Repair/RepairCompiler/MCC/test2.cc

   1
   2 // Token values
   3
   4 // Used = 100
   5 // Free = 101
   6
   7
   8 int __Success = 1;
   9
  10 // creating hashtables
  11 SimpleHash* __int___hash = new SimpleHash();
  12 SimpleHash* __FileBlock___hash = new SimpleHash();
  13 SimpleHash* __UsedBlock___hash = new SimpleHash();
  14 SimpleHash* __FileInode___hash = new SimpleHash();
  15 SimpleHash* __SuperBlock___hash = new SimpleHash();
  16 SimpleHash* __UsedInode___hash = new SimpleHash();
  17 SimpleHash* __InodeBitmapBlock___hash = new SimpleHash();
  18 SimpleHash* __BlockBitmapBlock___hash = new SimpleHash();
  19 SimpleHash* __FileDirectoryBlock___hash = new SimpleHash();
  20 SimpleHash* __token___hash = new SimpleHash();
  21 SimpleHash* __DirectoryEntry___hash = new SimpleHash();
  22 SimpleHash* __RootDirectoryInode___hash = new SimpleHash();
  23 SimpleHash* __FreeBlock___hash = new SimpleHash();
  24 SimpleHash* __GroupBlock___hash = new SimpleHash();
  25 SimpleHash* __Block___hash = new SimpleHash();
  26 SimpleHash* __DirectoryBlock___hash = new SimpleHash();
  27 SimpleHash* __FreeInode___hash = new SimpleHash();
  28 SimpleHash* __Inode___hash = new SimpleHash();
  29 SimpleHash* __DirectoryInode___hash = new SimpleHash();
  30 SimpleHash* __InodeTableBlock___hash = new SimpleHash();
  31 __SuperBlock___hash->addParent(__UsedBlock___hash);
  32 __GroupBlock___hash->addParent(__UsedBlock___hash);
  33 __FileDirectoryBlock___hash->addParent(__UsedBlock___hash);
  34 __InodeTableBlock___hash->addParent(__UsedBlock___hash);
  35 __InodeBitmapBlock___hash->addParent(__UsedBlock___hash);
  36 __BlockBitmapBlock___hash->addParent(__UsedBlock___hash);
  37 __FileInode___hash->addParent(__UsedInode___hash);
  38 __DirectoryInode___hash->addParent(__UsedInode___hash);
  39 __DirectoryBlock___hash->addParent(__FileDirectoryBlock___hash);
  40 __FileBlock___hash->addParent(__FileDirectoryBlock___hash);
  41 __UsedBlock___hash->addParent(__Block___hash);
  42 __FreeBlock___hash->addParent(__Block___hash);
  43 __UsedInode___hash->addParent(__Inode___hash);
  44 __FreeInode___hash->addParent(__Inode___hash);
  45 __RootDirectoryInode___hash->addParent(__DirectoryInode___hash);
  46 SimpleHash* __referencecount___hash = new SimpleHash();
  47 SimpleHash* __filesize___hash = new SimpleHash();
  48 SimpleHash* __inodeof___hashinv = new SimpleHash();
  49 SimpleHash* __contents___hash = new SimpleHash();
  50 SimpleHash* __contents___hashinv = new SimpleHash();
  51 SimpleHash* __inodestatus___hash = new SimpleHash();
  52 SimpleHash* __blockstatus___hash = new SimpleHash();
  53
  54
  55 // build rule1
  56   {
  57   //true
  58   int __tempvar0__ = 1;
  59   if (__tempvar0__)
  60     {
  61     int __element1__ = 0;
  62     int __addeditem2__ = 1;
  63     __addeditem2__ = __SuperBlock___hash->add((int)__element1__, (int)__element1__);
  64     }
  65   }
  66
  67
  68 // build rule2
  69   {
  70   //true
  71   int __tempvar3__ = 1;
  72   if (__tempvar3__)
  73     {
  74     int __element4__ = 1;
  75     int __addeditem5__ = 1;
  76     __addeditem5__ = __GroupBlock___hash->add((int)__element4__, (int)__element4__);
  77     }
  78   }
  79
  80
  81 // build rule3
  82   {
  83   //(d.g.InodeTableBlock < d.s.NumberofBlocks)
  84   // __left8__ <-- d.g
  85   // __left9__ <-- d
  86   int __left9__ = (int) d; //varexpr
  87   // __left9__ = d
  88   // __offsetinbits10__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
  89   int __leftop11__ = 0;
  90   int __leftop15__ = 8;
  91   // __left17__ <-- d.s
  92   // __left18__ <-- d
  93   int __left18__ = (int) d; //varexpr
  94   // __left18__ = d
  95   int __left17__ = (__left18__ + 0);
  96   int __leftop20__ = 32;
  97   int __leftop22__ = 32;
  98   int __leftop24__ = 32;
  99   int __leftop26__ = 32;
 100   int __leftop28__ = 32;
 101   int __leftop30__ = 32;
 102   int __rightop31__ = 0;
 103   int __rightop29__ = __leftop30__ + __rightop31__;
 104   int __rightop27__ = __leftop28__ + __rightop29__;
 105   int __rightop25__ = __leftop26__ + __rightop27__;
 106   int __rightop23__ = __leftop24__ + __rightop25__;
 107   int __rightop21__ = __leftop22__ + __rightop23__;
 108   int __sizeof19__ = __leftop20__ + __rightop21__;
 109   int __high32__ = __left17__ + __sizeof19__;
 110   assertvalidmemory(__left17__, __high32__);
 111   // __left17__ = d.s
 112   // __offsetinbits33__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 113   int __leftop34__ = 32;
 114   int __leftop36__ = 32;
 115   int __leftop38__ = 32;
 116   int __leftop40__ = 32;
 117   int __leftop42__ = 32;
 118   int __rightop43__ = 0;
 119   int __rightop41__ = __leftop42__ + __rightop43__;
 120   int __rightop39__ = __leftop40__ + __rightop41__;
 121   int __rightop37__ = __leftop38__ + __rightop39__;
 122   int __rightop35__ = __leftop36__ + __rightop37__;
 123   int __offsetinbits33__ = __leftop34__ + __rightop35__;
 124   // __offsetinbits33__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 125   int __offset44__ = __offsetinbits33__ >> 3;
 126   int __shift45__ = __offsetinbits33__ - (__offset44__ << 3);
 127   int __rightop16__ = ((*(int *)(__left17__ + __offset44__))  >> __shift45__) & 0xffffffff;
 128   int __leftop14__ = __leftop15__ * __rightop16__;
 129   int __rightop46__ = 0;
 130   int __leftop13__ = __leftop14__ + __rightop46__;
 131   int __rightop47__ = 1;
 132   int __rightop12__ = __leftop13__ * __rightop47__;
 133   int __offsetinbits10__ = __leftop11__ + __rightop12__;
 134   // __offsetinbits10__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 135   int __offset48__ = __offsetinbits10__ >> 3;
 136   int __left8__ = (__left9__ + __offset48__);
 137   int __leftop50__ = 32;
 138   int __leftop52__ = 32;
 139   int __leftop54__ = 32;
 140   int __leftop56__ = 32;
 141   int __leftop58__ = 32;
 142   int __rightop59__ = 0;
 143   int __rightop57__ = __leftop58__ + __rightop59__;
 144   int __rightop55__ = __leftop56__ + __rightop57__;
 145   int __rightop53__ = __leftop54__ + __rightop55__;
 146   int __rightop51__ = __leftop52__ + __rightop53__;
 147   int __sizeof49__ = __leftop50__ + __rightop51__;
 148   int __high60__ = __left8__ + __sizeof49__;
 149   assertvalidmemory(__left8__, __high60__);
 150   // __left8__ = d.g
 151   // __offsetinbits61__ <-- (32 + (32 + 0))
 152   int __leftop62__ = 32;
 153   int __leftop64__ = 32;
 154   int __rightop65__ = 0;
 155   int __rightop63__ = __leftop64__ + __rightop65__;
 156   int __offsetinbits61__ = __leftop62__ + __rightop63__;
 157   // __offsetinbits61__ = (32 + (32 + 0))
 158   int __offset66__ = __offsetinbits61__ >> 3;
 159   int __shift67__ = __offsetinbits61__ - (__offset66__ << 3);
 160   int __leftop7__ = ((*(int *)(__left8__ + __offset66__))  >> __shift67__) & 0xffffffff;
 161   // __left69__ <-- d.s
 162   // __left70__ <-- d
 163   int __left70__ = (int) d; //varexpr
 164   // __left70__ = d
 165   int __left69__ = (__left70__ + 0);
 166   int __leftop72__ = 32;
 167   int __leftop74__ = 32;
 168   int __leftop76__ = 32;
 169   int __leftop78__ = 32;
 170   int __leftop80__ = 32;
 171   int __leftop82__ = 32;
 172   int __rightop83__ = 0;
 173   int __rightop81__ = __leftop82__ + __rightop83__;
 174   int __rightop79__ = __leftop80__ + __rightop81__;
 175   int __rightop77__ = __leftop78__ + __rightop79__;
 176   int __rightop75__ = __leftop76__ + __rightop77__;
 177   int __rightop73__ = __leftop74__ + __rightop75__;
 178   int __sizeof71__ = __leftop72__ + __rightop73__;
 179   int __high84__ = __left69__ + __sizeof71__;
 180   assertvalidmemory(__left69__, __high84__);
 181   // __left69__ = d.s
 182   // __offsetinbits85__ <-- (32 + (32 + 0))
 183   int __leftop86__ = 32;
 184   int __leftop88__ = 32;
 185   int __rightop89__ = 0;
 186   int __rightop87__ = __leftop88__ + __rightop89__;
 187   int __offsetinbits85__ = __leftop86__ + __rightop87__;
 188   // __offsetinbits85__ = (32 + (32 + 0))
 189   int __offset90__ = __offsetinbits85__ >> 3;
 190   int __shift91__ = __offsetinbits85__ - (__offset90__ << 3);
 191   int __rightop68__ = ((*(int *)(__left69__ + __offset90__))  >> __shift91__) & 0xffffffff;
 192   int __tempvar6__ = __leftop7__ < __rightop68__;
 193   if (__tempvar6__)
 194     {
 195     // __left93__ <-- d.g
 196     // __left94__ <-- d
 197     int __left94__ = (int) d; //varexpr
 198     // __left94__ = d
 199     // __offsetinbits95__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 200     int __leftop96__ = 0;
 201     int __leftop100__ = 8;
 202     // __left102__ <-- d.s
 203     // __left103__ <-- d
 204     int __left103__ = (int) d; //varexpr
 205     // __left103__ = d
 206     int __left102__ = (__left103__ + 0);
 207     int __leftop105__ = 32;
 208     int __leftop107__ = 32;
 209     int __leftop109__ = 32;
 210     int __leftop111__ = 32;
 211     int __leftop113__ = 32;
 212     int __leftop115__ = 32;
 213     int __rightop116__ = 0;
 214     int __rightop114__ = __leftop115__ + __rightop116__;
 215     int __rightop112__ = __leftop113__ + __rightop114__;
 216     int __rightop110__ = __leftop111__ + __rightop112__;
 217     int __rightop108__ = __leftop109__ + __rightop110__;
 218     int __rightop106__ = __leftop107__ + __rightop108__;
 219     int __sizeof104__ = __leftop105__ + __rightop106__;
 220     int __high117__ = __left102__ + __sizeof104__;
 221     assertvalidmemory(__left102__, __high117__);
 222     // __left102__ = d.s
 223     // __offsetinbits118__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 224     int __leftop119__ = 32;
 225     int __leftop121__ = 32;
 226     int __leftop123__ = 32;
 227     int __leftop125__ = 32;
 228     int __leftop127__ = 32;
 229     int __rightop128__ = 0;
 230     int __rightop126__ = __leftop127__ + __rightop128__;
 231     int __rightop124__ = __leftop125__ + __rightop126__;
 232     int __rightop122__ = __leftop123__ + __rightop124__;
 233     int __rightop120__ = __leftop121__ + __rightop122__;
 234     int __offsetinbits118__ = __leftop119__ + __rightop120__;
 235     // __offsetinbits118__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 236     int __offset129__ = __offsetinbits118__ >> 3;
 237     int __shift130__ = __offsetinbits118__ - (__offset129__ << 3);
 238     int __rightop101__ = ((*(int *)(__left102__ + __offset129__))  >> __shift130__) & 0xffffffff;
 239     int __leftop99__ = __leftop100__ * __rightop101__;
 240     int __rightop131__ = 0;
 241     int __leftop98__ = __leftop99__ + __rightop131__;
 242     int __rightop132__ = 1;
 243     int __rightop97__ = __leftop98__ * __rightop132__;
 244     int __offsetinbits95__ = __leftop96__ + __rightop97__;
 245     // __offsetinbits95__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 246     int __offset133__ = __offsetinbits95__ >> 3;
 247     int __left93__ = (__left94__ + __offset133__);
 248     int __leftop135__ = 32;
 249     int __leftop137__ = 32;
 250     int __leftop139__ = 32;
 251     int __leftop141__ = 32;
 252     int __leftop143__ = 32;
 253     int __rightop144__ = 0;
 254     int __rightop142__ = __leftop143__ + __rightop144__;
 255     int __rightop140__ = __leftop141__ + __rightop142__;
 256     int __rightop138__ = __leftop139__ + __rightop140__;
 257     int __rightop136__ = __leftop137__ + __rightop138__;
 258     int __sizeof134__ = __leftop135__ + __rightop136__;
 259     int __high145__ = __left93__ + __sizeof134__;
 260     assertvalidmemory(__left93__, __high145__);
 261     // __left93__ = d.g
 262     // __offsetinbits146__ <-- (32 + (32 + 0))
 263     int __leftop147__ = 32;
 264     int __leftop149__ = 32;
 265     int __rightop150__ = 0;
 266     int __rightop148__ = __leftop149__ + __rightop150__;
 267     int __offsetinbits146__ = __leftop147__ + __rightop148__;
 268     // __offsetinbits146__ = (32 + (32 + 0))
 269     int __offset151__ = __offsetinbits146__ >> 3;
 270     int __shift152__ = __offsetinbits146__ - (__offset151__ << 3);
 271     int __element92__ = ((*(int *)(__left93__ + __offset151__))  >> __shift152__) & 0xffffffff;
 272     int __addeditem153__ = 1;
 273     __addeditem153__ = __InodeTableBlock___hash->add((int)__element92__, (int)__element92__);
 274     }
 275   }
 276
 277
 278 // build rule4
 279   {
 280   //(d.g.InodeBitmapBlock < d.s.NumberofBlocks)
 281   // __left156__ <-- d.g
 282   // __left157__ <-- d
 283   int __left157__ = (int) d; //varexpr
 284   // __left157__ = d
 285   // __offsetinbits158__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 286   int __leftop159__ = 0;
 287   int __leftop163__ = 8;
 288   // __left165__ <-- d.s
 289   // __left166__ <-- d
 290   int __left166__ = (int) d; //varexpr
 291   // __left166__ = d
 292   int __left165__ = (__left166__ + 0);
 293   int __leftop168__ = 32;
 294   int __leftop170__ = 32;
 295   int __leftop172__ = 32;
 296   int __leftop174__ = 32;
 297   int __leftop176__ = 32;
 298   int __leftop178__ = 32;
 299   int __rightop179__ = 0;
 300   int __rightop177__ = __leftop178__ + __rightop179__;
 301   int __rightop175__ = __leftop176__ + __rightop177__;
 302   int __rightop173__ = __leftop174__ + __rightop175__;
 303   int __rightop171__ = __leftop172__ + __rightop173__;
 304   int __rightop169__ = __leftop170__ + __rightop171__;
 305   int __sizeof167__ = __leftop168__ + __rightop169__;
 306   int __high180__ = __left165__ + __sizeof167__;
 307   assertvalidmemory(__left165__, __high180__);
 308   // __left165__ = d.s
 309   // __offsetinbits181__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 310   int __leftop182__ = 32;
 311   int __leftop184__ = 32;
 312   int __leftop186__ = 32;
 313   int __leftop188__ = 32;
 314   int __leftop190__ = 32;
 315   int __rightop191__ = 0;
 316   int __rightop189__ = __leftop190__ + __rightop191__;
 317   int __rightop187__ = __leftop188__ + __rightop189__;
 318   int __rightop185__ = __leftop186__ + __rightop187__;
 319   int __rightop183__ = __leftop184__ + __rightop185__;
 320   int __offsetinbits181__ = __leftop182__ + __rightop183__;
 321   // __offsetinbits181__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 322   int __offset192__ = __offsetinbits181__ >> 3;
 323   int __shift193__ = __offsetinbits181__ - (__offset192__ << 3);
 324   int __rightop164__ = ((*(int *)(__left165__ + __offset192__))  >> __shift193__) & 0xffffffff;
 325   int __leftop162__ = __leftop163__ * __rightop164__;
 326   int __rightop194__ = 0;
 327   int __leftop161__ = __leftop162__ + __rightop194__;
 328   int __rightop195__ = 1;
 329   int __rightop160__ = __leftop161__ * __rightop195__;
 330   int __offsetinbits158__ = __leftop159__ + __rightop160__;
 331   // __offsetinbits158__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 332   int __offset196__ = __offsetinbits158__ >> 3;
 333   int __left156__ = (__left157__ + __offset196__);
 334   int __leftop198__ = 32;
 335   int __leftop200__ = 32;
 336   int __leftop202__ = 32;
 337   int __leftop204__ = 32;
 338   int __leftop206__ = 32;
 339   int __rightop207__ = 0;
 340   int __rightop205__ = __leftop206__ + __rightop207__;
 341   int __rightop203__ = __leftop204__ + __rightop205__;
 342   int __rightop201__ = __leftop202__ + __rightop203__;
 343   int __rightop199__ = __leftop200__ + __rightop201__;
 344   int __sizeof197__ = __leftop198__ + __rightop199__;
 345   int __high208__ = __left156__ + __sizeof197__;
 346   assertvalidmemory(__left156__, __high208__);
 347   // __left156__ = d.g
 348   // __offsetinbits209__ <-- (32 + 0)
 349   int __leftop210__ = 32;
 350   int __rightop211__ = 0;
 351   int __offsetinbits209__ = __leftop210__ + __rightop211__;
 352   // __offsetinbits209__ = (32 + 0)
 353   int __offset212__ = __offsetinbits209__ >> 3;
 354   int __shift213__ = __offsetinbits209__ - (__offset212__ << 3);
 355   int __leftop155__ = ((*(int *)(__left156__ + __offset212__))  >> __shift213__) & 0xffffffff;
 356   // __left215__ <-- d.s
 357   // __left216__ <-- d
 358   int __left216__ = (int) d; //varexpr
 359   // __left216__ = d
 360   int __left215__ = (__left216__ + 0);
 361   int __leftop218__ = 32;
 362   int __leftop220__ = 32;
 363   int __leftop222__ = 32;
 364   int __leftop224__ = 32;
 365   int __leftop226__ = 32;
 366   int __leftop228__ = 32;
 367   int __rightop229__ = 0;
 368   int __rightop227__ = __leftop228__ + __rightop229__;
 369   int __rightop225__ = __leftop226__ + __rightop227__;
 370   int __rightop223__ = __leftop224__ + __rightop225__;
 371   int __rightop221__ = __leftop222__ + __rightop223__;
 372   int __rightop219__ = __leftop220__ + __rightop221__;
 373   int __sizeof217__ = __leftop218__ + __rightop219__;
 374   int __high230__ = __left215__ + __sizeof217__;
 375   assertvalidmemory(__left215__, __high230__);
 376   // __left215__ = d.s
 377   // __offsetinbits231__ <-- (32 + (32 + 0))
 378   int __leftop232__ = 32;
 379   int __leftop234__ = 32;
 380   int __rightop235__ = 0;
 381   int __rightop233__ = __leftop234__ + __rightop235__;
 382   int __offsetinbits231__ = __leftop232__ + __rightop233__;
 383   // __offsetinbits231__ = (32 + (32 + 0))
 384   int __offset236__ = __offsetinbits231__ >> 3;
 385   int __shift237__ = __offsetinbits231__ - (__offset236__ << 3);
 386   int __rightop214__ = ((*(int *)(__left215__ + __offset236__))  >> __shift237__) & 0xffffffff;
 387   int __tempvar154__ = __leftop155__ < __rightop214__;
 388   if (__tempvar154__)
 389     {
 390     // __left239__ <-- d.g
 391     // __left240__ <-- d
 392     int __left240__ = (int) d; //varexpr
 393     // __left240__ = d
 394     // __offsetinbits241__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 395     int __leftop242__ = 0;
 396     int __leftop246__ = 8;
 397     // __left248__ <-- d.s
 398     // __left249__ <-- d
 399     int __left249__ = (int) d; //varexpr
 400     // __left249__ = d
 401     int __left248__ = (__left249__ + 0);
 402     int __leftop251__ = 32;
 403     int __leftop253__ = 32;
 404     int __leftop255__ = 32;
 405     int __leftop257__ = 32;
 406     int __leftop259__ = 32;
 407     int __leftop261__ = 32;
 408     int __rightop262__ = 0;
 409     int __rightop260__ = __leftop261__ + __rightop262__;
 410     int __rightop258__ = __leftop259__ + __rightop260__;
 411     int __rightop256__ = __leftop257__ + __rightop258__;
 412     int __rightop254__ = __leftop255__ + __rightop256__;
 413     int __rightop252__ = __leftop253__ + __rightop254__;
 414     int __sizeof250__ = __leftop251__ + __rightop252__;
 415     int __high263__ = __left248__ + __sizeof250__;
 416     assertvalidmemory(__left248__, __high263__);
 417     // __left248__ = d.s
 418     // __offsetinbits264__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 419     int __leftop265__ = 32;
 420     int __leftop267__ = 32;
 421     int __leftop269__ = 32;
 422     int __leftop271__ = 32;
 423     int __leftop273__ = 32;
 424     int __rightop274__ = 0;
 425     int __rightop272__ = __leftop273__ + __rightop274__;
 426     int __rightop270__ = __leftop271__ + __rightop272__;
 427     int __rightop268__ = __leftop269__ + __rightop270__;
 428     int __rightop266__ = __leftop267__ + __rightop268__;
 429     int __offsetinbits264__ = __leftop265__ + __rightop266__;
 430     // __offsetinbits264__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 431     int __offset275__ = __offsetinbits264__ >> 3;
 432     int __shift276__ = __offsetinbits264__ - (__offset275__ << 3);
 433     int __rightop247__ = ((*(int *)(__left248__ + __offset275__))  >> __shift276__) & 0xffffffff;
 434     int __leftop245__ = __leftop246__ * __rightop247__;
 435     int __rightop277__ = 0;
 436     int __leftop244__ = __leftop245__ + __rightop277__;
 437     int __rightop278__ = 1;
 438     int __rightop243__ = __leftop244__ * __rightop278__;
 439     int __offsetinbits241__ = __leftop242__ + __rightop243__;
 440     // __offsetinbits241__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 441     int __offset279__ = __offsetinbits241__ >> 3;
 442     int __left239__ = (__left240__ + __offset279__);
 443     int __leftop281__ = 32;
 444     int __leftop283__ = 32;
 445     int __leftop285__ = 32;
 446     int __leftop287__ = 32;
 447     int __leftop289__ = 32;
 448     int __rightop290__ = 0;
 449     int __rightop288__ = __leftop289__ + __rightop290__;
 450     int __rightop286__ = __leftop287__ + __rightop288__;
 451     int __rightop284__ = __leftop285__ + __rightop286__;
 452     int __rightop282__ = __leftop283__ + __rightop284__;
 453     int __sizeof280__ = __leftop281__ + __rightop282__;
 454     int __high291__ = __left239__ + __sizeof280__;
 455     assertvalidmemory(__left239__, __high291__);
 456     // __left239__ = d.g
 457     // __offsetinbits292__ <-- (32 + 0)
 458     int __leftop293__ = 32;
 459     int __rightop294__ = 0;
 460     int __offsetinbits292__ = __leftop293__ + __rightop294__;
 461     // __offsetinbits292__ = (32 + 0)
 462     int __offset295__ = __offsetinbits292__ >> 3;
 463     int __shift296__ = __offsetinbits292__ - (__offset295__ << 3);
 464     int __element238__ = ((*(int *)(__left239__ + __offset295__))  >> __shift296__) & 0xffffffff;
 465     int __addeditem297__ = 1;
 466     __addeditem297__ = __InodeBitmapBlock___hash->add((int)__element238__, (int)__element238__);
 467     }
 468   }
 469
 470
 471 // build rule12
 472   {
 473   int __tempvar298__ = 0;
 474   // __left301__ <-- d.s
 475   // __left302__ <-- d
 476   int __left302__ = (int) d; //varexpr
 477   // __left302__ = d
 478   int __left301__ = (__left302__ + 0);
 479   int __leftop304__ = 32;
 480   int __leftop306__ = 32;
 481   int __leftop308__ = 32;
 482   int __leftop310__ = 32;
 483   int __leftop312__ = 32;
 484   int __leftop314__ = 32;
 485   int __rightop315__ = 0;
 486   int __rightop313__ = __leftop314__ + __rightop315__;
 487   int __rightop311__ = __leftop312__ + __rightop313__;
 488   int __rightop309__ = __leftop310__ + __rightop311__;
 489   int __rightop307__ = __leftop308__ + __rightop309__;
 490   int __rightop305__ = __leftop306__ + __rightop307__;
 491   int __sizeof303__ = __leftop304__ + __rightop305__;
 492   int __high316__ = __left301__ + __sizeof303__;
 493   assertvalidmemory(__left301__, __high316__);
 494   // __left301__ = d.s
 495   // __offsetinbits317__ <-- (32 + (32 + (32 + 0)))
 496   int __leftop318__ = 32;
 497   int __leftop320__ = 32;
 498   int __leftop322__ = 32;
 499   int __rightop323__ = 0;
 500   int __rightop321__ = __leftop322__ + __rightop323__;
 501   int __rightop319__ = __leftop320__ + __rightop321__;
 502   int __offsetinbits317__ = __leftop318__ + __rightop319__;
 503   // __offsetinbits317__ = (32 + (32 + (32 + 0)))
 504   int __offset324__ = __offsetinbits317__ >> 3;
 505   int __shift325__ = __offsetinbits317__ - (__offset324__ << 3);
 506   int __leftop300__ = ((*(int *)(__left301__ + __offset324__))  >> __shift325__) & 0xffffffff;
 507   int __rightop326__ = 1;
 508   int __tempvar299__ = __leftop300__ - __rightop326__;
 509   for (int __j__ = __tempvar298__; __j__ <= __tempvar299__; __j__++)
 510     {
 511     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); )
 512       {
 513       int __ibb__ = (int) __ibb___iterator->next();
 514       //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == false)
 515       // __left329__ <-- cast(__InodeBitmap__, d.b[ibb])
 516       // __left331__ <-- d
 517       int __left331__ = (int) d; //varexpr
 518       // __left331__ = d
 519       // __offsetinbits332__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
 520       int __leftop333__ = 0;
 521       int __leftop337__ = 8;
 522       // __left339__ <-- d.s
 523       // __left340__ <-- d
 524       int __left340__ = (int) d; //varexpr
 525       // __left340__ = d
 526       int __left339__ = (__left340__ + 0);
 527       int __leftop342__ = 32;
 528       int __leftop344__ = 32;
 529       int __leftop346__ = 32;
 530       int __leftop348__ = 32;
 531       int __leftop350__ = 32;
 532       int __leftop352__ = 32;
 533       int __rightop353__ = 0;
 534       int __rightop351__ = __leftop352__ + __rightop353__;
 535       int __rightop349__ = __leftop350__ + __rightop351__;
 536       int __rightop347__ = __leftop348__ + __rightop349__;
 537       int __rightop345__ = __leftop346__ + __rightop347__;
 538       int __rightop343__ = __leftop344__ + __rightop345__;
 539       int __sizeof341__ = __leftop342__ + __rightop343__;
 540       int __high354__ = __left339__ + __sizeof341__;
 541       assertvalidmemory(__left339__, __high354__);
 542       // __left339__ = d.s
 543       // __offsetinbits355__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 544       int __leftop356__ = 32;
 545       int __leftop358__ = 32;
 546       int __leftop360__ = 32;
 547       int __leftop362__ = 32;
 548       int __leftop364__ = 32;
 549       int __rightop365__ = 0;
 550       int __rightop363__ = __leftop364__ + __rightop365__;
 551       int __rightop361__ = __leftop362__ + __rightop363__;
 552       int __rightop359__ = __leftop360__ + __rightop361__;
 553       int __rightop357__ = __leftop358__ + __rightop359__;
 554       int __offsetinbits355__ = __leftop356__ + __rightop357__;
 555       // __offsetinbits355__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 556       int __offset366__ = __offsetinbits355__ >> 3;
 557       int __shift367__ = __offsetinbits355__ - (__offset366__ << 3);
 558       int __rightop338__ = ((*(int *)(__left339__ + __offset366__))  >> __shift367__) & 0xffffffff;
 559       int __leftop336__ = __leftop337__ * __rightop338__;
 560       int __rightop368__ = 0;
 561       int __leftop335__ = __leftop336__ + __rightop368__;
 562       int __rightop369__ = (int) __ibb__; //varexpr
 563       int __rightop334__ = __leftop335__ * __rightop369__;
 564       int __offsetinbits332__ = __leftop333__ + __rightop334__;
 565       // __offsetinbits332__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
 566       int __offset370__ = __offsetinbits332__ >> 3;
 567       int __expr330__ = (__left331__ + __offset370__);
 568       int __leftop373__ = 8;
 569       // __left375__ <-- d.s
 570       // __left376__ <-- d
 571       int __left376__ = (int) d; //varexpr
 572       // __left376__ = d
 573       int __left375__ = (__left376__ + 0);
 574       int __leftop378__ = 32;
 575       int __leftop380__ = 32;
 576       int __leftop382__ = 32;
 577       int __leftop384__ = 32;
 578       int __leftop386__ = 32;
 579       int __leftop388__ = 32;
 580       int __rightop389__ = 0;
 581       int __rightop387__ = __leftop388__ + __rightop389__;
 582       int __rightop385__ = __leftop386__ + __rightop387__;
 583       int __rightop383__ = __leftop384__ + __rightop385__;
 584       int __rightop381__ = __leftop382__ + __rightop383__;
 585       int __rightop379__ = __leftop380__ + __rightop381__;
 586       int __sizeof377__ = __leftop378__ + __rightop379__;
 587       int __high390__ = __left375__ + __sizeof377__;
 588       assertvalidmemory(__left375__, __high390__);
 589       // __left375__ = d.s
 590       // __offsetinbits391__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 591       int __leftop392__ = 32;
 592       int __leftop394__ = 32;
 593       int __leftop396__ = 32;
 594       int __leftop398__ = 32;
 595       int __leftop400__ = 32;
 596       int __rightop401__ = 0;
 597       int __rightop399__ = __leftop400__ + __rightop401__;
 598       int __rightop397__ = __leftop398__ + __rightop399__;
 599       int __rightop395__ = __leftop396__ + __rightop397__;
 600       int __rightop393__ = __leftop394__ + __rightop395__;
 601       int __offsetinbits391__ = __leftop392__ + __rightop393__;
 602       // __offsetinbits391__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 603       int __offset402__ = __offsetinbits391__ >> 3;
 604       int __shift403__ = __offsetinbits391__ - (__offset402__ << 3);
 605       int __rightop374__ = ((*(int *)(__left375__ + __offset402__))  >> __shift403__) & 0xffffffff;
 606       int __leftop372__ = __leftop373__ * __rightop374__;
 607       int __rightop404__ = 0;
 608       int __sizeof371__ = __leftop372__ + __rightop404__;
 609       int __high405__ = __expr330__ + __sizeof371__;
 610       assertvalidmemory(__expr330__, __high405__);
 611       int __left329__ = (int) __expr330__;
 612       // __left329__ = cast(__InodeBitmap__, d.b[ibb])
 613       // __offsetinbits406__ <-- (0 + (1 * j))
 614       int __leftop407__ = 0;
 615       int __leftop409__ = 1;
 616       int __rightop410__ = (int) __j__; //varexpr
 617       int __rightop408__ = __leftop409__ * __rightop410__;
 618       int __offsetinbits406__ = __leftop407__ + __rightop408__;
 619       // __offsetinbits406__ = (0 + (1 * j))
 620       int __offset411__ = __offsetinbits406__ >> 3;
 621       int __shift412__ = __offsetinbits406__ - (__offset411__ << 3);
 622       int __leftop328__ = ((*(int *)(__left329__ + __offset411__))  >> __shift412__) & 0x1;
 623       int __rightop413__ = 0;
 624       int __tempvar327__ = __leftop328__ == __rightop413__;
 625       if (__tempvar327__)
 626         {
 627         int __leftele414__ = (int) __j__; //varexpr
 628         int __rightele415__ = 101;
 629         int __addeditem417__;
 630         __addeditem417__ = __inodestatus___hash->add((int)__leftele414__, (int)__rightele415__);
 631         }
 632       }
 633     }
 634   }
 635
 636
 637 // build rule5
 638   {
 639   //(d.g.BlockBitmapBlock < d.s.NumberofBlocks)
 640   // __left420__ <-- d.g
 641   // __left421__ <-- d
 642   int __left421__ = (int) d; //varexpr
 643   // __left421__ = d
 644   // __offsetinbits422__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 645   int __leftop423__ = 0;
 646   int __leftop427__ = 8;
 647   // __left429__ <-- d.s
 648   // __left430__ <-- d
 649   int __left430__ = (int) d; //varexpr
 650   // __left430__ = d
 651   int __left429__ = (__left430__ + 0);
 652   int __leftop432__ = 32;
 653   int __leftop434__ = 32;
 654   int __leftop436__ = 32;
 655   int __leftop438__ = 32;
 656   int __leftop440__ = 32;
 657   int __leftop442__ = 32;
 658   int __rightop443__ = 0;
 659   int __rightop441__ = __leftop442__ + __rightop443__;
 660   int __rightop439__ = __leftop440__ + __rightop441__;
 661   int __rightop437__ = __leftop438__ + __rightop439__;
 662   int __rightop435__ = __leftop436__ + __rightop437__;
 663   int __rightop433__ = __leftop434__ + __rightop435__;
 664   int __sizeof431__ = __leftop432__ + __rightop433__;
 665   int __high444__ = __left429__ + __sizeof431__;
 666   assertvalidmemory(__left429__, __high444__);
 667   // __left429__ = d.s
 668   // __offsetinbits445__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 669   int __leftop446__ = 32;
 670   int __leftop448__ = 32;
 671   int __leftop450__ = 32;
 672   int __leftop452__ = 32;
 673   int __leftop454__ = 32;
 674   int __rightop455__ = 0;
 675   int __rightop453__ = __leftop454__ + __rightop455__;
 676   int __rightop451__ = __leftop452__ + __rightop453__;
 677   int __rightop449__ = __leftop450__ + __rightop451__;
 678   int __rightop447__ = __leftop448__ + __rightop449__;
 679   int __offsetinbits445__ = __leftop446__ + __rightop447__;
 680   // __offsetinbits445__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 681   int __offset456__ = __offsetinbits445__ >> 3;
 682   int __shift457__ = __offsetinbits445__ - (__offset456__ << 3);
 683   int __rightop428__ = ((*(int *)(__left429__ + __offset456__))  >> __shift457__) & 0xffffffff;
 684   int __leftop426__ = __leftop427__ * __rightop428__;
 685   int __rightop458__ = 0;
 686   int __leftop425__ = __leftop426__ + __rightop458__;
 687   int __rightop459__ = 1;
 688   int __rightop424__ = __leftop425__ * __rightop459__;
 689   int __offsetinbits422__ = __leftop423__ + __rightop424__;
 690   // __offsetinbits422__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 691   int __offset460__ = __offsetinbits422__ >> 3;
 692   int __left420__ = (__left421__ + __offset460__);
 693   int __leftop462__ = 32;
 694   int __leftop464__ = 32;
 695   int __leftop466__ = 32;
 696   int __leftop468__ = 32;
 697   int __leftop470__ = 32;
 698   int __rightop471__ = 0;
 699   int __rightop469__ = __leftop470__ + __rightop471__;
 700   int __rightop467__ = __leftop468__ + __rightop469__;
 701   int __rightop465__ = __leftop466__ + __rightop467__;
 702   int __rightop463__ = __leftop464__ + __rightop465__;
 703   int __sizeof461__ = __leftop462__ + __rightop463__;
 704   int __high472__ = __left420__ + __sizeof461__;
 705   assertvalidmemory(__left420__, __high472__);
 706   // __left420__ = d.g
 707   int __leftop419__ = ((*(int *)(__left420__ + 0))  >> 0) & 0xffffffff;
 708   // __left474__ <-- d.s
 709   // __left475__ <-- d
 710   int __left475__ = (int) d; //varexpr
 711   // __left475__ = d
 712   int __left474__ = (__left475__ + 0);
 713   int __leftop477__ = 32;
 714   int __leftop479__ = 32;
 715   int __leftop481__ = 32;
 716   int __leftop483__ = 32;
 717   int __leftop485__ = 32;
 718   int __leftop487__ = 32;
 719   int __rightop488__ = 0;
 720   int __rightop486__ = __leftop487__ + __rightop488__;
 721   int __rightop484__ = __leftop485__ + __rightop486__;
 722   int __rightop482__ = __leftop483__ + __rightop484__;
 723   int __rightop480__ = __leftop481__ + __rightop482__;
 724   int __rightop478__ = __leftop479__ + __rightop480__;
 725   int __sizeof476__ = __leftop477__ + __rightop478__;
 726   int __high489__ = __left474__ + __sizeof476__;
 727   assertvalidmemory(__left474__, __high489__);
 728   // __left474__ = d.s
 729   // __offsetinbits490__ <-- (32 + (32 + 0))
 730   int __leftop491__ = 32;
 731   int __leftop493__ = 32;
 732   int __rightop494__ = 0;
 733   int __rightop492__ = __leftop493__ + __rightop494__;
 734   int __offsetinbits490__ = __leftop491__ + __rightop492__;
 735   // __offsetinbits490__ = (32 + (32 + 0))
 736   int __offset495__ = __offsetinbits490__ >> 3;
 737   int __shift496__ = __offsetinbits490__ - (__offset495__ << 3);
 738   int __rightop473__ = ((*(int *)(__left474__ + __offset495__))  >> __shift496__) & 0xffffffff;
 739   int __tempvar418__ = __leftop419__ < __rightop473__;
 740   if (__tempvar418__)
 741     {
 742     // __left498__ <-- d.g
 743     // __left499__ <-- d
 744     int __left499__ = (int) d; //varexpr
 745     // __left499__ = d
 746     // __offsetinbits500__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 747     int __leftop501__ = 0;
 748     int __leftop505__ = 8;
 749     // __left507__ <-- d.s
 750     // __left508__ <-- d
 751     int __left508__ = (int) d; //varexpr
 752     // __left508__ = d
 753     int __left507__ = (__left508__ + 0);
 754     int __leftop510__ = 32;
 755     int __leftop512__ = 32;
 756     int __leftop514__ = 32;
 757     int __leftop516__ = 32;
 758     int __leftop518__ = 32;
 759     int __leftop520__ = 32;
 760     int __rightop521__ = 0;
 761     int __rightop519__ = __leftop520__ + __rightop521__;
 762     int __rightop517__ = __leftop518__ + __rightop519__;
 763     int __rightop515__ = __leftop516__ + __rightop517__;
 764     int __rightop513__ = __leftop514__ + __rightop515__;
 765     int __rightop511__ = __leftop512__ + __rightop513__;
 766     int __sizeof509__ = __leftop510__ + __rightop511__;
 767     int __high522__ = __left507__ + __sizeof509__;
 768     assertvalidmemory(__left507__, __high522__);
 769     // __left507__ = d.s
 770     // __offsetinbits523__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 771     int __leftop524__ = 32;
 772     int __leftop526__ = 32;
 773     int __leftop528__ = 32;
 774     int __leftop530__ = 32;
 775     int __leftop532__ = 32;
 776     int __rightop533__ = 0;
 777     int __rightop531__ = __leftop532__ + __rightop533__;
 778     int __rightop529__ = __leftop530__ + __rightop531__;
 779     int __rightop527__ = __leftop528__ + __rightop529__;
 780     int __rightop525__ = __leftop526__ + __rightop527__;
 781     int __offsetinbits523__ = __leftop524__ + __rightop525__;
 782     // __offsetinbits523__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 783     int __offset534__ = __offsetinbits523__ >> 3;
 784     int __shift535__ = __offsetinbits523__ - (__offset534__ << 3);
 785     int __rightop506__ = ((*(int *)(__left507__ + __offset534__))  >> __shift535__) & 0xffffffff;
 786     int __leftop504__ = __leftop505__ * __rightop506__;
 787     int __rightop536__ = 0;
 788     int __leftop503__ = __leftop504__ + __rightop536__;
 789     int __rightop537__ = 1;
 790     int __rightop502__ = __leftop503__ * __rightop537__;
 791     int __offsetinbits500__ = __leftop501__ + __rightop502__;
 792     // __offsetinbits500__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 793     int __offset538__ = __offsetinbits500__ >> 3;
 794     int __left498__ = (__left499__ + __offset538__);
 795     int __leftop540__ = 32;
 796     int __leftop542__ = 32;
 797     int __leftop544__ = 32;
 798     int __leftop546__ = 32;
 799     int __leftop548__ = 32;
 800     int __rightop549__ = 0;
 801     int __rightop547__ = __leftop548__ + __rightop549__;
 802     int __rightop545__ = __leftop546__ + __rightop547__;
 803     int __rightop543__ = __leftop544__ + __rightop545__;
 804     int __rightop541__ = __leftop542__ + __rightop543__;
 805     int __sizeof539__ = __leftop540__ + __rightop541__;
 806     int __high550__ = __left498__ + __sizeof539__;
 807     assertvalidmemory(__left498__, __high550__);
 808     // __left498__ = d.g
 809     int __element497__ = ((*(int *)(__left498__ + 0))  >> 0) & 0xffffffff;
 810     int __addeditem551__ = 1;
 811     __addeditem551__ = __BlockBitmapBlock___hash->add((int)__element497__, (int)__element497__);
 812     }
 813   }
 814
 815
 816 // build rule13
 817   {
 818   int __tempvar552__ = 0;
 819   // __left555__ <-- d.s
 820   // __left556__ <-- d
 821   int __left556__ = (int) d; //varexpr
 822   // __left556__ = d
 823   int __left555__ = (__left556__ + 0);
 824   int __leftop558__ = 32;
 825   int __leftop560__ = 32;
 826   int __leftop562__ = 32;
 827   int __leftop564__ = 32;
 828   int __leftop566__ = 32;
 829   int __leftop568__ = 32;
 830   int __rightop569__ = 0;
 831   int __rightop567__ = __leftop568__ + __rightop569__;
 832   int __rightop565__ = __leftop566__ + __rightop567__;
 833   int __rightop563__ = __leftop564__ + __rightop565__;
 834   int __rightop561__ = __leftop562__ + __rightop563__;
 835   int __rightop559__ = __leftop560__ + __rightop561__;
 836   int __sizeof557__ = __leftop558__ + __rightop559__;
 837   int __high570__ = __left555__ + __sizeof557__;
 838   assertvalidmemory(__left555__, __high570__);
 839   // __left555__ = d.s
 840   // __offsetinbits571__ <-- (32 + (32 + (32 + 0)))
 841   int __leftop572__ = 32;
 842   int __leftop574__ = 32;
 843   int __leftop576__ = 32;
 844   int __rightop577__ = 0;
 845   int __rightop575__ = __leftop576__ + __rightop577__;
 846   int __rightop573__ = __leftop574__ + __rightop575__;
 847   int __offsetinbits571__ = __leftop572__ + __rightop573__;
 848   // __offsetinbits571__ = (32 + (32 + (32 + 0)))
 849   int __offset578__ = __offsetinbits571__ >> 3;
 850   int __shift579__ = __offsetinbits571__ - (__offset578__ << 3);
 851   int __leftop554__ = ((*(int *)(__left555__ + __offset578__))  >> __shift579__) & 0xffffffff;
 852   int __rightop580__ = 1;
 853   int __tempvar553__ = __leftop554__ - __rightop580__;
 854   for (int __j__ = __tempvar552__; __j__ <= __tempvar553__; __j__++)
 855     {
 856     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); )
 857       {
 858       int __ibb__ = (int) __ibb___iterator->next();
 859       //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == true)
 860       // __left583__ <-- cast(__InodeBitmap__, d.b[ibb])
 861       // __left585__ <-- d
 862       int __left585__ = (int) d; //varexpr
 863       // __left585__ = d
 864       // __offsetinbits586__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
 865       int __leftop587__ = 0;
 866       int __leftop591__ = 8;
 867       // __left593__ <-- d.s
 868       // __left594__ <-- d
 869       int __left594__ = (int) d; //varexpr
 870       // __left594__ = d
 871       int __left593__ = (__left594__ + 0);
 872       int __leftop596__ = 32;
 873       int __leftop598__ = 32;
 874       int __leftop600__ = 32;
 875       int __leftop602__ = 32;
 876       int __leftop604__ = 32;
 877       int __leftop606__ = 32;
 878       int __rightop607__ = 0;
 879       int __rightop605__ = __leftop606__ + __rightop607__;
 880       int __rightop603__ = __leftop604__ + __rightop605__;
 881       int __rightop601__ = __leftop602__ + __rightop603__;
 882       int __rightop599__ = __leftop600__ + __rightop601__;
 883       int __rightop597__ = __leftop598__ + __rightop599__;
 884       int __sizeof595__ = __leftop596__ + __rightop597__;
 885       int __high608__ = __left593__ + __sizeof595__;
 886       assertvalidmemory(__left593__, __high608__);
 887       // __left593__ = d.s
 888       // __offsetinbits609__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 889       int __leftop610__ = 32;
 890       int __leftop612__ = 32;
 891       int __leftop614__ = 32;
 892       int __leftop616__ = 32;
 893       int __leftop618__ = 32;
 894       int __rightop619__ = 0;
 895       int __rightop617__ = __leftop618__ + __rightop619__;
 896       int __rightop615__ = __leftop616__ + __rightop617__;
 897       int __rightop613__ = __leftop614__ + __rightop615__;
 898       int __rightop611__ = __leftop612__ + __rightop613__;
 899       int __offsetinbits609__ = __leftop610__ + __rightop611__;
 900       // __offsetinbits609__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 901       int __offset620__ = __offsetinbits609__ >> 3;
 902       int __shift621__ = __offsetinbits609__ - (__offset620__ << 3);
 903       int __rightop592__ = ((*(int *)(__left593__ + __offset620__))  >> __shift621__) & 0xffffffff;
 904       int __leftop590__ = __leftop591__ * __rightop592__;
 905       int __rightop622__ = 0;
 906       int __leftop589__ = __leftop590__ + __rightop622__;
 907       int __rightop623__ = (int) __ibb__; //varexpr
 908       int __rightop588__ = __leftop589__ * __rightop623__;
 909       int __offsetinbits586__ = __leftop587__ + __rightop588__;
 910       // __offsetinbits586__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
 911       int __offset624__ = __offsetinbits586__ >> 3;
 912       int __expr584__ = (__left585__ + __offset624__);
 913       int __leftop627__ = 8;
 914       // __left629__ <-- d.s
 915       // __left630__ <-- d
 916       int __left630__ = (int) d; //varexpr
 917       // __left630__ = d
 918       int __left629__ = (__left630__ + 0);
 919       int __leftop632__ = 32;
 920       int __leftop634__ = 32;
 921       int __leftop636__ = 32;
 922       int __leftop638__ = 32;
 923       int __leftop640__ = 32;
 924       int __leftop642__ = 32;
 925       int __rightop643__ = 0;
 926       int __rightop641__ = __leftop642__ + __rightop643__;
 927       int __rightop639__ = __leftop640__ + __rightop641__;
 928       int __rightop637__ = __leftop638__ + __rightop639__;
 929       int __rightop635__ = __leftop636__ + __rightop637__;
 930       int __rightop633__ = __leftop634__ + __rightop635__;
 931       int __sizeof631__ = __leftop632__ + __rightop633__;
 932       int __high644__ = __left629__ + __sizeof631__;
 933       assertvalidmemory(__left629__, __high644__);
 934       // __left629__ = d.s
 935       // __offsetinbits645__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 936       int __leftop646__ = 32;
 937       int __leftop648__ = 32;
 938       int __leftop650__ = 32;
 939       int __leftop652__ = 32;
 940       int __leftop654__ = 32;
 941       int __rightop655__ = 0;
 942       int __rightop653__ = __leftop654__ + __rightop655__;
 943       int __rightop651__ = __leftop652__ + __rightop653__;
 944       int __rightop649__ = __leftop650__ + __rightop651__;
 945       int __rightop647__ = __leftop648__ + __rightop649__;
 946       int __offsetinbits645__ = __leftop646__ + __rightop647__;
 947       // __offsetinbits645__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 948       int __offset656__ = __offsetinbits645__ >> 3;
 949       int __shift657__ = __offsetinbits645__ - (__offset656__ << 3);
 950       int __rightop628__ = ((*(int *)(__left629__ + __offset656__))  >> __shift657__) & 0xffffffff;
 951       int __leftop626__ = __leftop627__ * __rightop628__;
 952       int __rightop658__ = 0;
 953       int __sizeof625__ = __leftop626__ + __rightop658__;
 954       int __high659__ = __expr584__ + __sizeof625__;
 955       assertvalidmemory(__expr584__, __high659__);
 956       int __left583__ = (int) __expr584__;
 957       // __left583__ = cast(__InodeBitmap__, d.b[ibb])
 958       // __offsetinbits660__ <-- (0 + (1 * j))
 959       int __leftop661__ = 0;
 960       int __leftop663__ = 1;
 961       int __rightop664__ = (int) __j__; //varexpr
 962       int __rightop662__ = __leftop663__ * __rightop664__;
 963       int __offsetinbits660__ = __leftop661__ + __rightop662__;
 964       // __offsetinbits660__ = (0 + (1 * j))
 965       int __offset665__ = __offsetinbits660__ >> 3;
 966       int __shift666__ = __offsetinbits660__ - (__offset665__ << 3);
 967       int __leftop582__ = ((*(int *)(__left583__ + __offset665__))  >> __shift666__) & 0x1;
 968       int __rightop667__ = 1;
 969       int __tempvar581__ = __leftop582__ == __rightop667__;
 970       if (__tempvar581__)
 971         {
 972         int __leftele668__ = (int) __j__; //varexpr
 973         int __rightele669__ = 100;
 974         int __addeditem671__;
 975         __addeditem671__ = __inodestatus___hash->add((int)__leftele668__, (int)__rightele669__);
 976         }
 977       }
 978     }
 979   }
 980
 981
 982 // build rule6
 983   {
 984   //(d.s.RootDirectoryInode < d.s.NumberofInodes)
 985   // __left674__ <-- d.s
 986   // __left675__ <-- d
 987   int __left675__ = (int) d; //varexpr
 988   // __left675__ = d
 989   int __left674__ = (__left675__ + 0);
 990   int __leftop677__ = 32;
 991   int __leftop679__ = 32;
 992   int __leftop681__ = 32;
 993   int __leftop683__ = 32;
 994   int __leftop685__ = 32;
 995   int __leftop687__ = 32;
 996   int __rightop688__ = 0;
 997   int __rightop686__ = __leftop687__ + __rightop688__;
 998   int __rightop684__ = __leftop685__ + __rightop686__;
 999   int __rightop682__ = __leftop683__ + __rightop684__;
1000   int __rightop680__ = __leftop681__ + __rightop682__;
1001   int __rightop678__ = __leftop679__ + __rightop680__;
1002   int __sizeof676__ = __leftop677__ + __rightop678__;
1003   int __high689__ = __left674__ + __sizeof676__;
1004   assertvalidmemory(__left674__, __high689__);
1005   // __left674__ = d.s
1006   // __offsetinbits690__ <-- (32 + (32 + (32 + (32 + 0))))
1007   int __leftop691__ = 32;
1008   int __leftop693__ = 32;
1009   int __leftop695__ = 32;
1010   int __leftop697__ = 32;
1011   int __rightop698__ = 0;
1012   int __rightop696__ = __leftop697__ + __rightop698__;
1013   int __rightop694__ = __leftop695__ + __rightop696__;
1014   int __rightop692__ = __leftop693__ + __rightop694__;
1015   int __offsetinbits690__ = __leftop691__ + __rightop692__;
1016   // __offsetinbits690__ = (32 + (32 + (32 + (32 + 0))))
1017   int __offset699__ = __offsetinbits690__ >> 3;
1018   int __shift700__ = __offsetinbits690__ - (__offset699__ << 3);
1019   int __leftop673__ = ((*(int *)(__left674__ + __offset699__))  >> __shift700__) & 0xffffffff;
1020   // __left702__ <-- d.s
1021   // __left703__ <-- d
1022   int __left703__ = (int) d; //varexpr
1023   // __left703__ = d
1024   int __left702__ = (__left703__ + 0);
1025   int __leftop705__ = 32;
1026   int __leftop707__ = 32;
1027   int __leftop709__ = 32;
1028   int __leftop711__ = 32;
1029   int __leftop713__ = 32;
1030   int __leftop715__ = 32;
1031   int __rightop716__ = 0;
1032   int __rightop714__ = __leftop715__ + __rightop716__;
1033   int __rightop712__ = __leftop713__ + __rightop714__;
1034   int __rightop710__ = __leftop711__ + __rightop712__;
1035   int __rightop708__ = __leftop709__ + __rightop710__;
1036   int __rightop706__ = __leftop707__ + __rightop708__;
1037   int __sizeof704__ = __leftop705__ + __rightop706__;
1038   int __high717__ = __left702__ + __sizeof704__;
1039   assertvalidmemory(__left702__, __high717__);
1040   // __left702__ = d.s
1041   // __offsetinbits718__ <-- (32 + (32 + (32 + 0)))
1042   int __leftop719__ = 32;
1043   int __leftop721__ = 32;
1044   int __leftop723__ = 32;
1045   int __rightop724__ = 0;
1046   int __rightop722__ = __leftop723__ + __rightop724__;
1047   int __rightop720__ = __leftop721__ + __rightop722__;
1048   int __offsetinbits718__ = __leftop719__ + __rightop720__;
1049   // __offsetinbits718__ = (32 + (32 + (32 + 0)))
1050   int __offset725__ = __offsetinbits718__ >> 3;
1051   int __shift726__ = __offsetinbits718__ - (__offset725__ << 3);
1052   int __rightop701__ = ((*(int *)(__left702__ + __offset725__))  >> __shift726__) & 0xffffffff;
1053   int __tempvar672__ = __leftop673__ < __rightop701__;
1054   if (__tempvar672__)
1055     {
1056     // __left728__ <-- d.s
1057     // __left729__ <-- d
1058     int __left729__ = (int) d; //varexpr
1059     // __left729__ = d
1060     int __left728__ = (__left729__ + 0);
1061     int __leftop731__ = 32;
1062     int __leftop733__ = 32;
1063     int __leftop735__ = 32;
1064     int __leftop737__ = 32;
1065     int __leftop739__ = 32;
1066     int __leftop741__ = 32;
1067     int __rightop742__ = 0;
1068     int __rightop740__ = __leftop741__ + __rightop742__;
1069     int __rightop738__ = __leftop739__ + __rightop740__;
1070     int __rightop736__ = __leftop737__ + __rightop738__;
1071     int __rightop734__ = __leftop735__ + __rightop736__;
1072     int __rightop732__ = __leftop733__ + __rightop734__;
1073     int __sizeof730__ = __leftop731__ + __rightop732__;
1074     int __high743__ = __left728__ + __sizeof730__;
1075     assertvalidmemory(__left728__, __high743__);
1076     // __left728__ = d.s
1077     // __offsetinbits744__ <-- (32 + (32 + (32 + (32 + 0))))
1078     int __leftop745__ = 32;
1079     int __leftop747__ = 32;
1080     int __leftop749__ = 32;
1081     int __leftop751__ = 32;
1082     int __rightop752__ = 0;
1083     int __rightop750__ = __leftop751__ + __rightop752__;
1084     int __rightop748__ = __leftop749__ + __rightop750__;
1085     int __rightop746__ = __leftop747__ + __rightop748__;
1086     int __offsetinbits744__ = __leftop745__ + __rightop746__;
1087     // __offsetinbits744__ = (32 + (32 + (32 + (32 + 0))))
1088     int __offset753__ = __offsetinbits744__ >> 3;
1089     int __shift754__ = __offsetinbits744__ - (__offset753__ << 3);
1090     int __element727__ = ((*(int *)(__left728__ + __offset753__))  >> __shift754__) & 0xffffffff;
1091     int __addeditem755__ = 1;
1092     __addeditem755__ = __RootDirectoryInode___hash->add((int)__element727__, (int)__element727__);
1093     }
1094   }
1095
1096
1097 // build rule9
1098   {
1099   for (SimpleIterator* __di___iterator = __DirectoryInode___hash->iterator(); __di___iterator->hasNext(); )
1100     {
1101     int __di__ = (int) __di___iterator->next();
1102     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
1103       {
1104       int __itb__ = (int) __itb___iterator->next();
1105       int __tempvar756__ = 0;
1106       // __left760__ <-- d.s
1107       // __left761__ <-- d
1108       int __left761__ = (int) d; //varexpr
1109       // __left761__ = d
1110       int __left760__ = (__left761__ + 0);
1111       int __leftop763__ = 32;
1112       int __leftop765__ = 32;
1113       int __leftop767__ = 32;
1114       int __leftop769__ = 32;
1115       int __leftop771__ = 32;
1116       int __leftop773__ = 32;
1117       int __rightop774__ = 0;
1118       int __rightop772__ = __leftop773__ + __rightop774__;
1119       int __rightop770__ = __leftop771__ + __rightop772__;
1120       int __rightop768__ = __leftop769__ + __rightop770__;
1121       int __rightop766__ = __leftop767__ + __rightop768__;
1122       int __rightop764__ = __leftop765__ + __rightop766__;
1123       int __sizeof762__ = __leftop763__ + __rightop764__;
1124       int __high775__ = __left760__ + __sizeof762__;
1125       assertvalidmemory(__left760__, __high775__);
1126       // __left760__ = d.s
1127       // __offsetinbits776__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1128       int __leftop777__ = 32;
1129       int __leftop779__ = 32;
1130       int __leftop781__ = 32;
1131       int __leftop783__ = 32;
1132       int __leftop785__ = 32;
1133       int __rightop786__ = 0;
1134       int __rightop784__ = __leftop785__ + __rightop786__;
1135       int __rightop782__ = __leftop783__ + __rightop784__;
1136       int __rightop780__ = __leftop781__ + __rightop782__;
1137       int __rightop778__ = __leftop779__ + __rightop780__;
1138       int __offsetinbits776__ = __leftop777__ + __rightop778__;
1139       // __offsetinbits776__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1140       int __offset787__ = __offsetinbits776__ >> 3;
1141       int __shift788__ = __offsetinbits776__ - (__offset787__ << 3);
1142       int __leftop759__ = ((*(int *)(__left760__ + __offset787__))  >> __shift788__) & 0xffffffff;
1143       int __rightop789__ = 128;
1144       int __leftop758__ = __leftop759__ / __rightop789__;
1145       int __rightop790__ = 1;
1146       int __tempvar757__ = __leftop758__ - __rightop790__;
1147       for (int __j__ = __tempvar756__; __j__ <= __tempvar757__; __j__++)
1148         {
1149         int __tempvar791__ = 0;
1150         int __tempvar792__ = 11;
1151         for (int __k__ = __tempvar791__; __k__ <= __tempvar792__; __k__++)
1152           {
1153           //(cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k] < d.s.NumberofBlocks)
1154           // __left795__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
1155           // __left796__ <-- cast(__InodeTable__, d.b[itb])
1156           // __left798__ <-- d
1157           int __left798__ = (int) d; //varexpr
1158           // __left798__ = d
1159           // __offsetinbits799__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1160           int __leftop800__ = 0;
1161           int __leftop804__ = 8;
1162           // __left806__ <-- d.s
1163           // __left807__ <-- d
1164           int __left807__ = (int) d; //varexpr
1165           // __left807__ = d
1166           int __left806__ = (__left807__ + 0);
1167           int __leftop809__ = 32;
1168           int __leftop811__ = 32;
1169           int __leftop813__ = 32;
1170           int __leftop815__ = 32;
1171           int __leftop817__ = 32;
1172           int __leftop819__ = 32;
1173           int __rightop820__ = 0;
1174           int __rightop818__ = __leftop819__ + __rightop820__;
1175           int __rightop816__ = __leftop817__ + __rightop818__;
1176           int __rightop814__ = __leftop815__ + __rightop816__;
1177           int __rightop812__ = __leftop813__ + __rightop814__;
1178           int __rightop810__ = __leftop811__ + __rightop812__;
1179           int __sizeof808__ = __leftop809__ + __rightop810__;
1180           int __high821__ = __left806__ + __sizeof808__;
1181           assertvalidmemory(__left806__, __high821__);
1182           // __left806__ = d.s
1183           // __offsetinbits822__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1184           int __leftop823__ = 32;
1185           int __leftop825__ = 32;
1186           int __leftop827__ = 32;
1187           int __leftop829__ = 32;
1188           int __leftop831__ = 32;
1189           int __rightop832__ = 0;
1190           int __rightop830__ = __leftop831__ + __rightop832__;
1191           int __rightop828__ = __leftop829__ + __rightop830__;
1192           int __rightop826__ = __leftop827__ + __rightop828__;
1193           int __rightop824__ = __leftop825__ + __rightop826__;
1194           int __offsetinbits822__ = __leftop823__ + __rightop824__;
1195           // __offsetinbits822__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1196           int __offset833__ = __offsetinbits822__ >> 3;
1197           int __shift834__ = __offsetinbits822__ - (__offset833__ << 3);
1198           int __rightop805__ = ((*(int *)(__left806__ + __offset833__))  >> __shift834__) & 0xffffffff;
1199           int __leftop803__ = __leftop804__ * __rightop805__;
1200           int __rightop835__ = 0;
1201           int __leftop802__ = __leftop803__ + __rightop835__;
1202           int __rightop836__ = (int) __itb__; //varexpr
1203           int __rightop801__ = __leftop802__ * __rightop836__;
1204           int __offsetinbits799__ = __leftop800__ + __rightop801__;
1205           // __offsetinbits799__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1206           int __offset837__ = __offsetinbits799__ >> 3;
1207           int __expr797__ = (__left798__ + __offset837__);
1208           int __leftop840__ = 8;
1209           // __left842__ <-- d.s
1210           // __left843__ <-- d
1211           int __left843__ = (int) d; //varexpr
1212           // __left843__ = d
1213           int __left842__ = (__left843__ + 0);
1214           int __leftop845__ = 32;
1215           int __leftop847__ = 32;
1216           int __leftop849__ = 32;
1217           int __leftop851__ = 32;
1218           int __leftop853__ = 32;
1219           int __leftop855__ = 32;
1220           int __rightop856__ = 0;
1221           int __rightop854__ = __leftop855__ + __rightop856__;
1222           int __rightop852__ = __leftop853__ + __rightop854__;
1223           int __rightop850__ = __leftop851__ + __rightop852__;
1224           int __rightop848__ = __leftop849__ + __rightop850__;
1225           int __rightop846__ = __leftop847__ + __rightop848__;
1226           int __sizeof844__ = __leftop845__ + __rightop846__;
1227           int __high857__ = __left842__ + __sizeof844__;
1228           assertvalidmemory(__left842__, __high857__);
1229           // __left842__ = d.s
1230           // __offsetinbits858__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1231           int __leftop859__ = 32;
1232           int __leftop861__ = 32;
1233           int __leftop863__ = 32;
1234           int __leftop865__ = 32;
1235           int __leftop867__ = 32;
1236           int __rightop868__ = 0;
1237           int __rightop866__ = __leftop867__ + __rightop868__;
1238           int __rightop864__ = __leftop865__ + __rightop866__;
1239           int __rightop862__ = __leftop863__ + __rightop864__;
1240           int __rightop860__ = __leftop861__ + __rightop862__;
1241           int __offsetinbits858__ = __leftop859__ + __rightop860__;
1242           // __offsetinbits858__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1243           int __offset869__ = __offsetinbits858__ >> 3;
1244           int __shift870__ = __offsetinbits858__ - (__offset869__ << 3);
1245           int __rightop841__ = ((*(int *)(__left842__ + __offset869__))  >> __shift870__) & 0xffffffff;
1246           int __leftop839__ = __leftop840__ * __rightop841__;
1247           int __rightop871__ = 0;
1248           int __sizeof838__ = __leftop839__ + __rightop871__;
1249           int __high872__ = __expr797__ + __sizeof838__;
1250           assertvalidmemory(__expr797__, __high872__);
1251           int __left796__ = (int) __expr797__;
1252           // __left796__ = cast(__InodeTable__, d.b[itb])
1253           // __offsetinbits873__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1254           int __leftop874__ = 0;
1255           int __leftop877__ = 32;
1256           int __leftop880__ = 32;
1257           int __rightop881__ = 12;
1258           int __leftop879__ = __leftop880__ * __rightop881__;
1259           int __leftop883__ = 32;
1260           int __rightop884__ = 0;
1261           int __rightop882__ = __leftop883__ + __rightop884__;
1262           int __rightop878__ = __leftop879__ + __rightop882__;
1263           int __leftop876__ = __leftop877__ + __rightop878__;
1264           int __rightop885__ = (int) __di__; //varexpr
1265           int __rightop875__ = __leftop876__ * __rightop885__;
1266           int __offsetinbits873__ = __leftop874__ + __rightop875__;
1267           // __offsetinbits873__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1268           int __offset886__ = __offsetinbits873__ >> 3;
1269           int __left795__ = (__left796__ + __offset886__);
1270           int __leftop888__ = 32;
1271           int __leftop891__ = 32;
1272           int __rightop892__ = 12;
1273           int __leftop890__ = __leftop891__ * __rightop892__;
1274           int __leftop894__ = 32;
1275           int __rightop895__ = 0;
1276           int __rightop893__ = __leftop894__ + __rightop895__;
1277           int __rightop889__ = __leftop890__ + __rightop893__;
1278           int __sizeof887__ = __leftop888__ + __rightop889__;
1279           int __high896__ = __left795__ + __sizeof887__;
1280           assertvalidmemory(__left795__, __high896__);
1281           // __left795__ = cast(__InodeTable__, d.b[itb]).itable[di]
1282           // __offsetinbits897__ <-- ((32 + 0) + (32 * k))
1283           int __leftop899__ = 32;
1284           int __rightop900__ = 0;
1285           int __leftop898__ = __leftop899__ + __rightop900__;
1286           int __leftop902__ = 32;
1287           int __rightop903__ = (int) __k__; //varexpr
1288           int __rightop901__ = __leftop902__ * __rightop903__;
1289           int __offsetinbits897__ = __leftop898__ + __rightop901__;
1290           // __offsetinbits897__ = ((32 + 0) + (32 * k))
1291           int __offset904__ = __offsetinbits897__ >> 3;
1292           int __shift905__ = __offsetinbits897__ - (__offset904__ << 3);
1293           int __leftop794__ = ((*(int *)(__left795__ + __offset904__))  >> __shift905__) & 0xffffffff;
1294           // __left907__ <-- d.s
1295           // __left908__ <-- d
1296           int __left908__ = (int) d; //varexpr
1297           // __left908__ = d
1298           int __left907__ = (__left908__ + 0);
1299           int __leftop910__ = 32;
1300           int __leftop912__ = 32;
1301           int __leftop914__ = 32;
1302           int __leftop916__ = 32;
1303           int __leftop918__ = 32;
1304           int __leftop920__ = 32;
1305           int __rightop921__ = 0;
1306           int __rightop919__ = __leftop920__ + __rightop921__;
1307           int __rightop917__ = __leftop918__ + __rightop919__;
1308           int __rightop915__ = __leftop916__ + __rightop917__;
1309           int __rightop913__ = __leftop914__ + __rightop915__;
1310           int __rightop911__ = __leftop912__ + __rightop913__;
1311           int __sizeof909__ = __leftop910__ + __rightop911__;
1312           int __high922__ = __left907__ + __sizeof909__;
1313           assertvalidmemory(__left907__, __high922__);
1314           // __left907__ = d.s
1315           // __offsetinbits923__ <-- (32 + (32 + 0))
1316           int __leftop924__ = 32;
1317           int __leftop926__ = 32;
1318           int __rightop927__ = 0;
1319           int __rightop925__ = __leftop926__ + __rightop927__;
1320           int __offsetinbits923__ = __leftop924__ + __rightop925__;
1321           // __offsetinbits923__ = (32 + (32 + 0))
1322           int __offset928__ = __offsetinbits923__ >> 3;
1323           int __shift929__ = __offsetinbits923__ - (__offset928__ << 3);
1324           int __rightop906__ = ((*(int *)(__left907__ + __offset928__))  >> __shift929__) & 0xffffffff;
1325           int __tempvar793__ = __leftop794__ < __rightop906__;
1326           if (__tempvar793__)
1327             {
1328             // __left931__ <-- cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
1329             // __left933__ <-- d
1330             int __left933__ = (int) d; //varexpr
1331             // __left933__ = d
1332             // __offsetinbits934__ <-- (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
1333             int __leftop935__ = 0;
1334             int __leftop939__ = 8;
1335             // __left941__ <-- d.s
1336             // __left942__ <-- d
1337             int __left942__ = (int) d; //varexpr
1338             // __left942__ = d
1339             int __left941__ = (__left942__ + 0);
1340             int __leftop944__ = 32;
1341             int __leftop946__ = 32;
1342             int __leftop948__ = 32;
1343             int __leftop950__ = 32;
1344             int __leftop952__ = 32;
1345             int __leftop954__ = 32;
1346             int __rightop955__ = 0;
1347             int __rightop953__ = __leftop954__ + __rightop955__;
1348             int __rightop951__ = __leftop952__ + __rightop953__;
1349             int __rightop949__ = __leftop950__ + __rightop951__;
1350             int __rightop947__ = __leftop948__ + __rightop949__;
1351             int __rightop945__ = __leftop946__ + __rightop947__;
1352             int __sizeof943__ = __leftop944__ + __rightop945__;
1353             int __high956__ = __left941__ + __sizeof943__;
1354             assertvalidmemory(__left941__, __high956__);
1355             // __left941__ = d.s
1356             // __offsetinbits957__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1357             int __leftop958__ = 32;
1358             int __leftop960__ = 32;
1359             int __leftop962__ = 32;
1360             int __leftop964__ = 32;
1361             int __leftop966__ = 32;
1362             int __rightop967__ = 0;
1363             int __rightop965__ = __leftop966__ + __rightop967__;
1364             int __rightop963__ = __leftop964__ + __rightop965__;
1365             int __rightop961__ = __leftop962__ + __rightop963__;
1366             int __rightop959__ = __leftop960__ + __rightop961__;
1367             int __offsetinbits957__ = __leftop958__ + __rightop959__;
1368             // __offsetinbits957__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1369             int __offset968__ = __offsetinbits957__ >> 3;
1370             int __shift969__ = __offsetinbits957__ - (__offset968__ << 3);
1371             int __rightop940__ = ((*(int *)(__left941__ + __offset968__))  >> __shift969__) & 0xffffffff;
1372             int __leftop938__ = __leftop939__ * __rightop940__;
1373             int __rightop970__ = 0;
1374             int __leftop937__ = __leftop938__ + __rightop970__;
1375             // __left972__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
1376             // __left973__ <-- cast(__InodeTable__, d.b[itb])
1377             // __left975__ <-- d
1378             int __left975__ = (int) d; //varexpr
1379             // __left975__ = d
1380             // __offsetinbits976__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1381             int __leftop977__ = 0;
1382             int __leftop981__ = 8;
1383             // __left983__ <-- d.s
1384             // __left984__ <-- d
1385             int __left984__ = (int) d; //varexpr
1386             // __left984__ = d
1387             int __left983__ = (__left984__ + 0);
1388             int __leftop986__ = 32;
1389             int __leftop988__ = 32;
1390             int __leftop990__ = 32;
1391             int __leftop992__ = 32;
1392             int __leftop994__ = 32;
1393             int __leftop996__ = 32;
1394             int __rightop997__ = 0;
1395             int __rightop995__ = __leftop996__ + __rightop997__;
1396             int __rightop993__ = __leftop994__ + __rightop995__;
1397             int __rightop991__ = __leftop992__ + __rightop993__;
1398             int __rightop989__ = __leftop990__ + __rightop991__;
1399             int __rightop987__ = __leftop988__ + __rightop989__;
1400             int __sizeof985__ = __leftop986__ + __rightop987__;
1401             int __high998__ = __left983__ + __sizeof985__;
1402             assertvalidmemory(__left983__, __high998__);
1403             // __left983__ = d.s
1404             // __offsetinbits999__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1405             int __leftop1000__ = 32;
1406             int __leftop1002__ = 32;
1407             int __leftop1004__ = 32;
1408             int __leftop1006__ = 32;
1409             int __leftop1008__ = 32;
1410             int __rightop1009__ = 0;
1411             int __rightop1007__ = __leftop1008__ + __rightop1009__;
1412             int __rightop1005__ = __leftop1006__ + __rightop1007__;
1413             int __rightop1003__ = __leftop1004__ + __rightop1005__;
1414             int __rightop1001__ = __leftop1002__ + __rightop1003__;
1415             int __offsetinbits999__ = __leftop1000__ + __rightop1001__;
1416             // __offsetinbits999__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1417             int __offset1010__ = __offsetinbits999__ >> 3;
1418             int __shift1011__ = __offsetinbits999__ - (__offset1010__ << 3);
1419             int __rightop982__ = ((*(int *)(__left983__ + __offset1010__))  >> __shift1011__) & 0xffffffff;
1420             int __leftop980__ = __leftop981__ * __rightop982__;
1421             int __rightop1012__ = 0;
1422             int __leftop979__ = __leftop980__ + __rightop1012__;
1423             int __rightop1013__ = (int) __itb__; //varexpr
1424             int __rightop978__ = __leftop979__ * __rightop1013__;
1425             int __offsetinbits976__ = __leftop977__ + __rightop978__;
1426             // __offsetinbits976__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1427             int __offset1014__ = __offsetinbits976__ >> 3;
1428             int __expr974__ = (__left975__ + __offset1014__);
1429             int __leftop1017__ = 8;
1430             // __left1019__ <-- d.s
1431             // __left1020__ <-- d
1432             int __left1020__ = (int) d; //varexpr
1433             // __left1020__ = d
1434             int __left1019__ = (__left1020__ + 0);
1435             int __leftop1022__ = 32;
1436             int __leftop1024__ = 32;
1437             int __leftop1026__ = 32;
1438             int __leftop1028__ = 32;
1439             int __leftop1030__ = 32;
1440             int __leftop1032__ = 32;
1441             int __rightop1033__ = 0;
1442             int __rightop1031__ = __leftop1032__ + __rightop1033__;
1443             int __rightop1029__ = __leftop1030__ + __rightop1031__;
1444             int __rightop1027__ = __leftop1028__ + __rightop1029__;
1445             int __rightop1025__ = __leftop1026__ + __rightop1027__;
1446             int __rightop1023__ = __leftop1024__ + __rightop1025__;
1447             int __sizeof1021__ = __leftop1022__ + __rightop1023__;
1448             int __high1034__ = __left1019__ + __sizeof1021__;
1449             assertvalidmemory(__left1019__, __high1034__);
1450             // __left1019__ = d.s
1451             // __offsetinbits1035__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1452             int __leftop1036__ = 32;
1453             int __leftop1038__ = 32;
1454             int __leftop1040__ = 32;
1455             int __leftop1042__ = 32;
1456             int __leftop1044__ = 32;
1457             int __rightop1045__ = 0;
1458             int __rightop1043__ = __leftop1044__ + __rightop1045__;
1459             int __rightop1041__ = __leftop1042__ + __rightop1043__;
1460             int __rightop1039__ = __leftop1040__ + __rightop1041__;
1461             int __rightop1037__ = __leftop1038__ + __rightop1039__;
1462             int __offsetinbits1035__ = __leftop1036__ + __rightop1037__;
1463             // __offsetinbits1035__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1464             int __offset1046__ = __offsetinbits1035__ >> 3;
1465             int __shift1047__ = __offsetinbits1035__ - (__offset1046__ << 3);
1466             int __rightop1018__ = ((*(int *)(__left1019__ + __offset1046__))  >> __shift1047__) & 0xffffffff;
1467             int __leftop1016__ = __leftop1017__ * __rightop1018__;
1468             int __rightop1048__ = 0;
1469             int __sizeof1015__ = __leftop1016__ + __rightop1048__;
1470             int __high1049__ = __expr974__ + __sizeof1015__;
1471             assertvalidmemory(__expr974__, __high1049__);
1472             int __left973__ = (int) __expr974__;
1473             // __left973__ = cast(__InodeTable__, d.b[itb])
1474             // __offsetinbits1050__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1475             int __leftop1051__ = 0;
1476             int __leftop1054__ = 32;
1477             int __leftop1057__ = 32;
1478             int __rightop1058__ = 12;
1479             int __leftop1056__ = __leftop1057__ * __rightop1058__;
1480             int __leftop1060__ = 32;
1481             int __rightop1061__ = 0;
1482             int __rightop1059__ = __leftop1060__ + __rightop1061__;
1483             int __rightop1055__ = __leftop1056__ + __rightop1059__;
1484             int __leftop1053__ = __leftop1054__ + __rightop1055__;
1485             int __rightop1062__ = (int) __di__; //varexpr
1486             int __rightop1052__ = __leftop1053__ * __rightop1062__;
1487             int __offsetinbits1050__ = __leftop1051__ + __rightop1052__;
1488             // __offsetinbits1050__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1489             int __offset1063__ = __offsetinbits1050__ >> 3;
1490             int __left972__ = (__left973__ + __offset1063__);
1491             int __leftop1065__ = 32;
1492             int __leftop1068__ = 32;
1493             int __rightop1069__ = 12;
1494             int __leftop1067__ = __leftop1068__ * __rightop1069__;
1495             int __leftop1071__ = 32;
1496             int __rightop1072__ = 0;
1497             int __rightop1070__ = __leftop1071__ + __rightop1072__;
1498             int __rightop1066__ = __leftop1067__ + __rightop1070__;
1499             int __sizeof1064__ = __leftop1065__ + __rightop1066__;
1500             int __high1073__ = __left972__ + __sizeof1064__;
1501             assertvalidmemory(__left972__, __high1073__);
1502             // __left972__ = cast(__InodeTable__, d.b[itb]).itable[di]
1503             // __offsetinbits1074__ <-- ((32 + 0) + (32 * k))
1504             int __leftop1076__ = 32;
1505             int __rightop1077__ = 0;
1506             int __leftop1075__ = __leftop1076__ + __rightop1077__;
1507             int __leftop1079__ = 32;
1508             int __rightop1080__ = (int) __k__; //varexpr
1509             int __rightop1078__ = __leftop1079__ * __rightop1080__;
1510             int __offsetinbits1074__ = __leftop1075__ + __rightop1078__;
1511             // __offsetinbits1074__ = ((32 + 0) + (32 * k))
1512             int __offset1081__ = __offsetinbits1074__ >> 3;
1513             int __shift1082__ = __offsetinbits1074__ - (__offset1081__ << 3);
1514             int __rightop971__ = ((*(int *)(__left972__ + __offset1081__))  >> __shift1082__) & 0xffffffff;
1515             int __rightop936__ = __leftop937__ * __rightop971__;
1516             int __offsetinbits934__ = __leftop935__ + __rightop936__;
1517             // __offsetinbits934__ = (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
1518             int __offset1083__ = __offsetinbits934__ >> 3;
1519             int __expr932__ = (__left933__ + __offset1083__);
1520             int __leftop1086__ = 8;
1521             // __left1088__ <-- d.s
1522             // __left1089__ <-- d
1523             int __left1089__ = (int) d; //varexpr
1524             // __left1089__ = d
1525             int __left1088__ = (__left1089__ + 0);
1526             int __leftop1091__ = 32;
1527             int __leftop1093__ = 32;
1528             int __leftop1095__ = 32;
1529             int __leftop1097__ = 32;
1530             int __leftop1099__ = 32;
1531             int __leftop1101__ = 32;
1532             int __rightop1102__ = 0;
1533             int __rightop1100__ = __leftop1101__ + __rightop1102__;
1534             int __rightop1098__ = __leftop1099__ + __rightop1100__;
1535             int __rightop1096__ = __leftop1097__ + __rightop1098__;
1536             int __rightop1094__ = __leftop1095__ + __rightop1096__;
1537             int __rightop1092__ = __leftop1093__ + __rightop1094__;
1538             int __sizeof1090__ = __leftop1091__ + __rightop1092__;
1539             int __high1103__ = __left1088__ + __sizeof1090__;
1540             assertvalidmemory(__left1088__, __high1103__);
1541             // __left1088__ = d.s
1542             // __offsetinbits1104__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1543             int __leftop1105__ = 32;
1544             int __leftop1107__ = 32;
1545             int __leftop1109__ = 32;
1546             int __leftop1111__ = 32;
1547             int __leftop1113__ = 32;
1548             int __rightop1114__ = 0;
1549             int __rightop1112__ = __leftop1113__ + __rightop1114__;
1550             int __rightop1110__ = __leftop1111__ + __rightop1112__;
1551             int __rightop1108__ = __leftop1109__ + __rightop1110__;
1552             int __rightop1106__ = __leftop1107__ + __rightop1108__;
1553             int __offsetinbits1104__ = __leftop1105__ + __rightop1106__;
1554             // __offsetinbits1104__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1555             int __offset1115__ = __offsetinbits1104__ >> 3;
1556             int __shift1116__ = __offsetinbits1104__ - (__offset1115__ << 3);
1557             int __rightop1087__ = ((*(int *)(__left1088__ + __offset1115__))  >> __shift1116__) & 0xffffffff;
1558             int __leftop1085__ = __leftop1086__ * __rightop1087__;
1559             int __rightop1117__ = 0;
1560             int __sizeof1084__ = __leftop1085__ + __rightop1117__;
1561             int __high1118__ = __expr932__ + __sizeof1084__;
1562             assertvalidmemory(__expr932__, __high1118__);
1563             int __left931__ = (int) __expr932__;
1564             // __left931__ = cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
1565             // __offsetinbits1119__ <-- (0 + ((32 + ((8 * 124) + 0)) * j))
1566             int __leftop1120__ = 0;
1567             int __leftop1123__ = 32;
1568             int __leftop1126__ = 8;
1569             int __rightop1127__ = 124;
1570             int __leftop1125__ = __leftop1126__ * __rightop1127__;
1571             int __rightop1128__ = 0;
1572             int __rightop1124__ = __leftop1125__ + __rightop1128__;
1573             int __leftop1122__ = __leftop1123__ + __rightop1124__;
1574             int __rightop1129__ = (int) __j__; //varexpr
1575             int __rightop1121__ = __leftop1122__ * __rightop1129__;
1576             int __offsetinbits1119__ = __leftop1120__ + __rightop1121__;
1577             // __offsetinbits1119__ = (0 + ((32 + ((8 * 124) + 0)) * j))
1578             int __offset1130__ = __offsetinbits1119__ >> 3;
1579             int __element930__ = (__left931__ + __offset1130__);
1580             int __leftop1132__ = 32;
1581             int __leftop1135__ = 8;
1582             int __rightop1136__ = 124;
1583             int __leftop1134__ = __leftop1135__ * __rightop1136__;
1584             int __rightop1137__ = 0;
1585             int __rightop1133__ = __leftop1134__ + __rightop1137__;
1586             int __sizeof1131__ = __leftop1132__ + __rightop1133__;
1587             int __high1138__ = __element930__ + __sizeof1131__;
1588             assertvalidmemory(__element930__, __high1138__);
1589             int __addeditem1139__ = 1;
1590             __addeditem1139__ = __DirectoryEntry___hash->add((int)__element930__, (int)__element930__);
1591             }
1592           }
1593         }
1594       }
1595     }
1596   }
1597
1598
1599 // build rule27
1600   {
1601   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); )
1602     {
1603     int __de__ = (int) __de___iterator->next();
1604     //((de.inodenumber < d.s.NumberofInodes) && ((de.inodenumber == 0)))
1605     // __left1143__ <-- de
1606     int __left1143__ = (int) __de__; //varexpr
1607     // __left1143__ = de
1608     // __offsetinbits1144__ <-- ((8 * 124) + 0)
1609     int __leftop1146__ = 8;
1610     int __rightop1147__ = 124;
1611     int __leftop1145__ = __leftop1146__ * __rightop1147__;
1612     int __rightop1148__ = 0;
1613     int __offsetinbits1144__ = __leftop1145__ + __rightop1148__;
1614     // __offsetinbits1144__ = ((8 * 124) + 0)
1615     int __offset1149__ = __offsetinbits1144__ >> 3;
1616     int __shift1150__ = __offsetinbits1144__ - (__offset1149__ << 3);
1617     int __leftop1142__ = ((*(int *)(__left1143__ + __offset1149__))  >> __shift1150__) & 0xffffffff;
1618     // __left1152__ <-- d.s
1619     // __left1153__ <-- d
1620     int __left1153__ = (int) d; //varexpr
1621     // __left1153__ = d
1622     int __left1152__ = (__left1153__ + 0);
1623     int __leftop1155__ = 32;
1624     int __leftop1157__ = 32;
1625     int __leftop1159__ = 32;
1626     int __leftop1161__ = 32;
1627     int __leftop1163__ = 32;
1628     int __leftop1165__ = 32;
1629     int __rightop1166__ = 0;
1630     int __rightop1164__ = __leftop1165__ + __rightop1166__;
1631     int __rightop1162__ = __leftop1163__ + __rightop1164__;
1632     int __rightop1160__ = __leftop1161__ + __rightop1162__;
1633     int __rightop1158__ = __leftop1159__ + __rightop1160__;
1634     int __rightop1156__ = __leftop1157__ + __rightop1158__;
1635     int __sizeof1154__ = __leftop1155__ + __rightop1156__;
1636     int __high1167__ = __left1152__ + __sizeof1154__;
1637     assertvalidmemory(__left1152__, __high1167__);
1638     // __left1152__ = d.s
1639     // __offsetinbits1168__ <-- (32 + (32 + (32 + 0)))
1640     int __leftop1169__ = 32;
1641     int __leftop1171__ = 32;
1642     int __leftop1173__ = 32;
1643     int __rightop1174__ = 0;
1644     int __rightop1172__ = __leftop1173__ + __rightop1174__;
1645     int __rightop1170__ = __leftop1171__ + __rightop1172__;
1646     int __offsetinbits1168__ = __leftop1169__ + __rightop1170__;
1647     // __offsetinbits1168__ = (32 + (32 + (32 + 0)))
1648     int __offset1175__ = __offsetinbits1168__ >> 3;
1649     int __shift1176__ = __offsetinbits1168__ - (__offset1175__ << 3);
1650     int __rightop1151__ = ((*(int *)(__left1152__ + __offset1175__))  >> __shift1176__) & 0xffffffff;
1651     int __leftop1141__ = __leftop1142__ < __rightop1151__;
1652     // __left1180__ <-- de
1653     int __left1180__ = (int) __de__; //varexpr
1654     // __left1180__ = de
1655     // __offsetinbits1181__ <-- ((8 * 124) + 0)
1656     int __leftop1183__ = 8;
1657     int __rightop1184__ = 124;
1658     int __leftop1182__ = __leftop1183__ * __rightop1184__;
1659     int __rightop1185__ = 0;
1660     int __offsetinbits1181__ = __leftop1182__ + __rightop1185__;
1661     // __offsetinbits1181__ = ((8 * 124) + 0)
1662     int __offset1186__ = __offsetinbits1181__ >> 3;
1663     int __shift1187__ = __offsetinbits1181__ - (__offset1186__ << 3);
1664     int __leftop1179__ = ((*(int *)(__left1180__ + __offset1186__))  >> __shift1187__) & 0xffffffff;
1665     int __rightop1188__ = 0;
1666     int __leftop1178__ = __leftop1179__ == __rightop1188__;
1667     int __rightop1177__ = !__leftop1178__;
1668     int __tempvar1140__ = __leftop1141__ && __rightop1177__;
1669     if (__tempvar1140__)
1670       {
1671       // __left1190__ <-- de
1672       int __left1190__ = (int) __de__; //varexpr
1673       // __left1190__ = de
1674       // __offsetinbits1191__ <-- ((8 * 124) + 0)
1675       int __leftop1193__ = 8;
1676       int __rightop1194__ = 124;
1677       int __leftop1192__ = __leftop1193__ * __rightop1194__;
1678       int __rightop1195__ = 0;
1679       int __offsetinbits1191__ = __leftop1192__ + __rightop1195__;
1680       // __offsetinbits1191__ = ((8 * 124) + 0)
1681       int __offset1196__ = __offsetinbits1191__ >> 3;
1682       int __shift1197__ = __offsetinbits1191__ - (__offset1196__ << 3);
1683       int __element1189__ = ((*(int *)(__left1190__ + __offset1196__))  >> __shift1197__) & 0xffffffff;
1684       int __addeditem1198__ = 1;
1685       __addeditem1198__ = __Inode___hash->add((int)__element1189__, (int)__element1189__);
1686       }
1687     }
1688   }
1689
1690
1691 // build rule15
1692   {
1693   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); )
1694     {
1695     int __de__ = (int) __de___iterator->next();
1696     //(de.inodenumber < d.s.NumberofInodes)
1697     // __left1201__ <-- de
1698     int __left1201__ = (int) __de__; //varexpr
1699     // __left1201__ = de
1700     // __offsetinbits1202__ <-- ((8 * 124) + 0)
1701     int __leftop1204__ = 8;
1702     int __rightop1205__ = 124;
1703     int __leftop1203__ = __leftop1204__ * __rightop1205__;
1704     int __rightop1206__ = 0;
1705     int __offsetinbits1202__ = __leftop1203__ + __rightop1206__;
1706     // __offsetinbits1202__ = ((8 * 124) + 0)
1707     int __offset1207__ = __offsetinbits1202__ >> 3;
1708     int __shift1208__ = __offsetinbits1202__ - (__offset1207__ << 3);
1709     int __leftop1200__ = ((*(int *)(__left1201__ + __offset1207__))  >> __shift1208__) & 0xffffffff;
1710     // __left1210__ <-- d.s
1711     // __left1211__ <-- d
1712     int __left1211__ = (int) d; //varexpr
1713     // __left1211__ = d
1714     int __left1210__ = (__left1211__ + 0);
1715     int __leftop1213__ = 32;
1716     int __leftop1215__ = 32;
1717     int __leftop1217__ = 32;
1718     int __leftop1219__ = 32;
1719     int __leftop1221__ = 32;
1720     int __leftop1223__ = 32;
1721     int __rightop1224__ = 0;
1722     int __rightop1222__ = __leftop1223__ + __rightop1224__;
1723     int __rightop1220__ = __leftop1221__ + __rightop1222__;
1724     int __rightop1218__ = __leftop1219__ + __rightop1220__;
1725     int __rightop1216__ = __leftop1217__ + __rightop1218__;
1726     int __rightop1214__ = __leftop1215__ + __rightop1216__;
1727     int __sizeof1212__ = __leftop1213__ + __rightop1214__;
1728     int __high1225__ = __left1210__ + __sizeof1212__;
1729     assertvalidmemory(__left1210__, __high1225__);
1730     // __left1210__ = d.s
1731     // __offsetinbits1226__ <-- (32 + (32 + (32 + 0)))
1732     int __leftop1227__ = 32;
1733     int __leftop1229__ = 32;
1734     int __leftop1231__ = 32;
1735     int __rightop1232__ = 0;
1736     int __rightop1230__ = __leftop1231__ + __rightop1232__;
1737     int __rightop1228__ = __leftop1229__ + __rightop1230__;
1738     int __offsetinbits1226__ = __leftop1227__ + __rightop1228__;
1739     // __offsetinbits1226__ = (32 + (32 + (32 + 0)))
1740     int __offset1233__ = __offsetinbits1226__ >> 3;
1741     int __shift1234__ = __offsetinbits1226__ - (__offset1233__ << 3);
1742     int __rightop1209__ = ((*(int *)(__left1210__ + __offset1233__))  >> __shift1234__) & 0xffffffff;
1743     int __tempvar1199__ = __leftop1200__ < __rightop1209__;
1744     if (__tempvar1199__)
1745       {
1746       int __leftele1235__ = (int) __de__; //varexpr
1747       // __left1237__ <-- de
1748       int __left1237__ = (int) __de__; //varexpr
1749       // __left1237__ = de
1750       // __offsetinbits1238__ <-- ((8 * 124) + 0)
1751       int __leftop1240__ = 8;
1752       int __rightop1241__ = 124;
1753       int __leftop1239__ = __leftop1240__ * __rightop1241__;
1754       int __rightop1242__ = 0;
1755       int __offsetinbits1238__ = __leftop1239__ + __rightop1242__;
1756       // __offsetinbits1238__ = ((8 * 124) + 0)
1757       int __offset1243__ = __offsetinbits1238__ >> 3;
1758       int __shift1244__ = __offsetinbits1238__ - (__offset1243__ << 3);
1759       int __rightele1236__ = ((*(int *)(__left1237__ + __offset1243__))  >> __shift1244__) & 0xffffffff;
1760       int __addeditem1246__;
1761       __addeditem1246__ = __inodeof___hashinv->add((int)__rightele1236__, (int)__leftele1235__);
1762       }
1763     }
1764   }
1765
1766
1767 // build rule14
1768   {
1769   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); )
1770     {
1771     int __de__ = (int) __de___iterator->next();
1772     //((de.inodenumber < d.s.NumberofInodes) && ((de.inodenumber == 0)))
1773     // __left1250__ <-- de
1774     int __left1250__ = (int) __de__; //varexpr
1775     // __left1250__ = de
1776     // __offsetinbits1251__ <-- ((8 * 124) + 0)
1777     int __leftop1253__ = 8;
1778     int __rightop1254__ = 124;
1779     int __leftop1252__ = __leftop1253__ * __rightop1254__;
1780     int __rightop1255__ = 0;
1781     int __offsetinbits1251__ = __leftop1252__ + __rightop1255__;
1782     // __offsetinbits1251__ = ((8 * 124) + 0)
1783     int __offset1256__ = __offsetinbits1251__ >> 3;
1784     int __shift1257__ = __offsetinbits1251__ - (__offset1256__ << 3);
1785     int __leftop1249__ = ((*(int *)(__left1250__ + __offset1256__))  >> __shift1257__) & 0xffffffff;
1786     // __left1259__ <-- d.s
1787     // __left1260__ <-- d
1788     int __left1260__ = (int) d; //varexpr
1789     // __left1260__ = d
1790     int __left1259__ = (__left1260__ + 0);
1791     int __leftop1262__ = 32;
1792     int __leftop1264__ = 32;
1793     int __leftop1266__ = 32;
1794     int __leftop1268__ = 32;
1795     int __leftop1270__ = 32;
1796     int __leftop1272__ = 32;
1797     int __rightop1273__ = 0;
1798     int __rightop1271__ = __leftop1272__ + __rightop1273__;
1799     int __rightop1269__ = __leftop1270__ + __rightop1271__;
1800     int __rightop1267__ = __leftop1268__ + __rightop1269__;
1801     int __rightop1265__ = __leftop1266__ + __rightop1267__;
1802     int __rightop1263__ = __leftop1264__ + __rightop1265__;
1803     int __sizeof1261__ = __leftop1262__ + __rightop1263__;
1804     int __high1274__ = __left1259__ + __sizeof1261__;
1805     assertvalidmemory(__left1259__, __high1274__);
1806     // __left1259__ = d.s
1807     // __offsetinbits1275__ <-- (32 + (32 + (32 + 0)))
1808     int __leftop1276__ = 32;
1809     int __leftop1278__ = 32;
1810     int __leftop1280__ = 32;
1811     int __rightop1281__ = 0;
1812     int __rightop1279__ = __leftop1280__ + __rightop1281__;
1813     int __rightop1277__ = __leftop1278__ + __rightop1279__;
1814     int __offsetinbits1275__ = __leftop1276__ + __rightop1277__;
1815     // __offsetinbits1275__ = (32 + (32 + (32 + 0)))
1816     int __offset1282__ = __offsetinbits1275__ >> 3;
1817     int __shift1283__ = __offsetinbits1275__ - (__offset1282__ << 3);
1818     int __rightop1258__ = ((*(int *)(__left1259__ + __offset1282__))  >> __shift1283__) & 0xffffffff;
1819     int __leftop1248__ = __leftop1249__ < __rightop1258__;
1820     // __left1287__ <-- de
1821     int __left1287__ = (int) __de__; //varexpr
1822     // __left1287__ = de
1823     // __offsetinbits1288__ <-- ((8 * 124) + 0)
1824     int __leftop1290__ = 8;
1825     int __rightop1291__ = 124;
1826     int __leftop1289__ = __leftop1290__ * __rightop1291__;
1827     int __rightop1292__ = 0;
1828     int __offsetinbits1288__ = __leftop1289__ + __rightop1292__;
1829     // __offsetinbits1288__ = ((8 * 124) + 0)
1830     int __offset1293__ = __offsetinbits1288__ >> 3;
1831     int __shift1294__ = __offsetinbits1288__ - (__offset1293__ << 3);
1832     int __leftop1286__ = ((*(int *)(__left1287__ + __offset1293__))  >> __shift1294__) & 0xffffffff;
1833     int __rightop1295__ = 0;
1834     int __leftop1285__ = __leftop1286__ == __rightop1295__;
1835     int __rightop1284__ = !__leftop1285__;
1836     int __tempvar1247__ = __leftop1248__ && __rightop1284__;
1837     if (__tempvar1247__)
1838       {
1839       // __left1297__ <-- de
1840       int __left1297__ = (int) __de__; //varexpr
1841       // __left1297__ = de
1842       // __offsetinbits1298__ <-- ((8 * 124) + 0)
1843       int __leftop1300__ = 8;
1844       int __rightop1301__ = 124;
1845       int __leftop1299__ = __leftop1300__ * __rightop1301__;
1846       int __rightop1302__ = 0;
1847       int __offsetinbits1298__ = __leftop1299__ + __rightop1302__;
1848       // __offsetinbits1298__ = ((8 * 124) + 0)
1849       int __offset1303__ = __offsetinbits1298__ >> 3;
1850       int __shift1304__ = __offsetinbits1298__ - (__offset1303__ << 3);
1851       int __element1296__ = ((*(int *)(__left1297__ + __offset1303__))  >> __shift1304__) & 0xffffffff;
1852       int __addeditem1305__ = 1;
1853       __addeditem1305__ = __FileInode___hash->add((int)__element1296__, (int)__element1296__);
1854       }
1855     }
1856   }
1857
1858
1859 // build rule16
1860   {
1861   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); )
1862     {
1863     int __j__ = (int) __j___iterator->next();
1864     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
1865       {
1866       int __itb__ = (int) __itb___iterator->next();
1867       //true
1868       int __tempvar1306__ = 1;
1869       if (__tempvar1306__)
1870         {
1871         int __leftele1307__ = (int) __j__; //varexpr
1872         // __left1309__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1873         // __left1310__ <-- cast(__InodeTable__, d.b[itb])
1874         // __left1312__ <-- d
1875         int __left1312__ = (int) d; //varexpr
1876         // __left1312__ = d
1877         // __offsetinbits1313__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1878         int __leftop1314__ = 0;
1879         int __leftop1318__ = 8;
1880         // __left1320__ <-- d.s
1881         // __left1321__ <-- d
1882         int __left1321__ = (int) d; //varexpr
1883         // __left1321__ = d
1884         int __left1320__ = (__left1321__ + 0);
1885         int __leftop1323__ = 32;
1886         int __leftop1325__ = 32;
1887         int __leftop1327__ = 32;
1888         int __leftop1329__ = 32;
1889         int __leftop1331__ = 32;
1890         int __leftop1333__ = 32;
1891         int __rightop1334__ = 0;
1892         int __rightop1332__ = __leftop1333__ + __rightop1334__;
1893         int __rightop1330__ = __leftop1331__ + __rightop1332__;
1894         int __rightop1328__ = __leftop1329__ + __rightop1330__;
1895         int __rightop1326__ = __leftop1327__ + __rightop1328__;
1896         int __rightop1324__ = __leftop1325__ + __rightop1326__;
1897         int __sizeof1322__ = __leftop1323__ + __rightop1324__;
1898         int __high1335__ = __left1320__ + __sizeof1322__;
1899         assertvalidmemory(__left1320__, __high1335__);
1900         // __left1320__ = d.s
1901         // __offsetinbits1336__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1902         int __leftop1337__ = 32;
1903         int __leftop1339__ = 32;
1904         int __leftop1341__ = 32;
1905         int __leftop1343__ = 32;
1906         int __leftop1345__ = 32;
1907         int __rightop1346__ = 0;
1908         int __rightop1344__ = __leftop1345__ + __rightop1346__;
1909         int __rightop1342__ = __leftop1343__ + __rightop1344__;
1910         int __rightop1340__ = __leftop1341__ + __rightop1342__;
1911         int __rightop1338__ = __leftop1339__ + __rightop1340__;
1912         int __offsetinbits1336__ = __leftop1337__ + __rightop1338__;
1913         // __offsetinbits1336__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1914         int __offset1347__ = __offsetinbits1336__ >> 3;
1915         int __shift1348__ = __offsetinbits1336__ - (__offset1347__ << 3);
1916         int __rightop1319__ = ((*(int *)(__left1320__ + __offset1347__))  >> __shift1348__) & 0xffffffff;
1917         int __leftop1317__ = __leftop1318__ * __rightop1319__;
1918         int __rightop1349__ = 0;
1919         int __leftop1316__ = __leftop1317__ + __rightop1349__;
1920         int __rightop1350__ = (int) __itb__; //varexpr
1921         int __rightop1315__ = __leftop1316__ * __rightop1350__;
1922         int __offsetinbits1313__ = __leftop1314__ + __rightop1315__;
1923         // __offsetinbits1313__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1924         int __offset1351__ = __offsetinbits1313__ >> 3;
1925         int __expr1311__ = (__left1312__ + __offset1351__);
1926         int __leftop1354__ = 8;
1927         // __left1356__ <-- d.s
1928         // __left1357__ <-- d
1929         int __left1357__ = (int) d; //varexpr
1930         // __left1357__ = d
1931         int __left1356__ = (__left1357__ + 0);
1932         int __leftop1359__ = 32;
1933         int __leftop1361__ = 32;
1934         int __leftop1363__ = 32;
1935         int __leftop1365__ = 32;
1936         int __leftop1367__ = 32;
1937         int __leftop1369__ = 32;
1938         int __rightop1370__ = 0;
1939         int __rightop1368__ = __leftop1369__ + __rightop1370__;
1940         int __rightop1366__ = __leftop1367__ + __rightop1368__;
1941         int __rightop1364__ = __leftop1365__ + __rightop1366__;
1942         int __rightop1362__ = __leftop1363__ + __rightop1364__;
1943         int __rightop1360__ = __leftop1361__ + __rightop1362__;
1944         int __sizeof1358__ = __leftop1359__ + __rightop1360__;
1945         int __high1371__ = __left1356__ + __sizeof1358__;
1946         assertvalidmemory(__left1356__, __high1371__);
1947         // __left1356__ = d.s
1948         // __offsetinbits1372__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1949         int __leftop1373__ = 32;
1950         int __leftop1375__ = 32;
1951         int __leftop1377__ = 32;
1952         int __leftop1379__ = 32;
1953         int __leftop1381__ = 32;
1954         int __rightop1382__ = 0;
1955         int __rightop1380__ = __leftop1381__ + __rightop1382__;
1956         int __rightop1378__ = __leftop1379__ + __rightop1380__;
1957         int __rightop1376__ = __leftop1377__ + __rightop1378__;
1958         int __rightop1374__ = __leftop1375__ + __rightop1376__;
1959         int __offsetinbits1372__ = __leftop1373__ + __rightop1374__;
1960         // __offsetinbits1372__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1961         int __offset1383__ = __offsetinbits1372__ >> 3;
1962         int __shift1384__ = __offsetinbits1372__ - (__offset1383__ << 3);
1963         int __rightop1355__ = ((*(int *)(__left1356__ + __offset1383__))  >> __shift1384__) & 0xffffffff;
1964         int __leftop1353__ = __leftop1354__ * __rightop1355__;
1965         int __rightop1385__ = 0;
1966         int __sizeof1352__ = __leftop1353__ + __rightop1385__;
1967         int __high1386__ = __expr1311__ + __sizeof1352__;
1968         assertvalidmemory(__expr1311__, __high1386__);
1969         int __left1310__ = (int) __expr1311__;
1970         // __left1310__ = cast(__InodeTable__, d.b[itb])
1971         // __offsetinbits1387__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1972         int __leftop1388__ = 0;
1973         int __leftop1391__ = 32;
1974         int __leftop1394__ = 32;
1975         int __rightop1395__ = 12;
1976         int __leftop1393__ = __leftop1394__ * __rightop1395__;
1977         int __leftop1397__ = 32;
1978         int __rightop1398__ = 0;
1979         int __rightop1396__ = __leftop1397__ + __rightop1398__;
1980         int __rightop1392__ = __leftop1393__ + __rightop1396__;
1981         int __leftop1390__ = __leftop1391__ + __rightop1392__;
1982         int __rightop1399__ = (int) __j__; //varexpr
1983         int __rightop1389__ = __leftop1390__ * __rightop1399__;
1984         int __offsetinbits1387__ = __leftop1388__ + __rightop1389__;
1985         // __offsetinbits1387__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1986         int __offset1400__ = __offsetinbits1387__ >> 3;
1987         int __left1309__ = (__left1310__ + __offset1400__);
1988         int __leftop1402__ = 32;
1989         int __leftop1405__ = 32;
1990         int __rightop1406__ = 12;
1991         int __leftop1404__ = __leftop1405__ * __rightop1406__;
1992         int __leftop1408__ = 32;
1993         int __rightop1409__ = 0;
1994         int __rightop1407__ = __leftop1408__ + __rightop1409__;
1995         int __rightop1403__ = __leftop1404__ + __rightop1407__;
1996         int __sizeof1401__ = __leftop1402__ + __rightop1403__;
1997         int __high1410__ = __left1309__ + __sizeof1401__;
1998         assertvalidmemory(__left1309__, __high1410__);
1999         // __left1309__ = cast(__InodeTable__, d.b[itb]).itable[j]
2000         // __offsetinbits1411__ <-- ((32 * 12) + (32 + 0))
2001         int __leftop1413__ = 32;
2002         int __rightop1414__ = 12;
2003         int __leftop1412__ = __leftop1413__ * __rightop1414__;
2004         int __leftop1416__ = 32;
2005         int __rightop1417__ = 0;
2006         int __rightop1415__ = __leftop1416__ + __rightop1417__;
2007         int __offsetinbits1411__ = __leftop1412__ + __rightop1415__;
2008         // __offsetinbits1411__ = ((32 * 12) + (32 + 0))
2009         int __offset1418__ = __offsetinbits1411__ >> 3;
2010         int __shift1419__ = __offsetinbits1411__ - (__offset1418__ << 3);
2011         int __rightele1308__ = ((*(int *)(__left1309__ + __offset1418__))  >> __shift1419__) & 0xffffffff;
2012         int __addeditem1421__;
2013         __addeditem1421__ = __referencecount___hash->add((int)__leftele1307__, (int)__rightele1308__);
2014         }
2015       }
2016     }
2017   }
2018
2019
2020 // build rule11
2021   {
2022   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
2023     {
2024     int __i__ = (int) __i___iterator->next();
2025     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
2026       {
2027       int __itb__ = (int) __itb___iterator->next();
2028       int __tempvar1422__ = 0;
2029       int __tempvar1423__ = 11;
2030       for (int __j__ = __tempvar1422__; __j__ <= __tempvar1423__; __j__++)
2031         {
2032         //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks) && ((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0)))
2033         // __left1427__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2034         // __left1428__ <-- cast(__InodeTable__, d.b[itb])
2035         // __left1430__ <-- d
2036         int __left1430__ = (int) d; //varexpr
2037         // __left1430__ = d
2038         // __offsetinbits1431__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2039         int __leftop1432__ = 0;
2040         int __leftop1436__ = 8;
2041         // __left1438__ <-- d.s
2042         // __left1439__ <-- d
2043         int __left1439__ = (int) d; //varexpr
2044         // __left1439__ = d
2045         int __left1438__ = (__left1439__ + 0);
2046         int __leftop1441__ = 32;
2047         int __leftop1443__ = 32;
2048         int __leftop1445__ = 32;
2049         int __leftop1447__ = 32;
2050         int __leftop1449__ = 32;
2051         int __leftop1451__ = 32;
2052         int __rightop1452__ = 0;
2053         int __rightop1450__ = __leftop1451__ + __rightop1452__;
2054         int __rightop1448__ = __leftop1449__ + __rightop1450__;
2055         int __rightop1446__ = __leftop1447__ + __rightop1448__;
2056         int __rightop1444__ = __leftop1445__ + __rightop1446__;
2057         int __rightop1442__ = __leftop1443__ + __rightop1444__;
2058         int __sizeof1440__ = __leftop1441__ + __rightop1442__;
2059         int __high1453__ = __left1438__ + __sizeof1440__;
2060         assertvalidmemory(__left1438__, __high1453__);
2061         // __left1438__ = d.s
2062         // __offsetinbits1454__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2063         int __leftop1455__ = 32;
2064         int __leftop1457__ = 32;
2065         int __leftop1459__ = 32;
2066         int __leftop1461__ = 32;
2067         int __leftop1463__ = 32;
2068         int __rightop1464__ = 0;
2069         int __rightop1462__ = __leftop1463__ + __rightop1464__;
2070         int __rightop1460__ = __leftop1461__ + __rightop1462__;
2071         int __rightop1458__ = __leftop1459__ + __rightop1460__;
2072         int __rightop1456__ = __leftop1457__ + __rightop1458__;
2073         int __offsetinbits1454__ = __leftop1455__ + __rightop1456__;
2074         // __offsetinbits1454__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2075         int __offset1465__ = __offsetinbits1454__ >> 3;
2076         int __shift1466__ = __offsetinbits1454__ - (__offset1465__ << 3);
2077         int __rightop1437__ = ((*(int *)(__left1438__ + __offset1465__))  >> __shift1466__) & 0xffffffff;
2078         int __leftop1435__ = __leftop1436__ * __rightop1437__;
2079         int __rightop1467__ = 0;
2080         int __leftop1434__ = __leftop1435__ + __rightop1467__;
2081         int __rightop1468__ = (int) __itb__; //varexpr
2082         int __rightop1433__ = __leftop1434__ * __rightop1468__;
2083         int __offsetinbits1431__ = __leftop1432__ + __rightop1433__;
2084         // __offsetinbits1431__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2085         int __offset1469__ = __offsetinbits1431__ >> 3;
2086         int __expr1429__ = (__left1430__ + __offset1469__);
2087         int __leftop1472__ = 8;
2088         // __left1474__ <-- d.s
2089         // __left1475__ <-- d
2090         int __left1475__ = (int) d; //varexpr
2091         // __left1475__ = d
2092         int __left1474__ = (__left1475__ + 0);
2093         int __leftop1477__ = 32;
2094         int __leftop1479__ = 32;
2095         int __leftop1481__ = 32;
2096         int __leftop1483__ = 32;
2097         int __leftop1485__ = 32;
2098         int __leftop1487__ = 32;
2099         int __rightop1488__ = 0;
2100         int __rightop1486__ = __leftop1487__ + __rightop1488__;
2101         int __rightop1484__ = __leftop1485__ + __rightop1486__;
2102         int __rightop1482__ = __leftop1483__ + __rightop1484__;
2103         int __rightop1480__ = __leftop1481__ + __rightop1482__;
2104         int __rightop1478__ = __leftop1479__ + __rightop1480__;
2105         int __sizeof1476__ = __leftop1477__ + __rightop1478__;
2106         int __high1489__ = __left1474__ + __sizeof1476__;
2107         assertvalidmemory(__left1474__, __high1489__);
2108         // __left1474__ = d.s
2109         // __offsetinbits1490__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2110         int __leftop1491__ = 32;
2111         int __leftop1493__ = 32;
2112         int __leftop1495__ = 32;
2113         int __leftop1497__ = 32;
2114         int __leftop1499__ = 32;
2115         int __rightop1500__ = 0;
2116         int __rightop1498__ = __leftop1499__ + __rightop1500__;
2117         int __rightop1496__ = __leftop1497__ + __rightop1498__;
2118         int __rightop1494__ = __leftop1495__ + __rightop1496__;
2119         int __rightop1492__ = __leftop1493__ + __rightop1494__;
2120         int __offsetinbits1490__ = __leftop1491__ + __rightop1492__;
2121         // __offsetinbits1490__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2122         int __offset1501__ = __offsetinbits1490__ >> 3;
2123         int __shift1502__ = __offsetinbits1490__ - (__offset1501__ << 3);
2124         int __rightop1473__ = ((*(int *)(__left1474__ + __offset1501__))  >> __shift1502__) & 0xffffffff;
2125         int __leftop1471__ = __leftop1472__ * __rightop1473__;
2126         int __rightop1503__ = 0;
2127         int __sizeof1470__ = __leftop1471__ + __rightop1503__;
2128         int __high1504__ = __expr1429__ + __sizeof1470__;
2129         assertvalidmemory(__expr1429__, __high1504__);
2130         int __left1428__ = (int) __expr1429__;
2131         // __left1428__ = cast(__InodeTable__, d.b[itb])
2132         // __offsetinbits1505__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2133         int __leftop1506__ = 0;
2134         int __leftop1509__ = 32;
2135         int __leftop1512__ = 32;
2136         int __rightop1513__ = 12;
2137         int __leftop1511__ = __leftop1512__ * __rightop1513__;
2138         int __leftop1515__ = 32;
2139         int __rightop1516__ = 0;
2140         int __rightop1514__ = __leftop1515__ + __rightop1516__;
2141         int __rightop1510__ = __leftop1511__ + __rightop1514__;
2142         int __leftop1508__ = __leftop1509__ + __rightop1510__;
2143         int __rightop1517__ = (int) __i__; //varexpr
2144         int __rightop1507__ = __leftop1508__ * __rightop1517__;
2145         int __offsetinbits1505__ = __leftop1506__ + __rightop1507__;
2146         // __offsetinbits1505__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2147         int __offset1518__ = __offsetinbits1505__ >> 3;
2148         int __left1427__ = (__left1428__ + __offset1518__);
2149         int __leftop1520__ = 32;
2150         int __leftop1523__ = 32;
2151         int __rightop1524__ = 12;
2152         int __leftop1522__ = __leftop1523__ * __rightop1524__;
2153         int __leftop1526__ = 32;
2154         int __rightop1527__ = 0;
2155         int __rightop1525__ = __leftop1526__ + __rightop1527__;
2156         int __rightop1521__ = __leftop1522__ + __rightop1525__;
2157         int __sizeof1519__ = __leftop1520__ + __rightop1521__;
2158         int __high1528__ = __left1427__ + __sizeof1519__;
2159         assertvalidmemory(__left1427__, __high1528__);
2160         // __left1427__ = cast(__InodeTable__, d.b[itb]).itable[i]
2161         // __offsetinbits1529__ <-- ((32 + 0) + (32 * j))
2162         int __leftop1531__ = 32;
2163         int __rightop1532__ = 0;
2164         int __leftop1530__ = __leftop1531__ + __rightop1532__;
2165         int __leftop1534__ = 32;
2166         int __rightop1535__ = (int) __j__; //varexpr
2167         int __rightop1533__ = __leftop1534__ * __rightop1535__;
2168         int __offsetinbits1529__ = __leftop1530__ + __rightop1533__;
2169         // __offsetinbits1529__ = ((32 + 0) + (32 * j))
2170         int __offset1536__ = __offsetinbits1529__ >> 3;
2171         int __shift1537__ = __offsetinbits1529__ - (__offset1536__ << 3);
2172         int __leftop1426__ = ((*(int *)(__left1427__ + __offset1536__))  >> __shift1537__) & 0xffffffff;
2173         // __left1539__ <-- d.s
2174         // __left1540__ <-- d
2175         int __left1540__ = (int) d; //varexpr
2176         // __left1540__ = d
2177         int __left1539__ = (__left1540__ + 0);
2178         int __leftop1542__ = 32;
2179         int __leftop1544__ = 32;
2180         int __leftop1546__ = 32;
2181         int __leftop1548__ = 32;
2182         int __leftop1550__ = 32;
2183         int __leftop1552__ = 32;
2184         int __rightop1553__ = 0;
2185         int __rightop1551__ = __leftop1552__ + __rightop1553__;
2186         int __rightop1549__ = __leftop1550__ + __rightop1551__;
2187         int __rightop1547__ = __leftop1548__ + __rightop1549__;
2188         int __rightop1545__ = __leftop1546__ + __rightop1547__;
2189         int __rightop1543__ = __leftop1544__ + __rightop1545__;
2190         int __sizeof1541__ = __leftop1542__ + __rightop1543__;
2191         int __high1554__ = __left1539__ + __sizeof1541__;
2192         assertvalidmemory(__left1539__, __high1554__);
2193         // __left1539__ = d.s
2194         // __offsetinbits1555__ <-- (32 + (32 + 0))
2195         int __leftop1556__ = 32;
2196         int __leftop1558__ = 32;
2197         int __rightop1559__ = 0;
2198         int __rightop1557__ = __leftop1558__ + __rightop1559__;
2199         int __offsetinbits1555__ = __leftop1556__ + __rightop1557__;
2200         // __offsetinbits1555__ = (32 + (32 + 0))
2201         int __offset1560__ = __offsetinbits1555__ >> 3;
2202         int __shift1561__ = __offsetinbits1555__ - (__offset1560__ << 3);
2203         int __rightop1538__ = ((*(int *)(__left1539__ + __offset1560__))  >> __shift1561__) & 0xffffffff;
2204         int __leftop1425__ = __leftop1426__ < __rightop1538__;
2205         // __left1565__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2206         // __left1566__ <-- cast(__InodeTable__, d.b[itb])
2207         // __left1568__ <-- d
2208         int __left1568__ = (int) d; //varexpr
2209         // __left1568__ = d
2210         // __offsetinbits1569__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2211         int __leftop1570__ = 0;
2212         int __leftop1574__ = 8;
2213         // __left1576__ <-- d.s
2214         // __left1577__ <-- d
2215         int __left1577__ = (int) d; //varexpr
2216         // __left1577__ = d
2217         int __left1576__ = (__left1577__ + 0);
2218         int __leftop1579__ = 32;
2219         int __leftop1581__ = 32;
2220         int __leftop1583__ = 32;
2221         int __leftop1585__ = 32;
2222         int __leftop1587__ = 32;
2223         int __leftop1589__ = 32;
2224         int __rightop1590__ = 0;
2225         int __rightop1588__ = __leftop1589__ + __rightop1590__;
2226         int __rightop1586__ = __leftop1587__ + __rightop1588__;
2227         int __rightop1584__ = __leftop1585__ + __rightop1586__;
2228         int __rightop1582__ = __leftop1583__ + __rightop1584__;
2229         int __rightop1580__ = __leftop1581__ + __rightop1582__;
2230         int __sizeof1578__ = __leftop1579__ + __rightop1580__;
2231         int __high1591__ = __left1576__ + __sizeof1578__;
2232         assertvalidmemory(__left1576__, __high1591__);
2233         // __left1576__ = d.s
2234         // __offsetinbits1592__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2235         int __leftop1593__ = 32;
2236         int __leftop1595__ = 32;
2237         int __leftop1597__ = 32;
2238         int __leftop1599__ = 32;
2239         int __leftop1601__ = 32;
2240         int __rightop1602__ = 0;
2241         int __rightop1600__ = __leftop1601__ + __rightop1602__;
2242         int __rightop1598__ = __leftop1599__ + __rightop1600__;
2243         int __rightop1596__ = __leftop1597__ + __rightop1598__;
2244         int __rightop1594__ = __leftop1595__ + __rightop1596__;
2245         int __offsetinbits1592__ = __leftop1593__ + __rightop1594__;
2246         // __offsetinbits1592__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2247         int __offset1603__ = __offsetinbits1592__ >> 3;
2248         int __shift1604__ = __offsetinbits1592__ - (__offset1603__ << 3);
2249         int __rightop1575__ = ((*(int *)(__left1576__ + __offset1603__))  >> __shift1604__) & 0xffffffff;
2250         int __leftop1573__ = __leftop1574__ * __rightop1575__;
2251         int __rightop1605__ = 0;
2252         int __leftop1572__ = __leftop1573__ + __rightop1605__;
2253         int __rightop1606__ = (int) __itb__; //varexpr
2254         int __rightop1571__ = __leftop1572__ * __rightop1606__;
2255         int __offsetinbits1569__ = __leftop1570__ + __rightop1571__;
2256         // __offsetinbits1569__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2257         int __offset1607__ = __offsetinbits1569__ >> 3;
2258         int __expr1567__ = (__left1568__ + __offset1607__);
2259         int __leftop1610__ = 8;
2260         // __left1612__ <-- d.s
2261         // __left1613__ <-- d
2262         int __left1613__ = (int) d; //varexpr
2263         // __left1613__ = d
2264         int __left1612__ = (__left1613__ + 0);
2265         int __leftop1615__ = 32;
2266         int __leftop1617__ = 32;
2267         int __leftop1619__ = 32;
2268         int __leftop1621__ = 32;
2269         int __leftop1623__ = 32;
2270         int __leftop1625__ = 32;
2271         int __rightop1626__ = 0;
2272         int __rightop1624__ = __leftop1625__ + __rightop1626__;
2273         int __rightop1622__ = __leftop1623__ + __rightop1624__;
2274         int __rightop1620__ = __leftop1621__ + __rightop1622__;
2275         int __rightop1618__ = __leftop1619__ + __rightop1620__;
2276         int __rightop1616__ = __leftop1617__ + __rightop1618__;
2277         int __sizeof1614__ = __leftop1615__ + __rightop1616__;
2278         int __high1627__ = __left1612__ + __sizeof1614__;
2279         assertvalidmemory(__left1612__, __high1627__);
2280         // __left1612__ = d.s
2281         // __offsetinbits1628__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2282         int __leftop1629__ = 32;
2283         int __leftop1631__ = 32;
2284         int __leftop1633__ = 32;
2285         int __leftop1635__ = 32;
2286         int __leftop1637__ = 32;
2287         int __rightop1638__ = 0;
2288         int __rightop1636__ = __leftop1637__ + __rightop1638__;
2289         int __rightop1634__ = __leftop1635__ + __rightop1636__;
2290         int __rightop1632__ = __leftop1633__ + __rightop1634__;
2291         int __rightop1630__ = __leftop1631__ + __rightop1632__;
2292         int __offsetinbits1628__ = __leftop1629__ + __rightop1630__;
2293         // __offsetinbits1628__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2294         int __offset1639__ = __offsetinbits1628__ >> 3;
2295         int __shift1640__ = __offsetinbits1628__ - (__offset1639__ << 3);
2296         int __rightop1611__ = ((*(int *)(__left1612__ + __offset1639__))  >> __shift1640__) & 0xffffffff;
2297         int __leftop1609__ = __leftop1610__ * __rightop1611__;
2298         int __rightop1641__ = 0;
2299         int __sizeof1608__ = __leftop1609__ + __rightop1641__;
2300         int __high1642__ = __expr1567__ + __sizeof1608__;
2301         assertvalidmemory(__expr1567__, __high1642__);
2302         int __left1566__ = (int) __expr1567__;
2303         // __left1566__ = cast(__InodeTable__, d.b[itb])
2304         // __offsetinbits1643__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2305         int __leftop1644__ = 0;
2306         int __leftop1647__ = 32;
2307         int __leftop1650__ = 32;
2308         int __rightop1651__ = 12;
2309         int __leftop1649__ = __leftop1650__ * __rightop1651__;
2310         int __leftop1653__ = 32;
2311         int __rightop1654__ = 0;
2312         int __rightop1652__ = __leftop1653__ + __rightop1654__;
2313         int __rightop1648__ = __leftop1649__ + __rightop1652__;
2314         int __leftop1646__ = __leftop1647__ + __rightop1648__;
2315         int __rightop1655__ = (int) __i__; //varexpr
2316         int __rightop1645__ = __leftop1646__ * __rightop1655__;
2317         int __offsetinbits1643__ = __leftop1644__ + __rightop1645__;
2318         // __offsetinbits1643__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2319         int __offset1656__ = __offsetinbits1643__ >> 3;
2320         int __left1565__ = (__left1566__ + __offset1656__);
2321         int __leftop1658__ = 32;
2322         int __leftop1661__ = 32;
2323         int __rightop1662__ = 12;
2324         int __leftop1660__ = __leftop1661__ * __rightop1662__;
2325         int __leftop1664__ = 32;
2326         int __rightop1665__ = 0;
2327         int __rightop1663__ = __leftop1664__ + __rightop1665__;
2328         int __rightop1659__ = __leftop1660__ + __rightop1663__;
2329         int __sizeof1657__ = __leftop1658__ + __rightop1659__;
2330         int __high1666__ = __left1565__ + __sizeof1657__;
2331         assertvalidmemory(__left1565__, __high1666__);
2332         // __left1565__ = cast(__InodeTable__, d.b[itb]).itable[i]
2333         // __offsetinbits1667__ <-- ((32 + 0) + (32 * j))
2334         int __leftop1669__ = 32;
2335         int __rightop1670__ = 0;
2336         int __leftop1668__ = __leftop1669__ + __rightop1670__;
2337         int __leftop1672__ = 32;
2338         int __rightop1673__ = (int) __j__; //varexpr
2339         int __rightop1671__ = __leftop1672__ * __rightop1673__;
2340         int __offsetinbits1667__ = __leftop1668__ + __rightop1671__;
2341         // __offsetinbits1667__ = ((32 + 0) + (32 * j))
2342         int __offset1674__ = __offsetinbits1667__ >> 3;
2343         int __shift1675__ = __offsetinbits1667__ - (__offset1674__ << 3);
2344         int __leftop1564__ = ((*(int *)(__left1565__ + __offset1674__))  >> __shift1675__) & 0xffffffff;
2345         int __rightop1676__ = 0;
2346         int __leftop1563__ = __leftop1564__ == __rightop1676__;
2347         int __rightop1562__ = !__leftop1563__;
2348         int __tempvar1424__ = __leftop1425__ && __rightop1562__;
2349         if (__tempvar1424__)
2350           {
2351           // __left1678__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2352           // __left1679__ <-- cast(__InodeTable__, d.b[itb])
2353           // __left1681__ <-- d
2354           int __left1681__ = (int) d; //varexpr
2355           // __left1681__ = d
2356           // __offsetinbits1682__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2357           int __leftop1683__ = 0;
2358           int __leftop1687__ = 8;
2359           // __left1689__ <-- d.s
2360           // __left1690__ <-- d
2361           int __left1690__ = (int) d; //varexpr
2362           // __left1690__ = d
2363           int __left1689__ = (__left1690__ + 0);
2364           int __leftop1692__ = 32;
2365           int __leftop1694__ = 32;
2366           int __leftop1696__ = 32;
2367           int __leftop1698__ = 32;
2368           int __leftop1700__ = 32;
2369           int __leftop1702__ = 32;
2370           int __rightop1703__ = 0;
2371           int __rightop1701__ = __leftop1702__ + __rightop1703__;
2372           int __rightop1699__ = __leftop1700__ + __rightop1701__;
2373           int __rightop1697__ = __leftop1698__ + __rightop1699__;
2374           int __rightop1695__ = __leftop1696__ + __rightop1697__;
2375           int __rightop1693__ = __leftop1694__ + __rightop1695__;
2376           int __sizeof1691__ = __leftop1692__ + __rightop1693__;
2377           int __high1704__ = __left1689__ + __sizeof1691__;
2378           assertvalidmemory(__left1689__, __high1704__);
2379           // __left1689__ = d.s
2380           // __offsetinbits1705__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2381           int __leftop1706__ = 32;
2382           int __leftop1708__ = 32;
2383           int __leftop1710__ = 32;
2384           int __leftop1712__ = 32;
2385           int __leftop1714__ = 32;
2386           int __rightop1715__ = 0;
2387           int __rightop1713__ = __leftop1714__ + __rightop1715__;
2388           int __rightop1711__ = __leftop1712__ + __rightop1713__;
2389           int __rightop1709__ = __leftop1710__ + __rightop1711__;
2390           int __rightop1707__ = __leftop1708__ + __rightop1709__;
2391           int __offsetinbits1705__ = __leftop1706__ + __rightop1707__;
2392           // __offsetinbits1705__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2393           int __offset1716__ = __offsetinbits1705__ >> 3;
2394           int __shift1717__ = __offsetinbits1705__ - (__offset1716__ << 3);
2395           int __rightop1688__ = ((*(int *)(__left1689__ + __offset1716__))  >> __shift1717__) & 0xffffffff;
2396           int __leftop1686__ = __leftop1687__ * __rightop1688__;
2397           int __rightop1718__ = 0;
2398           int __leftop1685__ = __leftop1686__ + __rightop1718__;
2399           int __rightop1719__ = (int) __itb__; //varexpr
2400           int __rightop1684__ = __leftop1685__ * __rightop1719__;
2401           int __offsetinbits1682__ = __leftop1683__ + __rightop1684__;
2402           // __offsetinbits1682__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2403           int __offset1720__ = __offsetinbits1682__ >> 3;
2404           int __expr1680__ = (__left1681__ + __offset1720__);
2405           int __leftop1723__ = 8;
2406           // __left1725__ <-- d.s
2407           // __left1726__ <-- d
2408           int __left1726__ = (int) d; //varexpr
2409           // __left1726__ = d
2410           int __left1725__ = (__left1726__ + 0);
2411           int __leftop1728__ = 32;
2412           int __leftop1730__ = 32;
2413           int __leftop1732__ = 32;
2414           int __leftop1734__ = 32;
2415           int __leftop1736__ = 32;
2416           int __leftop1738__ = 32;
2417           int __rightop1739__ = 0;
2418           int __rightop1737__ = __leftop1738__ + __rightop1739__;
2419           int __rightop1735__ = __leftop1736__ + __rightop1737__;
2420           int __rightop1733__ = __leftop1734__ + __rightop1735__;
2421           int __rightop1731__ = __leftop1732__ + __rightop1733__;
2422           int __rightop1729__ = __leftop1730__ + __rightop1731__;
2423           int __sizeof1727__ = __leftop1728__ + __rightop1729__;
2424           int __high1740__ = __left1725__ + __sizeof1727__;
2425           assertvalidmemory(__left1725__, __high1740__);
2426           // __left1725__ = d.s
2427           // __offsetinbits1741__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2428           int __leftop1742__ = 32;
2429           int __leftop1744__ = 32;
2430           int __leftop1746__ = 32;
2431           int __leftop1748__ = 32;
2432           int __leftop1750__ = 32;
2433           int __rightop1751__ = 0;
2434           int __rightop1749__ = __leftop1750__ + __rightop1751__;
2435           int __rightop1747__ = __leftop1748__ + __rightop1749__;
2436           int __rightop1745__ = __leftop1746__ + __rightop1747__;
2437           int __rightop1743__ = __leftop1744__ + __rightop1745__;
2438           int __offsetinbits1741__ = __leftop1742__ + __rightop1743__;
2439           // __offsetinbits1741__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2440           int __offset1752__ = __offsetinbits1741__ >> 3;
2441           int __shift1753__ = __offsetinbits1741__ - (__offset1752__ << 3);
2442           int __rightop1724__ = ((*(int *)(__left1725__ + __offset1752__))  >> __shift1753__) & 0xffffffff;
2443           int __leftop1722__ = __leftop1723__ * __rightop1724__;
2444           int __rightop1754__ = 0;
2445           int __sizeof1721__ = __leftop1722__ + __rightop1754__;
2446           int __high1755__ = __expr1680__ + __sizeof1721__;
2447           assertvalidmemory(__expr1680__, __high1755__);
2448           int __left1679__ = (int) __expr1680__;
2449           // __left1679__ = cast(__InodeTable__, d.b[itb])
2450           // __offsetinbits1756__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2451           int __leftop1757__ = 0;
2452           int __leftop1760__ = 32;
2453           int __leftop1763__ = 32;
2454           int __rightop1764__ = 12;
2455           int __leftop1762__ = __leftop1763__ * __rightop1764__;
2456           int __leftop1766__ = 32;
2457           int __rightop1767__ = 0;
2458           int __rightop1765__ = __leftop1766__ + __rightop1767__;
2459           int __rightop1761__ = __leftop1762__ + __rightop1765__;
2460           int __leftop1759__ = __leftop1760__ + __rightop1761__;
2461           int __rightop1768__ = (int) __i__; //varexpr
2462           int __rightop1758__ = __leftop1759__ * __rightop1768__;
2463           int __offsetinbits1756__ = __leftop1757__ + __rightop1758__;
2464           // __offsetinbits1756__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2465           int __offset1769__ = __offsetinbits1756__ >> 3;
2466           int __left1678__ = (__left1679__ + __offset1769__);
2467           int __leftop1771__ = 32;
2468           int __leftop1774__ = 32;
2469           int __rightop1775__ = 12;
2470           int __leftop1773__ = __leftop1774__ * __rightop1775__;
2471           int __leftop1777__ = 32;
2472           int __rightop1778__ = 0;
2473           int __rightop1776__ = __leftop1777__ + __rightop1778__;
2474           int __rightop1772__ = __leftop1773__ + __rightop1776__;
2475           int __sizeof1770__ = __leftop1771__ + __rightop1772__;
2476           int __high1779__ = __left1678__ + __sizeof1770__;
2477           assertvalidmemory(__left1678__, __high1779__);
2478           // __left1678__ = cast(__InodeTable__, d.b[itb]).itable[i]
2479           // __offsetinbits1780__ <-- ((32 + 0) + (32 * j))
2480           int __leftop1782__ = 32;
2481           int __rightop1783__ = 0;
2482           int __leftop1781__ = __leftop1782__ + __rightop1783__;
2483           int __leftop1785__ = 32;
2484           int __rightop1786__ = (int) __j__; //varexpr
2485           int __rightop1784__ = __leftop1785__ * __rightop1786__;
2486           int __offsetinbits1780__ = __leftop1781__ + __rightop1784__;
2487           // __offsetinbits1780__ = ((32 + 0) + (32 * j))
2488           int __offset1787__ = __offsetinbits1780__ >> 3;
2489           int __shift1788__ = __offsetinbits1780__ - (__offset1787__ << 3);
2490           int __element1677__ = ((*(int *)(__left1678__ + __offset1787__))  >> __shift1788__) & 0xffffffff;
2491           int __addeditem1789__ = 1;
2492           __addeditem1789__ = __FileBlock___hash->add((int)__element1677__, (int)__element1677__);
2493           }
2494         }
2495       }
2496     }
2497   }
2498
2499
2500 // build rule8
2501   {
2502   int __tempvar1790__ = 0;
2503   // __left1793__ <-- d.s
2504   // __left1794__ <-- d
2505   int __left1794__ = (int) d; //varexpr
2506   // __left1794__ = d
2507   int __left1793__ = (__left1794__ + 0);
2508   int __leftop1796__ = 32;
2509   int __leftop1798__ = 32;
2510   int __leftop1800__ = 32;
2511   int __leftop1802__ = 32;
2512   int __leftop1804__ = 32;
2513   int __leftop1806__ = 32;
2514   int __rightop1807__ = 0;
2515   int __rightop1805__ = __leftop1806__ + __rightop1807__;
2516   int __rightop1803__ = __leftop1804__ + __rightop1805__;
2517   int __rightop1801__ = __leftop1802__ + __rightop1803__;
2518   int __rightop1799__ = __leftop1800__ + __rightop1801__;
2519   int __rightop1797__ = __leftop1798__ + __rightop1799__;
2520   int __sizeof1795__ = __leftop1796__ + __rightop1797__;
2521   int __high1808__ = __left1793__ + __sizeof1795__;
2522   assertvalidmemory(__left1793__, __high1808__);
2523   // __left1793__ = d.s
2524   // __offsetinbits1809__ <-- (32 + (32 + 0))
2525   int __leftop1810__ = 32;
2526   int __leftop1812__ = 32;
2527   int __rightop1813__ = 0;
2528   int __rightop1811__ = __leftop1812__ + __rightop1813__;
2529   int __offsetinbits1809__ = __leftop1810__ + __rightop1811__;
2530   // __offsetinbits1809__ = (32 + (32 + 0))
2531   int __offset1814__ = __offsetinbits1809__ >> 3;
2532   int __shift1815__ = __offsetinbits1809__ - (__offset1814__ << 3);
2533   int __leftop1792__ = ((*(int *)(__left1793__ + __offset1814__))  >> __shift1815__) & 0xffffffff;
2534   int __rightop1816__ = 1;
2535   int __tempvar1791__ = __leftop1792__ - __rightop1816__;
2536   for (int __j__ = __tempvar1790__; __j__ <= __tempvar1791__; __j__++)
2537     {
2538     //(j in? __UsedBlock__)
2539     int __element1819__ = (int) __j__; //varexpr
2540     int __leftop1818__ = __UsedBlock___hash->contains(__element1819__);
2541     int __tempvar1817__ = !__leftop1818__;
2542     if (__tempvar1817__)
2543       {
2544       int __element1820__ = (int) __j__; //varexpr
2545       int __addeditem1821__ = 1;
2546       __addeditem1821__ = __FreeBlock___hash->add((int)__element1820__, (int)__element1820__);
2547       }
2548     }
2549   }
2550
2551
2552 // build rule10
2553   {
2554   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
2555     {
2556     int __i__ = (int) __i___iterator->next();
2557     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
2558       {
2559       int __itb__ = (int) __itb___iterator->next();
2560       int __tempvar1822__ = 0;
2561       int __tempvar1823__ = 11;
2562       for (int __j__ = __tempvar1822__; __j__ <= __tempvar1823__; __j__++)
2563         {
2564         //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0))
2565         // __left1827__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2566         // __left1828__ <-- cast(__InodeTable__, d.b[itb])
2567         // __left1830__ <-- d
2568         int __left1830__ = (int) d; //varexpr
2569         // __left1830__ = d
2570         // __offsetinbits1831__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2571         int __leftop1832__ = 0;
2572         int __leftop1836__ = 8;
2573         // __left1838__ <-- d.s
2574         // __left1839__ <-- d
2575         int __left1839__ = (int) d; //varexpr
2576         // __left1839__ = d
2577         int __left1838__ = (__left1839__ + 0);
2578         int __leftop1841__ = 32;
2579         int __leftop1843__ = 32;
2580         int __leftop1845__ = 32;
2581         int __leftop1847__ = 32;
2582         int __leftop1849__ = 32;
2583         int __leftop1851__ = 32;
2584         int __rightop1852__ = 0;
2585         int __rightop1850__ = __leftop1851__ + __rightop1852__;
2586         int __rightop1848__ = __leftop1849__ + __rightop1850__;
2587         int __rightop1846__ = __leftop1847__ + __rightop1848__;
2588         int __rightop1844__ = __leftop1845__ + __rightop1846__;
2589         int __rightop1842__ = __leftop1843__ + __rightop1844__;
2590         int __sizeof1840__ = __leftop1841__ + __rightop1842__;
2591         int __high1853__ = __left1838__ + __sizeof1840__;
2592         assertvalidmemory(__left1838__, __high1853__);
2593         // __left1838__ = d.s
2594         // __offsetinbits1854__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2595         int __leftop1855__ = 32;
2596         int __leftop1857__ = 32;
2597         int __leftop1859__ = 32;
2598         int __leftop1861__ = 32;
2599         int __leftop1863__ = 32;
2600         int __rightop1864__ = 0;
2601         int __rightop1862__ = __leftop1863__ + __rightop1864__;
2602         int __rightop1860__ = __leftop1861__ + __rightop1862__;
2603         int __rightop1858__ = __leftop1859__ + __rightop1860__;
2604         int __rightop1856__ = __leftop1857__ + __rightop1858__;
2605         int __offsetinbits1854__ = __leftop1855__ + __rightop1856__;
2606         // __offsetinbits1854__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2607         int __offset1865__ = __offsetinbits1854__ >> 3;
2608         int __shift1866__ = __offsetinbits1854__ - (__offset1865__ << 3);
2609         int __rightop1837__ = ((*(int *)(__left1838__ + __offset1865__))  >> __shift1866__) & 0xffffffff;
2610         int __leftop1835__ = __leftop1836__ * __rightop1837__;
2611         int __rightop1867__ = 0;
2612         int __leftop1834__ = __leftop1835__ + __rightop1867__;
2613         int __rightop1868__ = (int) __itb__; //varexpr
2614         int __rightop1833__ = __leftop1834__ * __rightop1868__;
2615         int __offsetinbits1831__ = __leftop1832__ + __rightop1833__;
2616         // __offsetinbits1831__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2617         int __offset1869__ = __offsetinbits1831__ >> 3;
2618         int __expr1829__ = (__left1830__ + __offset1869__);
2619         int __leftop1872__ = 8;
2620         // __left1874__ <-- d.s
2621         // __left1875__ <-- d
2622         int __left1875__ = (int) d; //varexpr
2623         // __left1875__ = d
2624         int __left1874__ = (__left1875__ + 0);
2625         int __leftop1877__ = 32;
2626         int __leftop1879__ = 32;
2627         int __leftop1881__ = 32;
2628         int __leftop1883__ = 32;
2629         int __leftop1885__ = 32;
2630         int __leftop1887__ = 32;
2631         int __rightop1888__ = 0;
2632         int __rightop1886__ = __leftop1887__ + __rightop1888__;
2633         int __rightop1884__ = __leftop1885__ + __rightop1886__;
2634         int __rightop1882__ = __leftop1883__ + __rightop1884__;
2635         int __rightop1880__ = __leftop1881__ + __rightop1882__;
2636         int __rightop1878__ = __leftop1879__ + __rightop1880__;
2637         int __sizeof1876__ = __leftop1877__ + __rightop1878__;
2638         int __high1889__ = __left1874__ + __sizeof1876__;
2639         assertvalidmemory(__left1874__, __high1889__);
2640         // __left1874__ = d.s
2641         // __offsetinbits1890__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2642         int __leftop1891__ = 32;
2643         int __leftop1893__ = 32;
2644         int __leftop1895__ = 32;
2645         int __leftop1897__ = 32;
2646         int __leftop1899__ = 32;
2647         int __rightop1900__ = 0;
2648         int __rightop1898__ = __leftop1899__ + __rightop1900__;
2649         int __rightop1896__ = __leftop1897__ + __rightop1898__;
2650         int __rightop1894__ = __leftop1895__ + __rightop1896__;
2651         int __rightop1892__ = __leftop1893__ + __rightop1894__;
2652         int __offsetinbits1890__ = __leftop1891__ + __rightop1892__;
2653         // __offsetinbits1890__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2654         int __offset1901__ = __offsetinbits1890__ >> 3;
2655         int __shift1902__ = __offsetinbits1890__ - (__offset1901__ << 3);
2656         int __rightop1873__ = ((*(int *)(__left1874__ + __offset1901__))  >> __shift1902__) & 0xffffffff;
2657         int __leftop1871__ = __leftop1872__ * __rightop1873__;
2658         int __rightop1903__ = 0;
2659         int __sizeof1870__ = __leftop1871__ + __rightop1903__;
2660         int __high1904__ = __expr1829__ + __sizeof1870__;
2661         assertvalidmemory(__expr1829__, __high1904__);
2662         int __left1828__ = (int) __expr1829__;
2663         // __left1828__ = cast(__InodeTable__, d.b[itb])
2664         // __offsetinbits1905__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2665         int __leftop1906__ = 0;
2666         int __leftop1909__ = 32;
2667         int __leftop1912__ = 32;
2668         int __rightop1913__ = 12;
2669         int __leftop1911__ = __leftop1912__ * __rightop1913__;
2670         int __leftop1915__ = 32;
2671         int __rightop1916__ = 0;
2672         int __rightop1914__ = __leftop1915__ + __rightop1916__;
2673         int __rightop1910__ = __leftop1911__ + __rightop1914__;
2674         int __leftop1908__ = __leftop1909__ + __rightop1910__;
2675         int __rightop1917__ = (int) __i__; //varexpr
2676         int __rightop1907__ = __leftop1908__ * __rightop1917__;
2677         int __offsetinbits1905__ = __leftop1906__ + __rightop1907__;
2678         // __offsetinbits1905__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2679         int __offset1918__ = __offsetinbits1905__ >> 3;
2680         int __left1827__ = (__left1828__ + __offset1918__);
2681         int __leftop1920__ = 32;
2682         int __leftop1923__ = 32;
2683         int __rightop1924__ = 12;
2684         int __leftop1922__ = __leftop1923__ * __rightop1924__;
2685         int __leftop1926__ = 32;
2686         int __rightop1927__ = 0;
2687         int __rightop1925__ = __leftop1926__ + __rightop1927__;
2688         int __rightop1921__ = __leftop1922__ + __rightop1925__;
2689         int __sizeof1919__ = __leftop1920__ + __rightop1921__;
2690         int __high1928__ = __left1827__ + __sizeof1919__;
2691         assertvalidmemory(__left1827__, __high1928__);
2692         // __left1827__ = cast(__InodeTable__, d.b[itb]).itable[i]
2693         // __offsetinbits1929__ <-- ((32 + 0) + (32 * j))
2694         int __leftop1931__ = 32;
2695         int __rightop1932__ = 0;
2696         int __leftop1930__ = __leftop1931__ + __rightop1932__;
2697         int __leftop1934__ = 32;
2698         int __rightop1935__ = (int) __j__; //varexpr
2699         int __rightop1933__ = __leftop1934__ * __rightop1935__;
2700         int __offsetinbits1929__ = __leftop1930__ + __rightop1933__;
2701         // __offsetinbits1929__ = ((32 + 0) + (32 * j))
2702         int __offset1936__ = __offsetinbits1929__ >> 3;
2703         int __shift1937__ = __offsetinbits1929__ - (__offset1936__ << 3);
2704         int __leftop1826__ = ((*(int *)(__left1827__ + __offset1936__))  >> __shift1937__) & 0xffffffff;
2705         int __rightop1938__ = 0;
2706         int __leftop1825__ = __leftop1826__ == __rightop1938__;
2707         int __tempvar1824__ = !__leftop1825__;
2708         if (__tempvar1824__)
2709           {
2710           int __leftele1939__ = (int) __i__; //varexpr
2711           // __left1941__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2712           // __left1942__ <-- cast(__InodeTable__, d.b[itb])
2713           // __left1944__ <-- d
2714           int __left1944__ = (int) d; //varexpr
2715           // __left1944__ = d
2716           // __offsetinbits1945__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2717           int __leftop1946__ = 0;
2718           int __leftop1950__ = 8;
2719           // __left1952__ <-- d.s
2720           // __left1953__ <-- d
2721           int __left1953__ = (int) d; //varexpr
2722           // __left1953__ = d
2723           int __left1952__ = (__left1953__ + 0);
2724           int __leftop1955__ = 32;
2725           int __leftop1957__ = 32;
2726           int __leftop1959__ = 32;
2727           int __leftop1961__ = 32;
2728           int __leftop1963__ = 32;
2729           int __leftop1965__ = 32;
2730           int __rightop1966__ = 0;
2731           int __rightop1964__ = __leftop1965__ + __rightop1966__;
2732           int __rightop1962__ = __leftop1963__ + __rightop1964__;
2733           int __rightop1960__ = __leftop1961__ + __rightop1962__;
2734           int __rightop1958__ = __leftop1959__ + __rightop1960__;
2735           int __rightop1956__ = __leftop1957__ + __rightop1958__;
2736           int __sizeof1954__ = __leftop1955__ + __rightop1956__;
2737           int __high1967__ = __left1952__ + __sizeof1954__;
2738           assertvalidmemory(__left1952__, __high1967__);
2739           // __left1952__ = d.s
2740           // __offsetinbits1968__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2741           int __leftop1969__ = 32;
2742           int __leftop1971__ = 32;
2743           int __leftop1973__ = 32;
2744           int __leftop1975__ = 32;
2745           int __leftop1977__ = 32;
2746           int __rightop1978__ = 0;
2747           int __rightop1976__ = __leftop1977__ + __rightop1978__;
2748           int __rightop1974__ = __leftop1975__ + __rightop1976__;
2749           int __rightop1972__ = __leftop1973__ + __rightop1974__;
2750           int __rightop1970__ = __leftop1971__ + __rightop1972__;
2751           int __offsetinbits1968__ = __leftop1969__ + __rightop1970__;
2752           // __offsetinbits1968__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2753           int __offset1979__ = __offsetinbits1968__ >> 3;
2754           int __shift1980__ = __offsetinbits1968__ - (__offset1979__ << 3);
2755           int __rightop1951__ = ((*(int *)(__left1952__ + __offset1979__))  >> __shift1980__) & 0xffffffff;
2756           int __leftop1949__ = __leftop1950__ * __rightop1951__;
2757           int __rightop1981__ = 0;
2758           int __leftop1948__ = __leftop1949__ + __rightop1981__;
2759           int __rightop1982__ = (int) __itb__; //varexpr
2760           int __rightop1947__ = __leftop1948__ * __rightop1982__;
2761           int __offsetinbits1945__ = __leftop1946__ + __rightop1947__;
2762           // __offsetinbits1945__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2763           int __offset1983__ = __offsetinbits1945__ >> 3;
2764           int __expr1943__ = (__left1944__ + __offset1983__);
2765           int __leftop1986__ = 8;
2766           // __left1988__ <-- d.s
2767           // __left1989__ <-- d
2768           int __left1989__ = (int) d; //varexpr
2769           // __left1989__ = d
2770           int __left1988__ = (__left1989__ + 0);
2771           int __leftop1991__ = 32;
2772           int __leftop1993__ = 32;
2773           int __leftop1995__ = 32;
2774           int __leftop1997__ = 32;
2775           int __leftop1999__ = 32;
2776           int __leftop2001__ = 32;
2777           int __rightop2002__ = 0;
2778           int __rightop2000__ = __leftop2001__ + __rightop2002__;
2779           int __rightop1998__ = __leftop1999__ + __rightop2000__;
2780           int __rightop1996__ = __leftop1997__ + __rightop1998__;
2781           int __rightop1994__ = __leftop1995__ + __rightop1996__;
2782           int __rightop1992__ = __leftop1993__ + __rightop1994__;
2783           int __sizeof1990__ = __leftop1991__ + __rightop1992__;
2784           int __high2003__ = __left1988__ + __sizeof1990__;
2785           assertvalidmemory(__left1988__, __high2003__);
2786           // __left1988__ = d.s
2787           // __offsetinbits2004__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2788           int __leftop2005__ = 32;
2789           int __leftop2007__ = 32;
2790           int __leftop2009__ = 32;
2791           int __leftop2011__ = 32;
2792           int __leftop2013__ = 32;
2793           int __rightop2014__ = 0;
2794           int __rightop2012__ = __leftop2013__ + __rightop2014__;
2795           int __rightop2010__ = __leftop2011__ + __rightop2012__;
2796           int __rightop2008__ = __leftop2009__ + __rightop2010__;
2797           int __rightop2006__ = __leftop2007__ + __rightop2008__;
2798           int __offsetinbits2004__ = __leftop2005__ + __rightop2006__;
2799           // __offsetinbits2004__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2800           int __offset2015__ = __offsetinbits2004__ >> 3;
2801           int __shift2016__ = __offsetinbits2004__ - (__offset2015__ << 3);
2802           int __rightop1987__ = ((*(int *)(__left1988__ + __offset2015__))  >> __shift2016__) & 0xffffffff;
2803           int __leftop1985__ = __leftop1986__ * __rightop1987__;
2804           int __rightop2017__ = 0;
2805           int __sizeof1984__ = __leftop1985__ + __rightop2017__;
2806           int __high2018__ = __expr1943__ + __sizeof1984__;
2807           assertvalidmemory(__expr1943__, __high2018__);
2808           int __left1942__ = (int) __expr1943__;
2809           // __left1942__ = cast(__InodeTable__, d.b[itb])
2810           // __offsetinbits2019__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2811           int __leftop2020__ = 0;
2812           int __leftop2023__ = 32;
2813           int __leftop2026__ = 32;
2814           int __rightop2027__ = 12;
2815           int __leftop2025__ = __leftop2026__ * __rightop2027__;
2816           int __leftop2029__ = 32;
2817           int __rightop2030__ = 0;
2818           int __rightop2028__ = __leftop2029__ + __rightop2030__;
2819           int __rightop2024__ = __leftop2025__ + __rightop2028__;
2820           int __leftop2022__ = __leftop2023__ + __rightop2024__;
2821           int __rightop2031__ = (int) __i__; //varexpr
2822           int __rightop2021__ = __leftop2022__ * __rightop2031__;
2823           int __offsetinbits2019__ = __leftop2020__ + __rightop2021__;
2824           // __offsetinbits2019__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2825           int __offset2032__ = __offsetinbits2019__ >> 3;
2826           int __left1941__ = (__left1942__ + __offset2032__);
2827           int __leftop2034__ = 32;
2828           int __leftop2037__ = 32;
2829           int __rightop2038__ = 12;
2830           int __leftop2036__ = __leftop2037__ * __rightop2038__;
2831           int __leftop2040__ = 32;
2832           int __rightop2041__ = 0;
2833           int __rightop2039__ = __leftop2040__ + __rightop2041__;
2834           int __rightop2035__ = __leftop2036__ + __rightop2039__;
2835           int __sizeof2033__ = __leftop2034__ + __rightop2035__;
2836           int __high2042__ = __left1941__ + __sizeof2033__;
2837           assertvalidmemory(__left1941__, __high2042__);
2838           // __left1941__ = cast(__InodeTable__, d.b[itb]).itable[i]
2839           // __offsetinbits2043__ <-- ((32 + 0) + (32 * j))
2840           int __leftop2045__ = 32;
2841           int __rightop2046__ = 0;
2842           int __leftop2044__ = __leftop2045__ + __rightop2046__;
2843           int __leftop2048__ = 32;
2844           int __rightop2049__ = (int) __j__; //varexpr
2845           int __rightop2047__ = __leftop2048__ * __rightop2049__;
2846           int __offsetinbits2043__ = __leftop2044__ + __rightop2047__;
2847           // __offsetinbits2043__ = ((32 + 0) + (32 * j))
2848           int __offset2050__ = __offsetinbits2043__ >> 3;
2849           int __shift2051__ = __offsetinbits2043__ - (__offset2050__ << 3);
2850           int __rightele1940__ = ((*(int *)(__left1941__ + __offset2050__))  >> __shift2051__) & 0xffffffff;
2851           int __addeditem2053__;
2852           __addeditem2053__ = __contents___hash->add((int)__leftele1939__, (int)__rightele1940__);
2853           __addeditem2053__ = __contents___hashinv->add((int)__rightele1940__, (int)__leftele1939__);
2854           }
2855         }
2856       }
2857     }
2858   }
2859
2860
2861 // build rule7
2862   {
2863   int __tempvar2054__ = 0;
2864   // __left2057__ <-- d.s
2865   // __left2058__ <-- d
2866   int __left2058__ = (int) d; //varexpr
2867   // __left2058__ = d
2868   int __left2057__ = (__left2058__ + 0);
2869   int __leftop2060__ = 32;
2870   int __leftop2062__ = 32;
2871   int __leftop2064__ = 32;
2872   int __leftop2066__ = 32;
2873   int __leftop2068__ = 32;
2874   int __leftop2070__ = 32;
2875   int __rightop2071__ = 0;
2876   int __rightop2069__ = __leftop2070__ + __rightop2071__;
2877   int __rightop2067__ = __leftop2068__ + __rightop2069__;
2878   int __rightop2065__ = __leftop2066__ + __rightop2067__;
2879   int __rightop2063__ = __leftop2064__ + __rightop2065__;
2880   int __rightop2061__ = __leftop2062__ + __rightop2063__;
2881   int __sizeof2059__ = __leftop2060__ + __rightop2061__;
2882   int __high2072__ = __left2057__ + __sizeof2059__;
2883   assertvalidmemory(__left2057__, __high2072__);
2884   // __left2057__ = d.s
2885   // __offsetinbits2073__ <-- (32 + (32 + (32 + 0)))
2886   int __leftop2074__ = 32;
2887   int __leftop2076__ = 32;
2888   int __leftop2078__ = 32;
2889   int __rightop2079__ = 0;
2890   int __rightop2077__ = __leftop2078__ + __rightop2079__;
2891   int __rightop2075__ = __leftop2076__ + __rightop2077__;
2892   int __offsetinbits2073__ = __leftop2074__ + __rightop2075__;
2893   // __offsetinbits2073__ = (32 + (32 + (32 + 0)))
2894   int __offset2080__ = __offsetinbits2073__ >> 3;
2895   int __shift2081__ = __offsetinbits2073__ - (__offset2080__ << 3);
2896   int __leftop2056__ = ((*(int *)(__left2057__ + __offset2080__))  >> __shift2081__) & 0xffffffff;
2897   int __rightop2082__ = 1;
2898   int __tempvar2055__ = __leftop2056__ - __rightop2082__;
2899   for (int __j__ = __tempvar2054__; __j__ <= __tempvar2055__; __j__++)
2900     {
2901     //(j in? __UsedInode__)
2902     int __element2085__ = (int) __j__; //varexpr
2903     int __leftop2084__ = __UsedInode___hash->contains(__element2085__);
2904     int __tempvar2083__ = !__leftop2084__;
2905     if (__tempvar2083__)
2906       {
2907       int __element2086__ = (int) __j__; //varexpr
2908       int __addeditem2087__ = 1;
2909       __addeditem2087__ = __FreeInode___hash->add((int)__element2086__, (int)__element2086__);
2910       }
2911     }
2912   }
2913
2914
2915 // build rule17
2916   {
2917   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); )
2918     {
2919     int __j__ = (int) __j___iterator->next();
2920     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
2921       {
2922       int __itb__ = (int) __itb___iterator->next();
2923       //true
2924       int __tempvar2088__ = 1;
2925       if (__tempvar2088__)
2926         {
2927         int __leftele2089__ = (int) __j__; //varexpr
2928         // __left2091__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
2929         // __left2092__ <-- cast(__InodeTable__, d.b[itb])
2930         // __left2094__ <-- d
2931         int __left2094__ = (int) d; //varexpr
2932         // __left2094__ = d
2933         // __offsetinbits2095__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2934         int __leftop2096__ = 0;
2935         int __leftop2100__ = 8;
2936         // __left2102__ <-- d.s
2937         // __left2103__ <-- d
2938         int __left2103__ = (int) d; //varexpr
2939         // __left2103__ = d
2940         int __left2102__ = (__left2103__ + 0);
2941         int __leftop2105__ = 32;
2942         int __leftop2107__ = 32;
2943         int __leftop2109__ = 32;
2944         int __leftop2111__ = 32;
2945         int __leftop2113__ = 32;
2946         int __leftop2115__ = 32;
2947         int __rightop2116__ = 0;
2948         int __rightop2114__ = __leftop2115__ + __rightop2116__;
2949         int __rightop2112__ = __leftop2113__ + __rightop2114__;
2950         int __rightop2110__ = __leftop2111__ + __rightop2112__;
2951         int __rightop2108__ = __leftop2109__ + __rightop2110__;
2952         int __rightop2106__ = __leftop2107__ + __rightop2108__;
2953         int __sizeof2104__ = __leftop2105__ + __rightop2106__;
2954         int __high2117__ = __left2102__ + __sizeof2104__;
2955         assertvalidmemory(__left2102__, __high2117__);
2956         // __left2102__ = d.s
2957         // __offsetinbits2118__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2958         int __leftop2119__ = 32;
2959         int __leftop2121__ = 32;
2960         int __leftop2123__ = 32;
2961         int __leftop2125__ = 32;
2962         int __leftop2127__ = 32;
2963         int __rightop2128__ = 0;
2964         int __rightop2126__ = __leftop2127__ + __rightop2128__;
2965         int __rightop2124__ = __leftop2125__ + __rightop2126__;
2966         int __rightop2122__ = __leftop2123__ + __rightop2124__;
2967         int __rightop2120__ = __leftop2121__ + __rightop2122__;
2968         int __offsetinbits2118__ = __leftop2119__ + __rightop2120__;
2969         // __offsetinbits2118__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2970         int __offset2129__ = __offsetinbits2118__ >> 3;
2971         int __shift2130__ = __offsetinbits2118__ - (__offset2129__ << 3);
2972         int __rightop2101__ = ((*(int *)(__left2102__ + __offset2129__))  >> __shift2130__) & 0xffffffff;
2973         int __leftop2099__ = __leftop2100__ * __rightop2101__;
2974         int __rightop2131__ = 0;
2975         int __leftop2098__ = __leftop2099__ + __rightop2131__;
2976         int __rightop2132__ = (int) __itb__; //varexpr
2977         int __rightop2097__ = __leftop2098__ * __rightop2132__;
2978         int __offsetinbits2095__ = __leftop2096__ + __rightop2097__;
2979         // __offsetinbits2095__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2980         int __offset2133__ = __offsetinbits2095__ >> 3;
2981         int __expr2093__ = (__left2094__ + __offset2133__);
2982         int __leftop2136__ = 8;
2983         // __left2138__ <-- d.s
2984         // __left2139__ <-- d
2985         int __left2139__ = (int) d; //varexpr
2986         // __left2139__ = d
2987         int __left2138__ = (__left2139__ + 0);
2988         int __leftop2141__ = 32;
2989         int __leftop2143__ = 32;
2990         int __leftop2145__ = 32;
2991         int __leftop2147__ = 32;
2992         int __leftop2149__ = 32;
2993         int __leftop2151__ = 32;
2994         int __rightop2152__ = 0;
2995         int __rightop2150__ = __leftop2151__ + __rightop2152__;
2996         int __rightop2148__ = __leftop2149__ + __rightop2150__;
2997         int __rightop2146__ = __leftop2147__ + __rightop2148__;
2998         int __rightop2144__ = __leftop2145__ + __rightop2146__;
2999         int __rightop2142__ = __leftop2143__ + __rightop2144__;
3000         int __sizeof2140__ = __leftop2141__ + __rightop2142__;
3001         int __high2153__ = __left2138__ + __sizeof2140__;
3002         assertvalidmemory(__left2138__, __high2153__);
3003         // __left2138__ = d.s
3004         // __offsetinbits2154__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3005         int __leftop2155__ = 32;
3006         int __leftop2157__ = 32;
3007         int __leftop2159__ = 32;
3008         int __leftop2161__ = 32;
3009         int __leftop2163__ = 32;
3010         int __rightop2164__ = 0;
3011         int __rightop2162__ = __leftop2163__ + __rightop2164__;
3012         int __rightop2160__ = __leftop2161__ + __rightop2162__;
3013         int __rightop2158__ = __leftop2159__ + __rightop2160__;
3014         int __rightop2156__ = __leftop2157__ + __rightop2158__;
3015         int __offsetinbits2154__ = __leftop2155__ + __rightop2156__;
3016         // __offsetinbits2154__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3017         int __offset2165__ = __offsetinbits2154__ >> 3;
3018         int __shift2166__ = __offsetinbits2154__ - (__offset2165__ << 3);
3019         int __rightop2137__ = ((*(int *)(__left2138__ + __offset2165__))  >> __shift2166__) & 0xffffffff;
3020         int __leftop2135__ = __leftop2136__ * __rightop2137__;
3021         int __rightop2167__ = 0;
3022         int __sizeof2134__ = __leftop2135__ + __rightop2167__;
3023         int __high2168__ = __expr2093__ + __sizeof2134__;
3024         assertvalidmemory(__expr2093__, __high2168__);
3025         int __left2092__ = (int) __expr2093__;
3026         // __left2092__ = cast(__InodeTable__, d.b[itb])
3027         // __offsetinbits2169__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
3028         int __leftop2170__ = 0;
3029         int __leftop2173__ = 32;
3030         int __leftop2176__ = 32;
3031         int __rightop2177__ = 12;
3032         int __leftop2175__ = __leftop2176__ * __rightop2177__;
3033         int __leftop2179__ = 32;
3034         int __rightop2180__ = 0;
3035         int __rightop2178__ = __leftop2179__ + __rightop2180__;
3036         int __rightop2174__ = __leftop2175__ + __rightop2178__;
3037         int __leftop2172__ = __leftop2173__ + __rightop2174__;
3038         int __rightop2181__ = (int) __j__; //varexpr
3039         int __rightop2171__ = __leftop2172__ * __rightop2181__;
3040         int __offsetinbits2169__ = __leftop2170__ + __rightop2171__;
3041         // __offsetinbits2169__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
3042         int __offset2182__ = __offsetinbits2169__ >> 3;
3043         int __left2091__ = (__left2092__ + __offset2182__);
3044         int __leftop2184__ = 32;
3045         int __leftop2187__ = 32;
3046         int __rightop2188__ = 12;
3047         int __leftop2186__ = __leftop2187__ * __rightop2188__;
3048         int __leftop2190__ = 32;
3049         int __rightop2191__ = 0;
3050         int __rightop2189__ = __leftop2190__ + __rightop2191__;
3051         int __rightop2185__ = __leftop2186__ + __rightop2189__;
3052         int __sizeof2183__ = __leftop2184__ + __rightop2185__;
3053         int __high2192__ = __left2091__ + __sizeof2183__;
3054         assertvalidmemory(__left2091__, __high2192__);
3055         // __left2091__ = cast(__InodeTable__, d.b[itb]).itable[j]
3056         int __rightele2090__ = ((*(int *)(__left2091__ + 0))  >> 0) & 0xffffffff;
3057         int __addeditem2194__;
3058         __addeditem2194__ = __filesize___hash->add((int)__leftele2089__, (int)__rightele2090__);
3059         }
3060       }
3061     }
3062   }
3063
3064
3065 // build rule18
3066   {
3067   int __tempvar2195__ = 0;
3068   // __left2198__ <-- d.s
3069   // __left2199__ <-- d
3070   int __left2199__ = (int) d; //varexpr
3071   // __left2199__ = d
3072   int __left2198__ = (__left2199__ + 0);
3073   int __leftop2201__ = 32;
3074   int __leftop2203__ = 32;
3075   int __leftop2205__ = 32;
3076   int __leftop2207__ = 32;
3077   int __leftop2209__ = 32;
3078   int __leftop2211__ = 32;
3079   int __rightop2212__ = 0;
3080   int __rightop2210__ = __leftop2211__ + __rightop2212__;
3081   int __rightop2208__ = __leftop2209__ + __rightop2210__;
3082   int __rightop2206__ = __leftop2207__ + __rightop2208__;
3083   int __rightop2204__ = __leftop2205__ + __rightop2206__;
3084   int __rightop2202__ = __leftop2203__ + __rightop2204__;
3085   int __sizeof2200__ = __leftop2201__ + __rightop2202__;
3086   int __high2213__ = __left2198__ + __sizeof2200__;
3087   assertvalidmemory(__left2198__, __high2213__);
3088   // __left2198__ = d.s
3089   // __offsetinbits2214__ <-- (32 + (32 + 0))
3090   int __leftop2215__ = 32;
3091   int __leftop2217__ = 32;
3092   int __rightop2218__ = 0;
3093   int __rightop2216__ = __leftop2217__ + __rightop2218__;
3094   int __offsetinbits2214__ = __leftop2215__ + __rightop2216__;
3095   // __offsetinbits2214__ = (32 + (32 + 0))
3096   int __offset2219__ = __offsetinbits2214__ >> 3;
3097   int __shift2220__ = __offsetinbits2214__ - (__offset2219__ << 3);
3098   int __leftop2197__ = ((*(int *)(__left2198__ + __offset2219__))  >> __shift2220__) & 0xffffffff;
3099   int __rightop2221__ = 1;
3100   int __tempvar2196__ = __leftop2197__ - __rightop2221__;
3101   for (int __j__ = __tempvar2195__; __j__ <= __tempvar2196__; __j__++)
3102     {
3103     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); )
3104       {
3105       int __bbb__ = (int) __bbb___iterator->next();
3106       //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == false)
3107       // __left2224__ <-- cast(__BlockBitmap__, d.b[bbb])
3108       // __left2226__ <-- d
3109       int __left2226__ = (int) d; //varexpr
3110       // __left2226__ = d
3111       // __offsetinbits2227__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
3112       int __leftop2228__ = 0;
3113       int __leftop2232__ = 8;
3114       // __left2234__ <-- d.s
3115       // __left2235__ <-- d
3116       int __left2235__ = (int) d; //varexpr
3117       // __left2235__ = d
3118       int __left2234__ = (__left2235__ + 0);
3119       int __leftop2237__ = 32;
3120       int __leftop2239__ = 32;
3121       int __leftop2241__ = 32;
3122       int __leftop2243__ = 32;
3123       int __leftop2245__ = 32;
3124       int __leftop2247__ = 32;
3125       int __rightop2248__ = 0;
3126       int __rightop2246__ = __leftop2247__ + __rightop2248__;
3127       int __rightop2244__ = __leftop2245__ + __rightop2246__;
3128       int __rightop2242__ = __leftop2243__ + __rightop2244__;
3129       int __rightop2240__ = __leftop2241__ + __rightop2242__;
3130       int __rightop2238__ = __leftop2239__ + __rightop2240__;
3131       int __sizeof2236__ = __leftop2237__ + __rightop2238__;
3132       int __high2249__ = __left2234__ + __sizeof2236__;
3133       assertvalidmemory(__left2234__, __high2249__);
3134       // __left2234__ = d.s
3135       // __offsetinbits2250__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3136       int __leftop2251__ = 32;
3137       int __leftop2253__ = 32;
3138       int __leftop2255__ = 32;
3139       int __leftop2257__ = 32;
3140       int __leftop2259__ = 32;
3141       int __rightop2260__ = 0;
3142       int __rightop2258__ = __leftop2259__ + __rightop2260__;
3143       int __rightop2256__ = __leftop2257__ + __rightop2258__;
3144       int __rightop2254__ = __leftop2255__ + __rightop2256__;
3145       int __rightop2252__ = __leftop2253__ + __rightop2254__;
3146       int __offsetinbits2250__ = __leftop2251__ + __rightop2252__;
3147       // __offsetinbits2250__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3148       int __offset2261__ = __offsetinbits2250__ >> 3;
3149       int __shift2262__ = __offsetinbits2250__ - (__offset2261__ << 3);
3150       int __rightop2233__ = ((*(int *)(__left2234__ + __offset2261__))  >> __shift2262__) & 0xffffffff;
3151       int __leftop2231__ = __leftop2232__ * __rightop2233__;
3152       int __rightop2263__ = 0;
3153       int __leftop2230__ = __leftop2231__ + __rightop2263__;
3154       int __rightop2264__ = (int) __bbb__; //varexpr
3155       int __rightop2229__ = __leftop2230__ * __rightop2264__;
3156       int __offsetinbits2227__ = __leftop2228__ + __rightop2229__;
3157       // __offsetinbits2227__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
3158       int __offset2265__ = __offsetinbits2227__ >> 3;
3159       int __expr2225__ = (__left2226__ + __offset2265__);
3160       int __leftop2268__ = 8;
3161       // __left2270__ <-- d.s
3162       // __left2271__ <-- d
3163       int __left2271__ = (int) d; //varexpr
3164       // __left2271__ = d
3165       int __left2270__ = (__left2271__ + 0);
3166       int __leftop2273__ = 32;
3167       int __leftop2275__ = 32;
3168       int __leftop2277__ = 32;
3169       int __leftop2279__ = 32;
3170       int __leftop2281__ = 32;
3171       int __leftop2283__ = 32;
3172       int __rightop2284__ = 0;
3173       int __rightop2282__ = __leftop2283__ + __rightop2284__;
3174       int __rightop2280__ = __leftop2281__ + __rightop2282__;
3175       int __rightop2278__ = __leftop2279__ + __rightop2280__;
3176       int __rightop2276__ = __leftop2277__ + __rightop2278__;
3177       int __rightop2274__ = __leftop2275__ + __rightop2276__;
3178       int __sizeof2272__ = __leftop2273__ + __rightop2274__;
3179       int __high2285__ = __left2270__ + __sizeof2272__;
3180       assertvalidmemory(__left2270__, __high2285__);
3181       // __left2270__ = d.s
3182       // __offsetinbits2286__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3183       int __leftop2287__ = 32;
3184       int __leftop2289__ = 32;
3185       int __leftop2291__ = 32;
3186       int __leftop2293__ = 32;
3187       int __leftop2295__ = 32;
3188       int __rightop2296__ = 0;
3189       int __rightop2294__ = __leftop2295__ + __rightop2296__;
3190       int __rightop2292__ = __leftop2293__ + __rightop2294__;
3191       int __rightop2290__ = __leftop2291__ + __rightop2292__;
3192       int __rightop2288__ = __leftop2289__ + __rightop2290__;
3193       int __offsetinbits2286__ = __leftop2287__ + __rightop2288__;
3194       // __offsetinbits2286__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3195       int __offset2297__ = __offsetinbits2286__ >> 3;
3196       int __shift2298__ = __offsetinbits2286__ - (__offset2297__ << 3);
3197       int __rightop2269__ = ((*(int *)(__left2270__ + __offset2297__))  >> __shift2298__) & 0xffffffff;
3198       int __leftop2267__ = __leftop2268__ * __rightop2269__;
3199       int __rightop2299__ = 0;
3200       int __sizeof2266__ = __leftop2267__ + __rightop2299__;
3201       int __high2300__ = __expr2225__ + __sizeof2266__;
3202       assertvalidmemory(__expr2225__, __high2300__);
3203       int __left2224__ = (int) __expr2225__;
3204       // __left2224__ = cast(__BlockBitmap__, d.b[bbb])
3205       // __offsetinbits2301__ <-- (0 + (1 * j))
3206       int __leftop2302__ = 0;
3207       int __leftop2304__ = 1;
3208       int __rightop2305__ = (int) __j__; //varexpr
3209       int __rightop2303__ = __leftop2304__ * __rightop2305__;
3210       int __offsetinbits2301__ = __leftop2302__ + __rightop2303__;
3211       // __offsetinbits2301__ = (0 + (1 * j))
3212       int __offset2306__ = __offsetinbits2301__ >> 3;
3213       int __shift2307__ = __offsetinbits2301__ - (__offset2306__ << 3);
3214       int __leftop2223__ = ((*(int *)(__left2224__ + __offset2306__))  >> __shift2307__) & 0x1;
3215       int __rightop2308__ = 0;
3216       int __tempvar2222__ = __leftop2223__ == __rightop2308__;
3217       if (__tempvar2222__)
3218         {
3219         int __leftele2309__ = (int) __j__; //varexpr
3220         int __rightele2310__ = 101;
3221         int __addeditem2312__;
3222         __addeditem2312__ = __blockstatus___hash->add((int)__leftele2309__, (int)__rightele2310__);
3223         }
3224       }
3225     }
3226   }
3227
3228
3229 // build rule19
3230   {
3231   int __tempvar2313__ = 0;
3232   // __left2316__ <-- d.s
3233   // __left2317__ <-- d
3234   int __left2317__ = (int) d; //varexpr
3235   // __left2317__ = d
3236   int __left2316__ = (__left2317__ + 0);
3237   int __leftop2319__ = 32;
3238   int __leftop2321__ = 32;
3239   int __leftop2323__ = 32;
3240   int __leftop2325__ = 32;
3241   int __leftop2327__ = 32;
3242   int __leftop2329__ = 32;
3243   int __rightop2330__ = 0;
3244   int __rightop2328__ = __leftop2329__ + __rightop2330__;
3245   int __rightop2326__ = __leftop2327__ + __rightop2328__;
3246   int __rightop2324__ = __leftop2325__ + __rightop2326__;
3247   int __rightop2322__ = __leftop2323__ + __rightop2324__;
3248   int __rightop2320__ = __leftop2321__ + __rightop2322__;
3249   int __sizeof2318__ = __leftop2319__ + __rightop2320__;
3250   int __high2331__ = __left2316__ + __sizeof2318__;
3251   assertvalidmemory(__left2316__, __high2331__);
3252   // __left2316__ = d.s
3253   // __offsetinbits2332__ <-- (32 + (32 + 0))
3254   int __leftop2333__ = 32;
3255   int __leftop2335__ = 32;
3256   int __rightop2336__ = 0;
3257   int __rightop2334__ = __leftop2335__ + __rightop2336__;
3258   int __offsetinbits2332__ = __leftop2333__ + __rightop2334__;
3259   // __offsetinbits2332__ = (32 + (32 + 0))
3260   int __offset2337__ = __offsetinbits2332__ >> 3;
3261   int __shift2338__ = __offsetinbits2332__ - (__offset2337__ << 3);
3262   int __leftop2315__ = ((*(int *)(__left2316__ + __offset2337__))  >> __shift2338__) & 0xffffffff;
3263   int __rightop2339__ = 1;
3264   int __tempvar2314__ = __leftop2315__ - __rightop2339__;
3265   for (int __j__ = __tempvar2313__; __j__ <= __tempvar2314__; __j__++)
3266     {
3267     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); )
3268       {
3269       int __bbb__ = (int) __bbb___iterator->next();
3270       //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == true)
3271       // __left2342__ <-- cast(__BlockBitmap__, d.b[bbb])
3272       // __left2344__ <-- d
3273       int __left2344__ = (int) d; //varexpr
3274       // __left2344__ = d
3275       // __offsetinbits2345__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
3276       int __leftop2346__ = 0;
3277       int __leftop2350__ = 8;
3278       // __left2352__ <-- d.s
3279       // __left2353__ <-- d
3280       int __left2353__ = (int) d; //varexpr
3281       // __left2353__ = d
3282       int __left2352__ = (__left2353__ + 0);
3283       int __leftop2355__ = 32;
3284       int __leftop2357__ = 32;
3285       int __leftop2359__ = 32;
3286       int __leftop2361__ = 32;
3287       int __leftop2363__ = 32;
3288       int __leftop2365__ = 32;
3289       int __rightop2366__ = 0;
3290       int __rightop2364__ = __leftop2365__ + __rightop2366__;
3291       int __rightop2362__ = __leftop2363__ + __rightop2364__;
3292       int __rightop2360__ = __leftop2361__ + __rightop2362__;
3293       int __rightop2358__ = __leftop2359__ + __rightop2360__;
3294       int __rightop2356__ = __leftop2357__ + __rightop2358__;
3295       int __sizeof2354__ = __leftop2355__ + __rightop2356__;
3296       int __high2367__ = __left2352__ + __sizeof2354__;
3297       assertvalidmemory(__left2352__, __high2367__);
3298       // __left2352__ = d.s
3299       // __offsetinbits2368__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3300       int __leftop2369__ = 32;
3301       int __leftop2371__ = 32;
3302       int __leftop2373__ = 32;
3303       int __leftop2375__ = 32;
3304       int __leftop2377__ = 32;
3305       int __rightop2378__ = 0;
3306       int __rightop2376__ = __leftop2377__ + __rightop2378__;
3307       int __rightop2374__ = __leftop2375__ + __rightop2376__;
3308       int __rightop2372__ = __leftop2373__ + __rightop2374__;
3309       int __rightop2370__ = __leftop2371__ + __rightop2372__;
3310       int __offsetinbits2368__ = __leftop2369__ + __rightop2370__;
3311       // __offsetinbits2368__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3312       int __offset2379__ = __offsetinbits2368__ >> 3;
3313       int __shift2380__ = __offsetinbits2368__ - (__offset2379__ << 3);
3314       int __rightop2351__ = ((*(int *)(__left2352__ + __offset2379__))  >> __shift2380__) & 0xffffffff;
3315       int __leftop2349__ = __leftop2350__ * __rightop2351__;
3316       int __rightop2381__ = 0;
3317       int __leftop2348__ = __leftop2349__ + __rightop2381__;
3318       int __rightop2382__ = (int) __bbb__; //varexpr
3319       int __rightop2347__ = __leftop2348__ * __rightop2382__;
3320       int __offsetinbits2345__ = __leftop2346__ + __rightop2347__;
3321       // __offsetinbits2345__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
3322       int __offset2383__ = __offsetinbits2345__ >> 3;
3323       int __expr2343__ = (__left2344__ + __offset2383__);
3324       int __leftop2386__ = 8;
3325       // __left2388__ <-- d.s
3326       // __left2389__ <-- d
3327       int __left2389__ = (int) d; //varexpr
3328       // __left2389__ = d
3329       int __left2388__ = (__left2389__ + 0);
3330       int __leftop2391__ = 32;
3331       int __leftop2393__ = 32;
3332       int __leftop2395__ = 32;
3333       int __leftop2397__ = 32;
3334       int __leftop2399__ = 32;
3335       int __leftop2401__ = 32;
3336       int __rightop2402__ = 0;
3337       int __rightop2400__ = __leftop2401__ + __rightop2402__;
3338       int __rightop2398__ = __leftop2399__ + __rightop2400__;
3339       int __rightop2396__ = __leftop2397__ + __rightop2398__;
3340       int __rightop2394__ = __leftop2395__ + __rightop2396__;
3341       int __rightop2392__ = __leftop2393__ + __rightop2394__;
3342       int __sizeof2390__ = __leftop2391__ + __rightop2392__;
3343       int __high2403__ = __left2388__ + __sizeof2390__;
3344       assertvalidmemory(__left2388__, __high2403__);
3345       // __left2388__ = d.s
3346       // __offsetinbits2404__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3347       int __leftop2405__ = 32;
3348       int __leftop2407__ = 32;
3349       int __leftop2409__ = 32;
3350       int __leftop2411__ = 32;
3351       int __leftop2413__ = 32;
3352       int __rightop2414__ = 0;
3353       int __rightop2412__ = __leftop2413__ + __rightop2414__;
3354       int __rightop2410__ = __leftop2411__ + __rightop2412__;
3355       int __rightop2408__ = __leftop2409__ + __rightop2410__;
3356       int __rightop2406__ = __leftop2407__ + __rightop2408__;
3357       int __offsetinbits2404__ = __leftop2405__ + __rightop2406__;
3358       // __offsetinbits2404__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3359       int __offset2415__ = __offsetinbits2404__ >> 3;
3360       int __shift2416__ = __offsetinbits2404__ - (__offset2415__ << 3);
3361       int __rightop2387__ = ((*(int *)(__left2388__ + __offset2415__))  >> __shift2416__) & 0xffffffff;
3362       int __leftop2385__ = __leftop2386__ * __rightop2387__;
3363       int __rightop2417__ = 0;
3364       int __sizeof2384__ = __leftop2385__ + __rightop2417__;
3365       int __high2418__ = __expr2343__ + __sizeof2384__;
3366       assertvalidmemory(__expr2343__, __high2418__);
3367       int __left2342__ = (int) __expr2343__;
3368       // __left2342__ = cast(__BlockBitmap__, d.b[bbb])
3369       // __offsetinbits2419__ <-- (0 + (1 * j))
3370       int __leftop2420__ = 0;
3371       int __leftop2422__ = 1;
3372       int __rightop2423__ = (int) __j__; //varexpr
3373       int __rightop2421__ = __leftop2422__ * __rightop2423__;
3374       int __offsetinbits2419__ = __leftop2420__ + __rightop2421__;
3375       // __offsetinbits2419__ = (0 + (1 * j))
3376       int __offset2424__ = __offsetinbits2419__ >> 3;
3377       int __shift2425__ = __offsetinbits2419__ - (__offset2424__ << 3);
3378       int __leftop2341__ = ((*(int *)(__left2342__ + __offset2424__))  >> __shift2425__) & 0x1;
3379       int __rightop2426__ = 1;
3380       int __tempvar2340__ = __leftop2341__ == __rightop2426__;
3381       if (__tempvar2340__)
3382         {
3383         int __leftele2427__ = (int) __j__; //varexpr
3384         int __rightele2428__ = 100;
3385         int __addeditem2430__;
3386         __addeditem2430__ = __blockstatus___hash->add((int)__leftele2427__, (int)__rightele2428__);
3387         }
3388       }
3389     }
3390   }
3391
3392
3393 // build rule20
3394   {
3395   //true
3396   int __tempvar2431__ = 1;
3397   if (__tempvar2431__)
3398     {
3399     int __element2432__ = 0;
3400     int __addeditem2433__ = 1;
3401     __addeditem2433__ = __Block___hash->add((int)__element2432__, (int)__element2432__);
3402     }
3403   }
3404
3405
3406 // build rule21
3407   {
3408   //true
3409   int __tempvar2434__ = 1;
3410   if (__tempvar2434__)
3411     {
3412     int __element2435__ = 1;
3413     int __addeditem2436__ = 1;
3414     __addeditem2436__ = __Block___hash->add((int)__element2435__, (int)__element2435__);
3415     }
3416   }
3417
3418
3419 // build rule22
3420   {
3421   //(d.g.InodeTableBlock < d.s.NumberofBlocks)
3422   // __left2439__ <-- d.g
3423   // __left2440__ <-- d
3424   int __left2440__ = (int) d; //varexpr
3425   // __left2440__ = d
3426   // __offsetinbits2441__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3427   int __leftop2442__ = 0;
3428   int __leftop2446__ = 8;
3429   // __left2448__ <-- d.s
3430   // __left2449__ <-- d
3431   int __left2449__ = (int) d; //varexpr
3432   // __left2449__ = d
3433   int __left2448__ = (__left2449__ + 0);
3434   int __leftop2451__ = 32;
3435   int __leftop2453__ = 32;
3436   int __leftop2455__ = 32;
3437   int __leftop2457__ = 32;
3438   int __leftop2459__ = 32;
3439   int __leftop2461__ = 32;
3440   int __rightop2462__ = 0;
3441   int __rightop2460__ = __leftop2461__ + __rightop2462__;
3442   int __rightop2458__ = __leftop2459__ + __rightop2460__;
3443   int __rightop2456__ = __leftop2457__ + __rightop2458__;
3444   int __rightop2454__ = __leftop2455__ + __rightop2456__;
3445   int __rightop2452__ = __leftop2453__ + __rightop2454__;
3446   int __sizeof2450__ = __leftop2451__ + __rightop2452__;
3447   int __high2463__ = __left2448__ + __sizeof2450__;
3448   assertvalidmemory(__left2448__, __high2463__);
3449   // __left2448__ = d.s
3450   // __offsetinbits2464__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3451   int __leftop2465__ = 32;
3452   int __leftop2467__ = 32;
3453   int __leftop2469__ = 32;
3454   int __leftop2471__ = 32;
3455   int __leftop2473__ = 32;
3456   int __rightop2474__ = 0;
3457   int __rightop2472__ = __leftop2473__ + __rightop2474__;
3458   int __rightop2470__ = __leftop2471__ + __rightop2472__;
3459   int __rightop2468__ = __leftop2469__ + __rightop2470__;
3460   int __rightop2466__ = __leftop2467__ + __rightop2468__;
3461   int __offsetinbits2464__ = __leftop2465__ + __rightop2466__;
3462   // __offsetinbits2464__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3463   int __offset2475__ = __offsetinbits2464__ >> 3;
3464   int __shift2476__ = __offsetinbits2464__ - (__offset2475__ << 3);
3465   int __rightop2447__ = ((*(int *)(__left2448__ + __offset2475__))  >> __shift2476__) & 0xffffffff;
3466   int __leftop2445__ = __leftop2446__ * __rightop2447__;
3467   int __rightop2477__ = 0;
3468   int __leftop2444__ = __leftop2445__ + __rightop2477__;
3469   int __rightop2478__ = 1;
3470   int __rightop2443__ = __leftop2444__ * __rightop2478__;
3471   int __offsetinbits2441__ = __leftop2442__ + __rightop2443__;
3472   // __offsetinbits2441__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3473   int __offset2479__ = __offsetinbits2441__ >> 3;
3474   int __left2439__ = (__left2440__ + __offset2479__);
3475   int __leftop2481__ = 32;
3476   int __leftop2483__ = 32;
3477   int __leftop2485__ = 32;
3478   int __leftop2487__ = 32;
3479   int __leftop2489__ = 32;
3480   int __rightop2490__ = 0;
3481   int __rightop2488__ = __leftop2489__ + __rightop2490__;
3482   int __rightop2486__ = __leftop2487__ + __rightop2488__;
3483   int __rightop2484__ = __leftop2485__ + __rightop2486__;
3484   int __rightop2482__ = __leftop2483__ + __rightop2484__;
3485   int __sizeof2480__ = __leftop2481__ + __rightop2482__;
3486   int __high2491__ = __left2439__ + __sizeof2480__;
3487   assertvalidmemory(__left2439__, __high2491__);
3488   // __left2439__ = d.g
3489   // __offsetinbits2492__ <-- (32 + (32 + 0))
3490   int __leftop2493__ = 32;
3491   int __leftop2495__ = 32;
3492   int __rightop2496__ = 0;
3493   int __rightop2494__ = __leftop2495__ + __rightop2496__;
3494   int __offsetinbits2492__ = __leftop2493__ + __rightop2494__;
3495   // __offsetinbits2492__ = (32 + (32 + 0))
3496   int __offset2497__ = __offsetinbits2492__ >> 3;
3497   int __shift2498__ = __offsetinbits2492__ - (__offset2497__ << 3);
3498   int __leftop2438__ = ((*(int *)(__left2439__ + __offset2497__))  >> __shift2498__) & 0xffffffff;
3499   // __left2500__ <-- d.s
3500   // __left2501__ <-- d
3501   int __left2501__ = (int) d; //varexpr
3502   // __left2501__ = d
3503   int __left2500__ = (__left2501__ + 0);
3504   int __leftop2503__ = 32;
3505   int __leftop2505__ = 32;
3506   int __leftop2507__ = 32;
3507   int __leftop2509__ = 32;
3508   int __leftop2511__ = 32;
3509   int __leftop2513__ = 32;
3510   int __rightop2514__ = 0;
3511   int __rightop2512__ = __leftop2513__ + __rightop2514__;
3512   int __rightop2510__ = __leftop2511__ + __rightop2512__;
3513   int __rightop2508__ = __leftop2509__ + __rightop2510__;
3514   int __rightop2506__ = __leftop2507__ + __rightop2508__;
3515   int __rightop2504__ = __leftop2505__ + __rightop2506__;
3516   int __sizeof2502__ = __leftop2503__ + __rightop2504__;
3517   int __high2515__ = __left2500__ + __sizeof2502__;
3518   assertvalidmemory(__left2500__, __high2515__);
3519   // __left2500__ = d.s
3520   // __offsetinbits2516__ <-- (32 + (32 + 0))
3521   int __leftop2517__ = 32;
3522   int __leftop2519__ = 32;
3523   int __rightop2520__ = 0;
3524   int __rightop2518__ = __leftop2519__ + __rightop2520__;
3525   int __offsetinbits2516__ = __leftop2517__ + __rightop2518__;
3526   // __offsetinbits2516__ = (32 + (32 + 0))
3527   int __offset2521__ = __offsetinbits2516__ >> 3;
3528   int __shift2522__ = __offsetinbits2516__ - (__offset2521__ << 3);
3529   int __rightop2499__ = ((*(int *)(__left2500__ + __offset2521__))  >> __shift2522__) & 0xffffffff;
3530   int __tempvar2437__ = __leftop2438__ < __rightop2499__;
3531   if (__tempvar2437__)
3532     {
3533     // __left2524__ <-- d.g
3534     // __left2525__ <-- d
3535     int __left2525__ = (int) d; //varexpr
3536     // __left2525__ = d
3537     // __offsetinbits2526__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3538     int __leftop2527__ = 0;
3539     int __leftop2531__ = 8;
3540     // __left2533__ <-- d.s
3541     // __left2534__ <-- d
3542     int __left2534__ = (int) d; //varexpr
3543     // __left2534__ = d
3544     int __left2533__ = (__left2534__ + 0);
3545     int __leftop2536__ = 32;
3546     int __leftop2538__ = 32;
3547     int __leftop2540__ = 32;
3548     int __leftop2542__ = 32;
3549     int __leftop2544__ = 32;
3550     int __leftop2546__ = 32;
3551     int __rightop2547__ = 0;
3552     int __rightop2545__ = __leftop2546__ + __rightop2547__;
3553     int __rightop2543__ = __leftop2544__ + __rightop2545__;
3554     int __rightop2541__ = __leftop2542__ + __rightop2543__;
3555     int __rightop2539__ = __leftop2540__ + __rightop2541__;
3556     int __rightop2537__ = __leftop2538__ + __rightop2539__;
3557     int __sizeof2535__ = __leftop2536__ + __rightop2537__;
3558     int __high2548__ = __left2533__ + __sizeof2535__;
3559     assertvalidmemory(__left2533__, __high2548__);
3560     // __left2533__ = d.s
3561     // __offsetinbits2549__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3562     int __leftop2550__ = 32;
3563     int __leftop2552__ = 32;
3564     int __leftop2554__ = 32;
3565     int __leftop2556__ = 32;
3566     int __leftop2558__ = 32;
3567     int __rightop2559__ = 0;
3568     int __rightop2557__ = __leftop2558__ + __rightop2559__;
3569     int __rightop2555__ = __leftop2556__ + __rightop2557__;
3570     int __rightop2553__ = __leftop2554__ + __rightop2555__;
3571     int __rightop2551__ = __leftop2552__ + __rightop2553__;
3572     int __offsetinbits2549__ = __leftop2550__ + __rightop2551__;
3573     // __offsetinbits2549__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3574     int __offset2560__ = __offsetinbits2549__ >> 3;
3575     int __shift2561__ = __offsetinbits2549__ - (__offset2560__ << 3);
3576     int __rightop2532__ = ((*(int *)(__left2533__ + __offset2560__))  >> __shift2561__) & 0xffffffff;
3577     int __leftop2530__ = __leftop2531__ * __rightop2532__;
3578     int __rightop2562__ = 0;
3579     int __leftop2529__ = __leftop2530__ + __rightop2562__;
3580     int __rightop2563__ = 1;
3581     int __rightop2528__ = __leftop2529__ * __rightop2563__;
3582     int __offsetinbits2526__ = __leftop2527__ + __rightop2528__;
3583     // __offsetinbits2526__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3584     int __offset2564__ = __offsetinbits2526__ >> 3;
3585     int __left2524__ = (__left2525__ + __offset2564__);
3586     int __leftop2566__ = 32;
3587     int __leftop2568__ = 32;
3588     int __leftop2570__ = 32;
3589     int __leftop2572__ = 32;
3590     int __leftop2574__ = 32;
3591     int __rightop2575__ = 0;
3592     int __rightop2573__ = __leftop2574__ + __rightop2575__;
3593     int __rightop2571__ = __leftop2572__ + __rightop2573__;
3594     int __rightop2569__ = __leftop2570__ + __rightop2571__;
3595     int __rightop2567__ = __leftop2568__ + __rightop2569__;
3596     int __sizeof2565__ = __leftop2566__ + __rightop2567__;
3597     int __high2576__ = __left2524__ + __sizeof2565__;
3598     assertvalidmemory(__left2524__, __high2576__);
3599     // __left2524__ = d.g
3600     // __offsetinbits2577__ <-- (32 + (32 + 0))
3601     int __leftop2578__ = 32;
3602     int __leftop2580__ = 32;
3603     int __rightop2581__ = 0;
3604     int __rightop2579__ = __leftop2580__ + __rightop2581__;
3605     int __offsetinbits2577__ = __leftop2578__ + __rightop2579__;
3606     // __offsetinbits2577__ = (32 + (32 + 0))
3607     int __offset2582__ = __offsetinbits2577__ >> 3;
3608     int __shift2583__ = __offsetinbits2577__ - (__offset2582__ << 3);
3609     int __element2523__ = ((*(int *)(__left2524__ + __offset2582__))  >> __shift2583__) & 0xffffffff;
3610     int __addeditem2584__ = 1;
3611     __addeditem2584__ = __Block___hash->add((int)__element2523__, (int)__element2523__);
3612     }
3613   }
3614
3615
3616 // build rule23
3617   {
3618   //(d.g.InodeBitmapBlock < d.s.NumberofBlocks)
3619   // __left2587__ <-- d.g
3620   // __left2588__ <-- d
3621   int __left2588__ = (int) d; //varexpr
3622   // __left2588__ = d
3623   // __offsetinbits2589__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3624   int __leftop2590__ = 0;
3625   int __leftop2594__ = 8;
3626   // __left2596__ <-- d.s
3627   // __left2597__ <-- d
3628   int __left2597__ = (int) d; //varexpr
3629   // __left2597__ = d
3630   int __left2596__ = (__left2597__ + 0);
3631   int __leftop2599__ = 32;
3632   int __leftop2601__ = 32;
3633   int __leftop2603__ = 32;
3634   int __leftop2605__ = 32;
3635   int __leftop2607__ = 32;
3636   int __leftop2609__ = 32;
3637   int __rightop2610__ = 0;
3638   int __rightop2608__ = __leftop2609__ + __rightop2610__;
3639   int __rightop2606__ = __leftop2607__ + __rightop2608__;
3640   int __rightop2604__ = __leftop2605__ + __rightop2606__;
3641   int __rightop2602__ = __leftop2603__ + __rightop2604__;
3642   int __rightop2600__ = __leftop2601__ + __rightop2602__;
3643   int __sizeof2598__ = __leftop2599__ + __rightop2600__;
3644   int __high2611__ = __left2596__ + __sizeof2598__;
3645   assertvalidmemory(__left2596__, __high2611__);
3646   // __left2596__ = d.s
3647   // __offsetinbits2612__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3648   int __leftop2613__ = 32;
3649   int __leftop2615__ = 32;
3650   int __leftop2617__ = 32;
3651   int __leftop2619__ = 32;
3652   int __leftop2621__ = 32;
3653   int __rightop2622__ = 0;
3654   int __rightop2620__ = __leftop2621__ + __rightop2622__;
3655   int __rightop2618__ = __leftop2619__ + __rightop2620__;
3656   int __rightop2616__ = __leftop2617__ + __rightop2618__;
3657   int __rightop2614__ = __leftop2615__ + __rightop2616__;
3658   int __offsetinbits2612__ = __leftop2613__ + __rightop2614__;
3659   // __offsetinbits2612__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3660   int __offset2623__ = __offsetinbits2612__ >> 3;
3661   int __shift2624__ = __offsetinbits2612__ - (__offset2623__ << 3);
3662   int __rightop2595__ = ((*(int *)(__left2596__ + __offset2623__))  >> __shift2624__) & 0xffffffff;
3663   int __leftop2593__ = __leftop2594__ * __rightop2595__;
3664   int __rightop2625__ = 0;
3665   int __leftop2592__ = __leftop2593__ + __rightop2625__;
3666   int __rightop2626__ = 1;
3667   int __rightop2591__ = __leftop2592__ * __rightop2626__;
3668   int __offsetinbits2589__ = __leftop2590__ + __rightop2591__;
3669   // __offsetinbits2589__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3670   int __offset2627__ = __offsetinbits2589__ >> 3;
3671   int __left2587__ = (__left2588__ + __offset2627__);
3672   int __leftop2629__ = 32;
3673   int __leftop2631__ = 32;
3674   int __leftop2633__ = 32;
3675   int __leftop2635__ = 32;
3676   int __leftop2637__ = 32;
3677   int __rightop2638__ = 0;
3678   int __rightop2636__ = __leftop2637__ + __rightop2638__;
3679   int __rightop2634__ = __leftop2635__ + __rightop2636__;
3680   int __rightop2632__ = __leftop2633__ + __rightop2634__;
3681   int __rightop2630__ = __leftop2631__ + __rightop2632__;
3682   int __sizeof2628__ = __leftop2629__ + __rightop2630__;
3683   int __high2639__ = __left2587__ + __sizeof2628__;
3684   assertvalidmemory(__left2587__, __high2639__);
3685   // __left2587__ = d.g
3686   // __offsetinbits2640__ <-- (32 + 0)
3687   int __leftop2641__ = 32;
3688   int __rightop2642__ = 0;
3689   int __offsetinbits2640__ = __leftop2641__ + __rightop2642__;
3690   // __offsetinbits2640__ = (32 + 0)
3691   int __offset2643__ = __offsetinbits2640__ >> 3;
3692   int __shift2644__ = __offsetinbits2640__ - (__offset2643__ << 3);
3693   int __leftop2586__ = ((*(int *)(__left2587__ + __offset2643__))  >> __shift2644__) & 0xffffffff;
3694   // __left2646__ <-- d.s
3695   // __left2647__ <-- d
3696   int __left2647__ = (int) d; //varexpr
3697   // __left2647__ = d
3698   int __left2646__ = (__left2647__ + 0);
3699   int __leftop2649__ = 32;
3700   int __leftop2651__ = 32;
3701   int __leftop2653__ = 32;
3702   int __leftop2655__ = 32;
3703   int __leftop2657__ = 32;
3704   int __leftop2659__ = 32;
3705   int __rightop2660__ = 0;
3706   int __rightop2658__ = __leftop2659__ + __rightop2660__;
3707   int __rightop2656__ = __leftop2657__ + __rightop2658__;
3708   int __rightop2654__ = __leftop2655__ + __rightop2656__;
3709   int __rightop2652__ = __leftop2653__ + __rightop2654__;
3710   int __rightop2650__ = __leftop2651__ + __rightop2652__;
3711   int __sizeof2648__ = __leftop2649__ + __rightop2650__;
3712   int __high2661__ = __left2646__ + __sizeof2648__;
3713   assertvalidmemory(__left2646__, __high2661__);
3714   // __left2646__ = d.s
3715   // __offsetinbits2662__ <-- (32 + (32 + 0))
3716   int __leftop2663__ = 32;
3717   int __leftop2665__ = 32;
3718   int __rightop2666__ = 0;
3719   int __rightop2664__ = __leftop2665__ + __rightop2666__;
3720   int __offsetinbits2662__ = __leftop2663__ + __rightop2664__;
3721   // __offsetinbits2662__ = (32 + (32 + 0))
3722   int __offset2667__ = __offsetinbits2662__ >> 3;
3723   int __shift2668__ = __offsetinbits2662__ - (__offset2667__ << 3);
3724   int __rightop2645__ = ((*(int *)(__left2646__ + __offset2667__))  >> __shift2668__) & 0xffffffff;
3725   int __tempvar2585__ = __leftop2586__ < __rightop2645__;
3726   if (__tempvar2585__)
3727     {
3728     // __left2670__ <-- d.g
3729     // __left2671__ <-- d
3730     int __left2671__ = (int) d; //varexpr
3731     // __left2671__ = d
3732     // __offsetinbits2672__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3733     int __leftop2673__ = 0;
3734     int __leftop2677__ = 8;
3735     // __left2679__ <-- d.s
3736     // __left2680__ <-- d
3737     int __left2680__ = (int) d; //varexpr
3738     // __left2680__ = d
3739     int __left2679__ = (__left2680__ + 0);
3740     int __leftop2682__ = 32;
3741     int __leftop2684__ = 32;
3742     int __leftop2686__ = 32;
3743     int __leftop2688__ = 32;
3744     int __leftop2690__ = 32;
3745     int __leftop2692__ = 32;
3746     int __rightop2693__ = 0;
3747     int __rightop2691__ = __leftop2692__ + __rightop2693__;
3748     int __rightop2689__ = __leftop2690__ + __rightop2691__;
3749     int __rightop2687__ = __leftop2688__ + __rightop2689__;
3750     int __rightop2685__ = __leftop2686__ + __rightop2687__;
3751     int __rightop2683__ = __leftop2684__ + __rightop2685__;
3752     int __sizeof2681__ = __leftop2682__ + __rightop2683__;
3753     int __high2694__ = __left2679__ + __sizeof2681__;
3754     assertvalidmemory(__left2679__, __high2694__);
3755     // __left2679__ = d.s
3756     // __offsetinbits2695__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3757     int __leftop2696__ = 32;
3758     int __leftop2698__ = 32;
3759     int __leftop2700__ = 32;
3760     int __leftop2702__ = 32;
3761     int __leftop2704__ = 32;
3762     int __rightop2705__ = 0;
3763     int __rightop2703__ = __leftop2704__ + __rightop2705__;
3764     int __rightop2701__ = __leftop2702__ + __rightop2703__;
3765     int __rightop2699__ = __leftop2700__ + __rightop2701__;
3766     int __rightop2697__ = __leftop2698__ + __rightop2699__;
3767     int __offsetinbits2695__ = __leftop2696__ + __rightop2697__;
3768     // __offsetinbits2695__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3769     int __offset2706__ = __offsetinbits2695__ >> 3;
3770     int __shift2707__ = __offsetinbits2695__ - (__offset2706__ << 3);
3771     int __rightop2678__ = ((*(int *)(__left2679__ + __offset2706__))  >> __shift2707__) & 0xffffffff;
3772     int __leftop2676__ = __leftop2677__ * __rightop2678__;
3773     int __rightop2708__ = 0;
3774     int __leftop2675__ = __leftop2676__ + __rightop2708__;
3775     int __rightop2709__ = 1;
3776     int __rightop2674__ = __leftop2675__ * __rightop2709__;
3777     int __offsetinbits2672__ = __leftop2673__ + __rightop2674__;
3778     // __offsetinbits2672__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3779     int __offset2710__ = __offsetinbits2672__ >> 3;
3780     int __left2670__ = (__left2671__ + __offset2710__);
3781     int __leftop2712__ = 32;
3782     int __leftop2714__ = 32;
3783     int __leftop2716__ = 32;
3784     int __leftop2718__ = 32;
3785     int __leftop2720__ = 32;
3786     int __rightop2721__ = 0;
3787     int __rightop2719__ = __leftop2720__ + __rightop2721__;
3788     int __rightop2717__ = __leftop2718__ + __rightop2719__;
3789     int __rightop2715__ = __leftop2716__ + __rightop2717__;
3790     int __rightop2713__ = __leftop2714__ + __rightop2715__;
3791     int __sizeof2711__ = __leftop2712__ + __rightop2713__;
3792     int __high2722__ = __left2670__ + __sizeof2711__;
3793     assertvalidmemory(__left2670__, __high2722__);
3794     // __left2670__ = d.g
3795     // __offsetinbits2723__ <-- (32 + 0)
3796     int __leftop2724__ = 32;
3797     int __rightop2725__ = 0;
3798     int __offsetinbits2723__ = __leftop2724__ + __rightop2725__;
3799     // __offsetinbits2723__ = (32 + 0)
3800     int __offset2726__ = __offsetinbits2723__ >> 3;
3801     int __shift2727__ = __offsetinbits2723__ - (__offset2726__ << 3);
3802     int __element2669__ = ((*(int *)(__left2670__ + __offset2726__))  >> __shift2727__) & 0xffffffff;
3803     int __addeditem2728__ = 1;
3804     __addeditem2728__ = __Block___hash->add((int)__element2669__, (int)__element2669__);
3805     }
3806   }
3807
3808
3809 // build rule24
3810   {
3811   //(d.g.BlockBitmapBlock < d.s.NumberofBlocks)
3812   // __left2731__ <-- d.g
3813   // __left2732__ <-- d
3814   int __left2732__ = (int) d; //varexpr
3815   // __left2732__ = d
3816   // __offsetinbits2733__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3817   int __leftop2734__ = 0;
3818   int __leftop2738__ = 8;
3819   // __left2740__ <-- d.s
3820   // __left2741__ <-- d
3821   int __left2741__ = (int) d; //varexpr
3822   // __left2741__ = d
3823   int __left2740__ = (__left2741__ + 0);
3824   int __leftop2743__ = 32;
3825   int __leftop2745__ = 32;
3826   int __leftop2747__ = 32;
3827   int __leftop2749__ = 32;
3828   int __leftop2751__ = 32;
3829   int __leftop2753__ = 32;
3830   int __rightop2754__ = 0;
3831   int __rightop2752__ = __leftop2753__ + __rightop2754__;
3832   int __rightop2750__ = __leftop2751__ + __rightop2752__;
3833   int __rightop2748__ = __leftop2749__ + __rightop2750__;
3834   int __rightop2746__ = __leftop2747__ + __rightop2748__;
3835   int __rightop2744__ = __leftop2745__ + __rightop2746__;
3836   int __sizeof2742__ = __leftop2743__ + __rightop2744__;
3837   int __high2755__ = __left2740__ + __sizeof2742__;
3838   assertvalidmemory(__left2740__, __high2755__);
3839   // __left2740__ = d.s
3840   // __offsetinbits2756__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3841   int __leftop2757__ = 32;
3842   int __leftop2759__ = 32;
3843   int __leftop2761__ = 32;
3844   int __leftop2763__ = 32;
3845   int __leftop2765__ = 32;
3846   int __rightop2766__ = 0;
3847   int __rightop2764__ = __leftop2765__ + __rightop2766__;
3848   int __rightop2762__ = __leftop2763__ + __rightop2764__;
3849   int __rightop2760__ = __leftop2761__ + __rightop2762__;
3850   int __rightop2758__ = __leftop2759__ + __rightop2760__;
3851   int __offsetinbits2756__ = __leftop2757__ + __rightop2758__;
3852   // __offsetinbits2756__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3853   int __offset2767__ = __offsetinbits2756__ >> 3;
3854   int __shift2768__ = __offsetinbits2756__ - (__offset2767__ << 3);
3855   int __rightop2739__ = ((*(int *)(__left2740__ + __offset2767__))  >> __shift2768__) & 0xffffffff;
3856   int __leftop2737__ = __leftop2738__ * __rightop2739__;
3857   int __rightop2769__ = 0;
3858   int __leftop2736__ = __leftop2737__ + __rightop2769__;
3859   int __rightop2770__ = 1;
3860   int __rightop2735__ = __leftop2736__ * __rightop2770__;
3861   int __offsetinbits2733__ = __leftop2734__ + __rightop2735__;
3862   // __offsetinbits2733__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3863   int __offset2771__ = __offsetinbits2733__ >> 3;
3864   int __left2731__ = (__left2732__ + __offset2771__);
3865   int __leftop2773__ = 32;
3866   int __leftop2775__ = 32;
3867   int __leftop2777__ = 32;
3868   int __leftop2779__ = 32;
3869   int __leftop2781__ = 32;
3870   int __rightop2782__ = 0;
3871   int __rightop2780__ = __leftop2781__ + __rightop2782__;
3872   int __rightop2778__ = __leftop2779__ + __rightop2780__;
3873   int __rightop2776__ = __leftop2777__ + __rightop2778__;
3874   int __rightop2774__ = __leftop2775__ + __rightop2776__;
3875   int __sizeof2772__ = __leftop2773__ + __rightop2774__;
3876   int __high2783__ = __left2731__ + __sizeof2772__;
3877   assertvalidmemory(__left2731__, __high2783__);
3878   // __left2731__ = d.g
3879   int __leftop2730__ = ((*(int *)(__left2731__ + 0))  >> 0) & 0xffffffff;
3880   // __left2785__ <-- d.s
3881   // __left2786__ <-- d
3882   int __left2786__ = (int) d; //varexpr
3883   // __left2786__ = d
3884   int __left2785__ = (__left2786__ + 0);
3885   int __leftop2788__ = 32;
3886   int __leftop2790__ = 32;
3887   int __leftop2792__ = 32;
3888   int __leftop2794__ = 32;
3889   int __leftop2796__ = 32;
3890   int __leftop2798__ = 32;
3891   int __rightop2799__ = 0;
3892   int __rightop2797__ = __leftop2798__ + __rightop2799__;
3893   int __rightop2795__ = __leftop2796__ + __rightop2797__;
3894   int __rightop2793__ = __leftop2794__ + __rightop2795__;
3895   int __rightop2791__ = __leftop2792__ + __rightop2793__;
3896   int __rightop2789__ = __leftop2790__ + __rightop2791__;
3897   int __sizeof2787__ = __leftop2788__ + __rightop2789__;
3898   int __high2800__ = __left2785__ + __sizeof2787__;
3899   assertvalidmemory(__left2785__, __high2800__);
3900   // __left2785__ = d.s
3901   // __offsetinbits2801__ <-- (32 + (32 + 0))
3902   int __leftop2802__ = 32;
3903   int __leftop2804__ = 32;
3904   int __rightop2805__ = 0;
3905   int __rightop2803__ = __leftop2804__ + __rightop2805__;
3906   int __offsetinbits2801__ = __leftop2802__ + __rightop2803__;
3907   // __offsetinbits2801__ = (32 + (32 + 0))
3908   int __offset2806__ = __offsetinbits2801__ >> 3;
3909   int __shift2807__ = __offsetinbits2801__ - (__offset2806__ << 3);
3910   int __rightop2784__ = ((*(int *)(__left2785__ + __offset2806__))  >> __shift2807__) & 0xffffffff;
3911   int __tempvar2729__ = __leftop2730__ < __rightop2784__;
3912   if (__tempvar2729__)
3913     {
3914     // __left2809__ <-- d.g
3915     // __left2810__ <-- d
3916     int __left2810__ = (int) d; //varexpr
3917     // __left2810__ = d
3918     // __offsetinbits2811__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
3919     int __leftop2812__ = 0;
3920     int __leftop2816__ = 8;
3921     // __left2818__ <-- d.s
3922     // __left2819__ <-- d
3923     int __left2819__ = (int) d; //varexpr
3924     // __left2819__ = d
3925     int __left2818__ = (__left2819__ + 0);
3926     int __leftop2821__ = 32;
3927     int __leftop2823__ = 32;
3928     int __leftop2825__ = 32;
3929     int __leftop2827__ = 32;
3930     int __leftop2829__ = 32;
3931     int __leftop2831__ = 32;
3932     int __rightop2832__ = 0;
3933     int __rightop2830__ = __leftop2831__ + __rightop2832__;
3934     int __rightop2828__ = __leftop2829__ + __rightop2830__;
3935     int __rightop2826__ = __leftop2827__ + __rightop2828__;
3936     int __rightop2824__ = __leftop2825__ + __rightop2826__;
3937     int __rightop2822__ = __leftop2823__ + __rightop2824__;
3938     int __sizeof2820__ = __leftop2821__ + __rightop2822__;
3939     int __high2833__ = __left2818__ + __sizeof2820__;
3940     assertvalidmemory(__left2818__, __high2833__);
3941     // __left2818__ = d.s
3942     // __offsetinbits2834__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3943     int __leftop2835__ = 32;
3944     int __leftop2837__ = 32;
3945     int __leftop2839__ = 32;
3946     int __leftop2841__ = 32;
3947     int __leftop2843__ = 32;
3948     int __rightop2844__ = 0;
3949     int __rightop2842__ = __leftop2843__ + __rightop2844__;
3950     int __rightop2840__ = __leftop2841__ + __rightop2842__;
3951     int __rightop2838__ = __leftop2839__ + __rightop2840__;
3952     int __rightop2836__ = __leftop2837__ + __rightop2838__;
3953     int __offsetinbits2834__ = __leftop2835__ + __rightop2836__;
3954     // __offsetinbits2834__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3955     int __offset2845__ = __offsetinbits2834__ >> 3;
3956     int __shift2846__ = __offsetinbits2834__ - (__offset2845__ << 3);
3957     int __rightop2817__ = ((*(int *)(__left2818__ + __offset2845__))  >> __shift2846__) & 0xffffffff;
3958     int __leftop2815__ = __leftop2816__ * __rightop2817__;
3959     int __rightop2847__ = 0;
3960     int __leftop2814__ = __leftop2815__ + __rightop2847__;
3961     int __rightop2848__ = 1;
3962     int __rightop2813__ = __leftop2814__ * __rightop2848__;
3963     int __offsetinbits2811__ = __leftop2812__ + __rightop2813__;
3964     // __offsetinbits2811__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
3965     int __offset2849__ = __offsetinbits2811__ >> 3;
3966     int __left2809__ = (__left2810__ + __offset2849__);
3967     int __leftop2851__ = 32;
3968     int __leftop2853__ = 32;
3969     int __leftop2855__ = 32;
3970     int __leftop2857__ = 32;
3971     int __leftop2859__ = 32;
3972     int __rightop2860__ = 0;
3973     int __rightop2858__ = __leftop2859__ + __rightop2860__;
3974     int __rightop2856__ = __leftop2857__ + __rightop2858__;
3975     int __rightop2854__ = __leftop2855__ + __rightop2856__;
3976     int __rightop2852__ = __leftop2853__ + __rightop2854__;
3977     int __sizeof2850__ = __leftop2851__ + __rightop2852__;
3978     int __high2861__ = __left2809__ + __sizeof2850__;
3979     assertvalidmemory(__left2809__, __high2861__);
3980     // __left2809__ = d.g
3981     int __element2808__ = ((*(int *)(__left2809__ + 0))  >> 0) & 0xffffffff;
3982     int __addeditem2862__ = 1;
3983     __addeditem2862__ = __Block___hash->add((int)__element2808__, (int)__element2808__);
3984     }
3985   }
3986
3987
3988 // build rule25
3989   {
3990   //(d.s.RootDirectoryInode < d.s.NumberofInodes)
3991   // __left2865__ <-- d.s
3992   // __left2866__ <-- d
3993   int __left2866__ = (int) d; //varexpr
3994   // __left2866__ = d
3995   int __left2865__ = (__left2866__ + 0);
3996   int __leftop2868__ = 32;
3997   int __leftop2870__ = 32;
3998   int __leftop2872__ = 32;
3999   int __leftop2874__ = 32;
4000   int __leftop2876__ = 32;
4001   int __leftop2878__ = 32;
4002   int __rightop2879__ = 0;
4003   int __rightop2877__ = __leftop2878__ + __rightop2879__;
4004   int __rightop2875__ = __leftop2876__ + __rightop2877__;
4005   int __rightop2873__ = __leftop2874__ + __rightop2875__;
4006   int __rightop2871__ = __leftop2872__ + __rightop2873__;
4007   int __rightop2869__ = __leftop2870__ + __rightop2871__;
4008   int __sizeof2867__ = __leftop2868__ + __rightop2869__;
4009   int __high2880__ = __left2865__ + __sizeof2867__;
4010   assertvalidmemory(__left2865__, __high2880__);
4011   // __left2865__ = d.s
4012   // __offsetinbits2881__ <-- (32 + (32 + (32 + (32 + 0))))
4013   int __leftop2882__ = 32;
4014   int __leftop2884__ = 32;
4015   int __leftop2886__ = 32;
4016   int __leftop2888__ = 32;
4017   int __rightop2889__ = 0;
4018   int __rightop2887__ = __leftop2888__ + __rightop2889__;
4019   int __rightop2885__ = __leftop2886__ + __rightop2887__;
4020   int __rightop2883__ = __leftop2884__ + __rightop2885__;
4021   int __offsetinbits2881__ = __leftop2882__ + __rightop2883__;
4022   // __offsetinbits2881__ = (32 + (32 + (32 + (32 + 0))))
4023   int __offset2890__ = __offsetinbits2881__ >> 3;
4024   int __shift2891__ = __offsetinbits2881__ - (__offset2890__ << 3);
4025   int __leftop2864__ = ((*(int *)(__left2865__ + __offset2890__))  >> __shift2891__) & 0xffffffff;
4026   // __left2893__ <-- d.s
4027   // __left2894__ <-- d
4028   int __left2894__ = (int) d; //varexpr
4029   // __left2894__ = d
4030   int __left2893__ = (__left2894__ + 0);
4031   int __leftop2896__ = 32;
4032   int __leftop2898__ = 32;
4033   int __leftop2900__ = 32;
4034   int __leftop2902__ = 32;
4035   int __leftop2904__ = 32;
4036   int __leftop2906__ = 32;
4037   int __rightop2907__ = 0;
4038   int __rightop2905__ = __leftop2906__ + __rightop2907__;
4039   int __rightop2903__ = __leftop2904__ + __rightop2905__;
4040   int __rightop2901__ = __leftop2902__ + __rightop2903__;
4041   int __rightop2899__ = __leftop2900__ + __rightop2901__;
4042   int __rightop2897__ = __leftop2898__ + __rightop2899__;
4043   int __sizeof2895__ = __leftop2896__ + __rightop2897__;
4044   int __high2908__ = __left2893__ + __sizeof2895__;
4045   assertvalidmemory(__left2893__, __high2908__);
4046   // __left2893__ = d.s
4047   // __offsetinbits2909__ <-- (32 + (32 + (32 + 0)))
4048   int __leftop2910__ = 32;
4049   int __leftop2912__ = 32;
4050   int __leftop2914__ = 32;
4051   int __rightop2915__ = 0;
4052   int __rightop2913__ = __leftop2914__ + __rightop2915__;
4053   int __rightop2911__ = __leftop2912__ + __rightop2913__;
4054   int __offsetinbits2909__ = __leftop2910__ + __rightop2911__;
4055   // __offsetinbits2909__ = (32 + (32 + (32 + 0)))
4056   int __offset2916__ = __offsetinbits2909__ >> 3;
4057   int __shift2917__ = __offsetinbits2909__ - (__offset2916__ << 3);
4058   int __rightop2892__ = ((*(int *)(__left2893__ + __offset2916__))  >> __shift2917__) & 0xffffffff;
4059   int __tempvar2863__ = __leftop2864__ < __rightop2892__;
4060   if (__tempvar2863__)
4061     {
4062     // __left2919__ <-- d.s
4063     // __left2920__ <-- d
4064     int __left2920__ = (int) d; //varexpr
4065     // __left2920__ = d
4066     int __left2919__ = (__left2920__ + 0);
4067     int __leftop2922__ = 32;
4068     int __leftop2924__ = 32;
4069     int __leftop2926__ = 32;
4070     int __leftop2928__ = 32;
4071     int __leftop2930__ = 32;
4072     int __leftop2932__ = 32;
4073     int __rightop2933__ = 0;
4074     int __rightop2931__ = __leftop2932__ + __rightop2933__;
4075     int __rightop2929__ = __leftop2930__ + __rightop2931__;
4076     int __rightop2927__ = __leftop2928__ + __rightop2929__;
4077     int __rightop2925__ = __leftop2926__ + __rightop2927__;
4078     int __rightop2923__ = __leftop2924__ + __rightop2925__;
4079     int __sizeof2921__ = __leftop2922__ + __rightop2923__;
4080     int __high2934__ = __left2919__ + __sizeof2921__;
4081     assertvalidmemory(__left2919__, __high2934__);
4082     // __left2919__ = d.s
4083     // __offsetinbits2935__ <-- (32 + (32 + (32 + (32 + 0))))
4084     int __leftop2936__ = 32;
4085     int __leftop2938__ = 32;
4086     int __leftop2940__ = 32;
4087     int __leftop2942__ = 32;
4088     int __rightop2943__ = 0;
4089     int __rightop2941__ = __leftop2942__ + __rightop2943__;
4090     int __rightop2939__ = __leftop2940__ + __rightop2941__;
4091     int __rightop2937__ = __leftop2938__ + __rightop2939__;
4092     int __offsetinbits2935__ = __leftop2936__ + __rightop2937__;
4093     // __offsetinbits2935__ = (32 + (32 + (32 + (32 + 0))))
4094     int __offset2944__ = __offsetinbits2935__ >> 3;
4095     int __shift2945__ = __offsetinbits2935__ - (__offset2944__ << 3);
4096     int __element2918__ = ((*(int *)(__left2919__ + __offset2944__))  >> __shift2945__) & 0xffffffff;
4097     int __addeditem2946__ = 1;
4098     __addeditem2946__ = __Inode___hash->add((int)__element2918__, (int)__element2918__);
4099     }
4100   }
4101
4102
4103 // build rule26
4104   {
4105   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
4106     {
4107     int __i__ = (int) __i___iterator->next();
4108     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
4109       {
4110       int __itb__ = (int) __itb___iterator->next();
4111       int __tempvar2947__ = 0;
4112       int __tempvar2948__ = 11;
4113       for (int __j__ = __tempvar2947__; __j__ <= __tempvar2948__; __j__++)
4114         {
4115         //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks) && ((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0)))
4116         // __left2952__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
4117         // __left2953__ <-- cast(__InodeTable__, d.b[itb])
4118         // __left2955__ <-- d
4119         int __left2955__ = (int) d; //varexpr
4120         // __left2955__ = d
4121         // __offsetinbits2956__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
4122         int __leftop2957__ = 0;
4123         int __leftop2961__ = 8;
4124         // __left2963__ <-- d.s
4125         // __left2964__ <-- d
4126         int __left2964__ = (int) d; //varexpr
4127         // __left2964__ = d
4128         int __left2963__ = (__left2964__ + 0);
4129         int __leftop2966__ = 32;
4130         int __leftop2968__ = 32;
4131         int __leftop2970__ = 32;
4132         int __leftop2972__ = 32;
4133         int __leftop2974__ = 32;
4134         int __leftop2976__ = 32;
4135         int __rightop2977__ = 0;
4136         int __rightop2975__ = __leftop2976__ + __rightop2977__;
4137         int __rightop2973__ = __leftop2974__ + __rightop2975__;
4138         int __rightop2971__ = __leftop2972__ + __rightop2973__;
4139         int __rightop2969__ = __leftop2970__ + __rightop2971__;
4140         int __rightop2967__ = __leftop2968__ + __rightop2969__;
4141         int __sizeof2965__ = __leftop2966__ + __rightop2967__;
4142         int __high2978__ = __left2963__ + __sizeof2965__;
4143         assertvalidmemory(__left2963__, __high2978__);
4144         // __left2963__ = d.s
4145         // __offsetinbits2979__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4146         int __leftop2980__ = 32;
4147         int __leftop2982__ = 32;
4148         int __leftop2984__ = 32;
4149         int __leftop2986__ = 32;
4150         int __leftop2988__ = 32;
4151         int __rightop2989__ = 0;
4152         int __rightop2987__ = __leftop2988__ + __rightop2989__;
4153         int __rightop2985__ = __leftop2986__ + __rightop2987__;
4154         int __rightop2983__ = __leftop2984__ + __rightop2985__;
4155         int __rightop2981__ = __leftop2982__ + __rightop2983__;
4156         int __offsetinbits2979__ = __leftop2980__ + __rightop2981__;
4157         // __offsetinbits2979__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4158         int __offset2990__ = __offsetinbits2979__ >> 3;
4159         int __shift2991__ = __offsetinbits2979__ - (__offset2990__ << 3);
4160         int __rightop2962__ = ((*(int *)(__left2963__ + __offset2990__))  >> __shift2991__) & 0xffffffff;
4161         int __leftop2960__ = __leftop2961__ * __rightop2962__;
4162         int __rightop2992__ = 0;
4163         int __leftop2959__ = __leftop2960__ + __rightop2992__;
4164         int __rightop2993__ = (int) __itb__; //varexpr
4165         int __rightop2958__ = __leftop2959__ * __rightop2993__;
4166         int __offsetinbits2956__ = __leftop2957__ + __rightop2958__;
4167         // __offsetinbits2956__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
4168         int __offset2994__ = __offsetinbits2956__ >> 3;
4169         int __expr2954__ = (__left2955__ + __offset2994__);
4170         int __leftop2997__ = 8;
4171         // __left2999__ <-- d.s
4172         // __left3000__ <-- d
4173         int __left3000__ = (int) d; //varexpr
4174         // __left3000__ = d
4175         int __left2999__ = (__left3000__ + 0);
4176         int __leftop3002__ = 32;
4177         int __leftop3004__ = 32;
4178         int __leftop3006__ = 32;
4179         int __leftop3008__ = 32;
4180         int __leftop3010__ = 32;
4181         int __leftop3012__ = 32;
4182         int __rightop3013__ = 0;
4183         int __rightop3011__ = __leftop3012__ + __rightop3013__;
4184         int __rightop3009__ = __leftop3010__ + __rightop3011__;
4185         int __rightop3007__ = __leftop3008__ + __rightop3009__;
4186         int __rightop3005__ = __leftop3006__ + __rightop3007__;
4187         int __rightop3003__ = __leftop3004__ + __rightop3005__;
4188         int __sizeof3001__ = __leftop3002__ + __rightop3003__;
4189         int __high3014__ = __left2999__ + __sizeof3001__;
4190         assertvalidmemory(__left2999__, __high3014__);
4191         // __left2999__ = d.s
4192         // __offsetinbits3015__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4193         int __leftop3016__ = 32;
4194         int __leftop3018__ = 32;
4195         int __leftop3020__ = 32;
4196         int __leftop3022__ = 32;
4197         int __leftop3024__ = 32;
4198         int __rightop3025__ = 0;
4199         int __rightop3023__ = __leftop3024__ + __rightop3025__;
4200         int __rightop3021__ = __leftop3022__ + __rightop3023__;
4201         int __rightop3019__ = __leftop3020__ + __rightop3021__;
4202         int __rightop3017__ = __leftop3018__ + __rightop3019__;
4203         int __offsetinbits3015__ = __leftop3016__ + __rightop3017__;
4204         // __offsetinbits3015__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4205         int __offset3026__ = __offsetinbits3015__ >> 3;
4206         int __shift3027__ = __offsetinbits3015__ - (__offset3026__ << 3);
4207         int __rightop2998__ = ((*(int *)(__left2999__ + __offset3026__))  >> __shift3027__) & 0xffffffff;
4208         int __leftop2996__ = __leftop2997__ * __rightop2998__;
4209         int __rightop3028__ = 0;
4210         int __sizeof2995__ = __leftop2996__ + __rightop3028__;
4211         int __high3029__ = __expr2954__ + __sizeof2995__;
4212         assertvalidmemory(__expr2954__, __high3029__);
4213         int __left2953__ = (int) __expr2954__;
4214         // __left2953__ = cast(__InodeTable__, d.b[itb])
4215         // __offsetinbits3030__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4216         int __leftop3031__ = 0;
4217         int __leftop3034__ = 32;
4218         int __leftop3037__ = 32;
4219         int __rightop3038__ = 12;
4220         int __leftop3036__ = __leftop3037__ * __rightop3038__;
4221         int __leftop3040__ = 32;
4222         int __rightop3041__ = 0;
4223         int __rightop3039__ = __leftop3040__ + __rightop3041__;
4224         int __rightop3035__ = __leftop3036__ + __rightop3039__;
4225         int __leftop3033__ = __leftop3034__ + __rightop3035__;
4226         int __rightop3042__ = (int) __i__; //varexpr
4227         int __rightop3032__ = __leftop3033__ * __rightop3042__;
4228         int __offsetinbits3030__ = __leftop3031__ + __rightop3032__;
4229         // __offsetinbits3030__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4230         int __offset3043__ = __offsetinbits3030__ >> 3;
4231         int __left2952__ = (__left2953__ + __offset3043__);
4232         int __leftop3045__ = 32;
4233         int __leftop3048__ = 32;
4234         int __rightop3049__ = 12;
4235         int __leftop3047__ = __leftop3048__ * __rightop3049__;
4236         int __leftop3051__ = 32;
4237         int __rightop3052__ = 0;
4238         int __rightop3050__ = __leftop3051__ + __rightop3052__;
4239         int __rightop3046__ = __leftop3047__ + __rightop3050__;
4240         int __sizeof3044__ = __leftop3045__ + __rightop3046__;
4241         int __high3053__ = __left2952__ + __sizeof3044__;
4242         assertvalidmemory(__left2952__, __high3053__);
4243         // __left2952__ = cast(__InodeTable__, d.b[itb]).itable[i]
4244         // __offsetinbits3054__ <-- ((32 + 0) + (32 * j))
4245         int __leftop3056__ = 32;
4246         int __rightop3057__ = 0;
4247         int __leftop3055__ = __leftop3056__ + __rightop3057__;
4248         int __leftop3059__ = 32;
4249         int __rightop3060__ = (int) __j__; //varexpr
4250         int __rightop3058__ = __leftop3059__ * __rightop3060__;
4251         int __offsetinbits3054__ = __leftop3055__ + __rightop3058__;
4252         // __offsetinbits3054__ = ((32 + 0) + (32 * j))
4253         int __offset3061__ = __offsetinbits3054__ >> 3;
4254         int __shift3062__ = __offsetinbits3054__ - (__offset3061__ << 3);
4255         int __leftop2951__ = ((*(int *)(__left2952__ + __offset3061__))  >> __shift3062__) & 0xffffffff;
4256         // __left3064__ <-- d.s
4257         // __left3065__ <-- d
4258         int __left3065__ = (int) d; //varexpr
4259         // __left3065__ = d
4260         int __left3064__ = (__left3065__ + 0);
4261         int __leftop3067__ = 32;
4262         int __leftop3069__ = 32;
4263         int __leftop3071__ = 32;
4264         int __leftop3073__ = 32;
4265         int __leftop3075__ = 32;
4266         int __leftop3077__ = 32;
4267         int __rightop3078__ = 0;
4268         int __rightop3076__ = __leftop3077__ + __rightop3078__;
4269         int __rightop3074__ = __leftop3075__ + __rightop3076__;
4270         int __rightop3072__ = __leftop3073__ + __rightop3074__;
4271         int __rightop3070__ = __leftop3071__ + __rightop3072__;
4272         int __rightop3068__ = __leftop3069__ + __rightop3070__;
4273         int __sizeof3066__ = __leftop3067__ + __rightop3068__;
4274         int __high3079__ = __left3064__ + __sizeof3066__;
4275         assertvalidmemory(__left3064__, __high3079__);
4276         // __left3064__ = d.s
4277         // __offsetinbits3080__ <-- (32 + (32 + 0))
4278         int __leftop3081__ = 32;
4279         int __leftop3083__ = 32;
4280         int __rightop3084__ = 0;
4281         int __rightop3082__ = __leftop3083__ + __rightop3084__;
4282         int __offsetinbits3080__ = __leftop3081__ + __rightop3082__;
4283         // __offsetinbits3080__ = (32 + (32 + 0))
4284         int __offset3085__ = __offsetinbits3080__ >> 3;
4285         int __shift3086__ = __offsetinbits3080__ - (__offset3085__ << 3);
4286         int __rightop3063__ = ((*(int *)(__left3064__ + __offset3085__))  >> __shift3086__) & 0xffffffff;
4287         int __leftop2950__ = __leftop2951__ < __rightop3063__;
4288         // __left3090__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
4289         // __left3091__ <-- cast(__InodeTable__, d.b[itb])
4290         // __left3093__ <-- d
4291         int __left3093__ = (int) d; //varexpr
4292         // __left3093__ = d
4293         // __offsetinbits3094__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
4294         int __leftop3095__ = 0;
4295         int __leftop3099__ = 8;
4296         // __left3101__ <-- d.s
4297         // __left3102__ <-- d
4298         int __left3102__ = (int) d; //varexpr
4299         // __left3102__ = d
4300         int __left3101__ = (__left3102__ + 0);
4301         int __leftop3104__ = 32;
4302         int __leftop3106__ = 32;
4303         int __leftop3108__ = 32;
4304         int __leftop3110__ = 32;
4305         int __leftop3112__ = 32;
4306         int __leftop3114__ = 32;
4307         int __rightop3115__ = 0;
4308         int __rightop3113__ = __leftop3114__ + __rightop3115__;
4309         int __rightop3111__ = __leftop3112__ + __rightop3113__;
4310         int __rightop3109__ = __leftop3110__ + __rightop3111__;
4311         int __rightop3107__ = __leftop3108__ + __rightop3109__;
4312         int __rightop3105__ = __leftop3106__ + __rightop3107__;
4313         int __sizeof3103__ = __leftop3104__ + __rightop3105__;
4314         int __high3116__ = __left3101__ + __sizeof3103__;
4315         assertvalidmemory(__left3101__, __high3116__);
4316         // __left3101__ = d.s
4317         // __offsetinbits3117__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4318         int __leftop3118__ = 32;
4319         int __leftop3120__ = 32;
4320         int __leftop3122__ = 32;
4321         int __leftop3124__ = 32;
4322         int __leftop3126__ = 32;
4323         int __rightop3127__ = 0;
4324         int __rightop3125__ = __leftop3126__ + __rightop3127__;
4325         int __rightop3123__ = __leftop3124__ + __rightop3125__;
4326         int __rightop3121__ = __leftop3122__ + __rightop3123__;
4327         int __rightop3119__ = __leftop3120__ + __rightop3121__;
4328         int __offsetinbits3117__ = __leftop3118__ + __rightop3119__;
4329         // __offsetinbits3117__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4330         int __offset3128__ = __offsetinbits3117__ >> 3;
4331         int __shift3129__ = __offsetinbits3117__ - (__offset3128__ << 3);
4332         int __rightop3100__ = ((*(int *)(__left3101__ + __offset3128__))  >> __shift3129__) & 0xffffffff;
4333         int __leftop3098__ = __leftop3099__ * __rightop3100__;
4334         int __rightop3130__ = 0;
4335         int __leftop3097__ = __leftop3098__ + __rightop3130__;
4336         int __rightop3131__ = (int) __itb__; //varexpr
4337         int __rightop3096__ = __leftop3097__ * __rightop3131__;
4338         int __offsetinbits3094__ = __leftop3095__ + __rightop3096__;
4339         // __offsetinbits3094__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
4340         int __offset3132__ = __offsetinbits3094__ >> 3;
4341         int __expr3092__ = (__left3093__ + __offset3132__);
4342         int __leftop3135__ = 8;
4343         // __left3137__ <-- d.s
4344         // __left3138__ <-- d
4345         int __left3138__ = (int) d; //varexpr
4346         // __left3138__ = d
4347         int __left3137__ = (__left3138__ + 0);
4348         int __leftop3140__ = 32;
4349         int __leftop3142__ = 32;
4350         int __leftop3144__ = 32;
4351         int __leftop3146__ = 32;
4352         int __leftop3148__ = 32;
4353         int __leftop3150__ = 32;
4354         int __rightop3151__ = 0;
4355         int __rightop3149__ = __leftop3150__ + __rightop3151__;
4356         int __rightop3147__ = __leftop3148__ + __rightop3149__;
4357         int __rightop3145__ = __leftop3146__ + __rightop3147__;
4358         int __rightop3143__ = __leftop3144__ + __rightop3145__;
4359         int __rightop3141__ = __leftop3142__ + __rightop3143__;
4360         int __sizeof3139__ = __leftop3140__ + __rightop3141__;
4361         int __high3152__ = __left3137__ + __sizeof3139__;
4362         assertvalidmemory(__left3137__, __high3152__);
4363         // __left3137__ = d.s
4364         // __offsetinbits3153__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4365         int __leftop3154__ = 32;
4366         int __leftop3156__ = 32;
4367         int __leftop3158__ = 32;
4368         int __leftop3160__ = 32;
4369         int __leftop3162__ = 32;
4370         int __rightop3163__ = 0;
4371         int __rightop3161__ = __leftop3162__ + __rightop3163__;
4372         int __rightop3159__ = __leftop3160__ + __rightop3161__;
4373         int __rightop3157__ = __leftop3158__ + __rightop3159__;
4374         int __rightop3155__ = __leftop3156__ + __rightop3157__;
4375         int __offsetinbits3153__ = __leftop3154__ + __rightop3155__;
4376         // __offsetinbits3153__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4377         int __offset3164__ = __offsetinbits3153__ >> 3;
4378         int __shift3165__ = __offsetinbits3153__ - (__offset3164__ << 3);
4379         int __rightop3136__ = ((*(int *)(__left3137__ + __offset3164__))  >> __shift3165__) & 0xffffffff;
4380         int __leftop3134__ = __leftop3135__ * __rightop3136__;
4381         int __rightop3166__ = 0;
4382         int __sizeof3133__ = __leftop3134__ + __rightop3166__;
4383         int __high3167__ = __expr3092__ + __sizeof3133__;
4384         assertvalidmemory(__expr3092__, __high3167__);
4385         int __left3091__ = (int) __expr3092__;
4386         // __left3091__ = cast(__InodeTable__, d.b[itb])
4387         // __offsetinbits3168__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4388         int __leftop3169__ = 0;
4389         int __leftop3172__ = 32;
4390         int __leftop3175__ = 32;
4391         int __rightop3176__ = 12;
4392         int __leftop3174__ = __leftop3175__ * __rightop3176__;
4393         int __leftop3178__ = 32;
4394         int __rightop3179__ = 0;
4395         int __rightop3177__ = __leftop3178__ + __rightop3179__;
4396         int __rightop3173__ = __leftop3174__ + __rightop3177__;
4397         int __leftop3171__ = __leftop3172__ + __rightop3173__;
4398         int __rightop3180__ = (int) __i__; //varexpr
4399         int __rightop3170__ = __leftop3171__ * __rightop3180__;
4400         int __offsetinbits3168__ = __leftop3169__ + __rightop3170__;
4401         // __offsetinbits3168__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4402         int __offset3181__ = __offsetinbits3168__ >> 3;
4403         int __left3090__ = (__left3091__ + __offset3181__);
4404         int __leftop3183__ = 32;
4405         int __leftop3186__ = 32;
4406         int __rightop3187__ = 12;
4407         int __leftop3185__ = __leftop3186__ * __rightop3187__;
4408         int __leftop3189__ = 32;
4409         int __rightop3190__ = 0;
4410         int __rightop3188__ = __leftop3189__ + __rightop3190__;
4411         int __rightop3184__ = __leftop3185__ + __rightop3188__;
4412         int __sizeof3182__ = __leftop3183__ + __rightop3184__;
4413         int __high3191__ = __left3090__ + __sizeof3182__;
4414         assertvalidmemory(__left3090__, __high3191__);
4415         // __left3090__ = cast(__InodeTable__, d.b[itb]).itable[i]
4416         // __offsetinbits3192__ <-- ((32 + 0) + (32 * j))
4417         int __leftop3194__ = 32;
4418         int __rightop3195__ = 0;
4419         int __leftop3193__ = __leftop3194__ + __rightop3195__;
4420         int __leftop3197__ = 32;
4421         int __rightop3198__ = (int) __j__; //varexpr
4422         int __rightop3196__ = __leftop3197__ * __rightop3198__;
4423         int __offsetinbits3192__ = __leftop3193__ + __rightop3196__;
4424         // __offsetinbits3192__ = ((32 + 0) + (32 * j))
4425         int __offset3199__ = __offsetinbits3192__ >> 3;
4426         int __shift3200__ = __offsetinbits3192__ - (__offset3199__ << 3);
4427         int __leftop3089__ = ((*(int *)(__left3090__ + __offset3199__))  >> __shift3200__) & 0xffffffff;
4428         int __rightop3201__ = 0;
4429         int __leftop3088__ = __leftop3089__ == __rightop3201__;
4430         int __rightop3087__ = !__leftop3088__;
4431         int __tempvar2949__ = __leftop2950__ && __rightop3087__;
4432         if (__tempvar2949__)
4433           {
4434           // __left3203__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
4435           // __left3204__ <-- cast(__InodeTable__, d.b[itb])
4436           // __left3206__ <-- d
4437           int __left3206__ = (int) d; //varexpr
4438           // __left3206__ = d
4439           // __offsetinbits3207__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
4440           int __leftop3208__ = 0;
4441           int __leftop3212__ = 8;
4442           // __left3214__ <-- d.s
4443           // __left3215__ <-- d
4444           int __left3215__ = (int) d; //varexpr
4445           // __left3215__ = d
4446           int __left3214__ = (__left3215__ + 0);
4447           int __leftop3217__ = 32;
4448           int __leftop3219__ = 32;
4449           int __leftop3221__ = 32;
4450           int __leftop3223__ = 32;
4451           int __leftop3225__ = 32;
4452           int __leftop3227__ = 32;
4453           int __rightop3228__ = 0;
4454           int __rightop3226__ = __leftop3227__ + __rightop3228__;
4455           int __rightop3224__ = __leftop3225__ + __rightop3226__;
4456           int __rightop3222__ = __leftop3223__ + __rightop3224__;
4457           int __rightop3220__ = __leftop3221__ + __rightop3222__;
4458           int __rightop3218__ = __leftop3219__ + __rightop3220__;
4459           int __sizeof3216__ = __leftop3217__ + __rightop3218__;
4460           int __high3229__ = __left3214__ + __sizeof3216__;
4461           assertvalidmemory(__left3214__, __high3229__);
4462           // __left3214__ = d.s
4463           // __offsetinbits3230__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4464           int __leftop3231__ = 32;
4465           int __leftop3233__ = 32;
4466           int __leftop3235__ = 32;
4467           int __leftop3237__ = 32;
4468           int __leftop3239__ = 32;
4469           int __rightop3240__ = 0;
4470           int __rightop3238__ = __leftop3239__ + __rightop3240__;
4471           int __rightop3236__ = __leftop3237__ + __rightop3238__;
4472           int __rightop3234__ = __leftop3235__ + __rightop3236__;
4473           int __rightop3232__ = __leftop3233__ + __rightop3234__;
4474           int __offsetinbits3230__ = __leftop3231__ + __rightop3232__;
4475           // __offsetinbits3230__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4476           int __offset3241__ = __offsetinbits3230__ >> 3;
4477           int __shift3242__ = __offsetinbits3230__ - (__offset3241__ << 3);
4478           int __rightop3213__ = ((*(int *)(__left3214__ + __offset3241__))  >> __shift3242__) & 0xffffffff;
4479           int __leftop3211__ = __leftop3212__ * __rightop3213__;
4480           int __rightop3243__ = 0;
4481           int __leftop3210__ = __leftop3211__ + __rightop3243__;
4482           int __rightop3244__ = (int) __itb__; //varexpr
4483           int __rightop3209__ = __leftop3210__ * __rightop3244__;
4484           int __offsetinbits3207__ = __leftop3208__ + __rightop3209__;
4485           // __offsetinbits3207__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
4486           int __offset3245__ = __offsetinbits3207__ >> 3;
4487           int __expr3205__ = (__left3206__ + __offset3245__);
4488           int __leftop3248__ = 8;
4489           // __left3250__ <-- d.s
4490           // __left3251__ <-- d
4491           int __left3251__ = (int) d; //varexpr
4492           // __left3251__ = d
4493           int __left3250__ = (__left3251__ + 0);
4494           int __leftop3253__ = 32;
4495           int __leftop3255__ = 32;
4496           int __leftop3257__ = 32;
4497           int __leftop3259__ = 32;
4498           int __leftop3261__ = 32;
4499           int __leftop3263__ = 32;
4500           int __rightop3264__ = 0;
4501           int __rightop3262__ = __leftop3263__ + __rightop3264__;
4502           int __rightop3260__ = __leftop3261__ + __rightop3262__;
4503           int __rightop3258__ = __leftop3259__ + __rightop3260__;
4504           int __rightop3256__ = __leftop3257__ + __rightop3258__;
4505           int __rightop3254__ = __leftop3255__ + __rightop3256__;
4506           int __sizeof3252__ = __leftop3253__ + __rightop3254__;
4507           int __high3265__ = __left3250__ + __sizeof3252__;
4508           assertvalidmemory(__left3250__, __high3265__);
4509           // __left3250__ = d.s
4510           // __offsetinbits3266__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
4511           int __leftop3267__ = 32;
4512           int __leftop3269__ = 32;
4513           int __leftop3271__ = 32;
4514           int __leftop3273__ = 32;
4515           int __leftop3275__ = 32;
4516           int __rightop3276__ = 0;
4517           int __rightop3274__ = __leftop3275__ + __rightop3276__;
4518           int __rightop3272__ = __leftop3273__ + __rightop3274__;
4519           int __rightop3270__ = __leftop3271__ + __rightop3272__;
4520           int __rightop3268__ = __leftop3269__ + __rightop3270__;
4521           int __offsetinbits3266__ = __leftop3267__ + __rightop3268__;
4522           // __offsetinbits3266__ = (32 + (32 + (32 + (32 + (32 + 0)))))
4523           int __offset3277__ = __offsetinbits3266__ >> 3;
4524           int __shift3278__ = __offsetinbits3266__ - (__offset3277__ << 3);
4525           int __rightop3249__ = ((*(int *)(__left3250__ + __offset3277__))  >> __shift3278__) & 0xffffffff;
4526           int __leftop3247__ = __leftop3248__ * __rightop3249__;
4527           int __rightop3279__ = 0;
4528           int __sizeof3246__ = __leftop3247__ + __rightop3279__;
4529           int __high3280__ = __expr3205__ + __sizeof3246__;
4530           assertvalidmemory(__expr3205__, __high3280__);
4531           int __left3204__ = (int) __expr3205__;
4532           // __left3204__ = cast(__InodeTable__, d.b[itb])
4533           // __offsetinbits3281__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4534           int __leftop3282__ = 0;
4535           int __leftop3285__ = 32;
4536           int __leftop3288__ = 32;
4537           int __rightop3289__ = 12;
4538           int __leftop3287__ = __leftop3288__ * __rightop3289__;
4539           int __leftop3291__ = 32;
4540           int __rightop3292__ = 0;
4541           int __rightop3290__ = __leftop3291__ + __rightop3292__;
4542           int __rightop3286__ = __leftop3287__ + __rightop3290__;
4543           int __leftop3284__ = __leftop3285__ + __rightop3286__;
4544           int __rightop3293__ = (int) __i__; //varexpr
4545           int __rightop3283__ = __leftop3284__ * __rightop3293__;
4546           int __offsetinbits3281__ = __leftop3282__ + __rightop3283__;
4547           // __offsetinbits3281__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
4548           int __offset3294__ = __offsetinbits3281__ >> 3;
4549           int __left3203__ = (__left3204__ + __offset3294__);
4550           int __leftop3296__ = 32;
4551           int __leftop3299__ = 32;
4552           int __rightop3300__ = 12;
4553           int __leftop3298__ = __leftop3299__ * __rightop3300__;
4554           int __leftop3302__ = 32;
4555           int __rightop3303__ = 0;
4556           int __rightop3301__ = __leftop3302__ + __rightop3303__;
4557           int __rightop3297__ = __leftop3298__ + __rightop3301__;
4558           int __sizeof3295__ = __leftop3296__ + __rightop3297__;
4559           int __high3304__ = __left3203__ + __sizeof3295__;
4560           assertvalidmemory(__left3203__, __high3304__);
4561           // __left3203__ = cast(__InodeTable__, d.b[itb]).itable[i]
4562           // __offsetinbits3305__ <-- ((32 + 0) + (32 * j))
4563           int __leftop3307__ = 32;
4564           int __rightop3308__ = 0;
4565           int __leftop3306__ = __leftop3307__ + __rightop3308__;
4566           int __leftop3310__ = 32;
4567           int __rightop3311__ = (int) __j__; //varexpr
4568           int __rightop3309__ = __leftop3310__ * __rightop3311__;
4569           int __offsetinbits3305__ = __leftop3306__ + __rightop3309__;
4570           // __offsetinbits3305__ = ((32 + 0) + (32 * j))
4571           int __offset3312__ = __offsetinbits3305__ >> 3;
4572           int __shift3313__ = __offsetinbits3305__ - (__offset3312__ << 3);
4573           int __element3202__ = ((*(int *)(__left3203__ + __offset3312__))  >> __shift3313__) & 0xffffffff;
4574           int __addeditem3314__ = 1;
4575           __addeditem3314__ = __Block___hash->add((int)__element3202__, (int)__element3202__);
4576           }
4577         }
4578       }
4579     }
4580   }
4581
4582
4583 // checking c1
4584   {
4585   for (SimpleIterator* __u___iterator = __UsedInode___hash->iterator(); __u___iterator->hasNext(); )
4586     {
4587     int __u__ = (int) __u___iterator->next();
4588     int maybe = 0;
4589     int __domain3317__ = (int) __u__; //varexpr
4590     int __leftop3316__;
4591     int __found3318__ = __inodestatus___hash->get(__domain3317__, __leftop3316__);
4592     if (!__found3318__) { maybe = 1; }
4593     int __rightop3319__ = 100;
4594     int __constraintboolean3315__ = __leftop3316__ == __rightop3319__;
4595     if (maybe)
4596       {
4597       __Success = 0;
4598       printf("maybe fail 1. ");
4599       exit(1);
4600       }
4601     else if (!__constraintboolean3315__)
4602       {
4603       __Success = 0;
4604       printf("fail 1. ");
4605       exit(1);
4606       }
4607     }
4608   }
4609
4610
4611 // checking c2
4612   {
4613   for (SimpleIterator* __f___iterator = __FreeInode___hash->iterator(); __f___iterator->hasNext(); )
4614     {
4615     int __f__ = (int) __f___iterator->next();
4616     int maybe = 0;
4617     int __domain3322__ = (int) __f__; //varexpr
4618     int __leftop3321__;
4619     int __found3323__ = __inodestatus___hash->get(__domain3322__, __leftop3321__);
4620     if (!__found3323__) { maybe = 1; }
4621     int __rightop3324__ = 101;
4622     int __constraintboolean3320__ = __leftop3321__ == __rightop3324__;
4623     if (maybe)
4624       {
4625       __Success = 0;
4626       printf("maybe fail 2. ");
4627       exit(1);
4628       }
4629     else if (!__constraintboolean3320__)
4630       {
4631       __Success = 0;
4632       printf("fail 2. ");
4633       exit(1);
4634       }
4635     }
4636   }
4637
4638
4639 // checking c3
4640   {
4641   for (SimpleIterator* __u___iterator = __UsedBlock___hash->iterator(); __u___iterator->hasNext(); )
4642     {
4643     int __u__ = (int) __u___iterator->next();
4644     int maybe = 0;
4645     int __domain3327__ = (int) __u__; //varexpr
4646     int __leftop3326__;
4647     int __found3328__ = __blockstatus___hash->get(__domain3327__, __leftop3326__);
4648     if (!__found3328__) { maybe = 1; }
4649     int __rightop3329__ = 100;
4650     int __constraintboolean3325__ = __leftop3326__ == __rightop3329__;
4651     if (maybe)
4652       {
4653       __Success = 0;
4654       printf("maybe fail 3. ");
4655       exit(1);
4656       }
4657     else if (!__constraintboolean3325__)
4658       {
4659       __Success = 0;
4660       printf("fail 3. ");
4661       exit(1);
4662       }
4663     }
4664   }
4665
4666
4667 // checking c4
4668   {
4669   for (SimpleIterator* __f___iterator = __FreeBlock___hash->iterator(); __f___iterator->hasNext(); )
4670     {
4671     int __f__ = (int) __f___iterator->next();
4672     int maybe = 0;
4673     int __domain3332__ = (int) __f__; //varexpr
4674     int __leftop3331__;
4675     int __found3333__ = __blockstatus___hash->get(__domain3332__, __leftop3331__);
4676     if (!__found3333__) { maybe = 1; }
4677     int __rightop3334__ = 101;
4678     int __constraintboolean3330__ = __leftop3331__ == __rightop3334__;
4679     if (maybe)
4680       {
4681       __Success = 0;
4682       printf("maybe fail 4. ");
4683       exit(1);
4684       }
4685     else if (!__constraintboolean3330__)
4686       {
4687       __Success = 0;
4688       printf("fail 4. ");
4689       exit(1);
4690       }
4691     }
4692   }
4693
4694
4695 // checking c5
4696   {
4697   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
4698     {
4699     int __i__ = (int) __i___iterator->next();
4700     int maybe = 0;
4701     int __domain3337__ = (int) __i__; //varexpr
4702     int __leftop3336__;
4703     int __found3338__ = __referencecount___hash->get(__domain3337__, __leftop3336__);
4704     if (!__found3338__) { maybe = 1; }
4705     int __rightop3339__ = __inodeof___hashinv->count(__i__);
4706     int __constraintboolean3335__ = __leftop3336__ == __rightop3339__;
4707     if (maybe)
4708       {
4709       __Success = 0;
4710       printf("maybe fail 5. ");
4711       exit(1);
4712       }
4713     else if (!__constraintboolean3335__)
4714       {
4715       __Success = 0;
4716       printf("fail 5. ");
4717       exit(1);
4718       }
4719     }
4720   }
4721
4722
4723 // checking c6
4724   {
4725   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
4726     {
4727     int __i__ = (int) __i___iterator->next();
4728     int maybe = 0;
4729     int __domain3342__ = (int) __i__; //varexpr
4730     int __leftop3341__;
4731     int __found3343__ = __filesize___hash->get(__domain3342__, __leftop3341__);
4732     if (!__found3343__) { maybe = 1; }
4733     int __leftop3345__ = __contents___hash->count(__i__);
4734     int __rightop3346__ = 8192;
4735     int __rightop3344__ = __leftop3345__ * __rightop3346__;
4736     int __constraintboolean3340__ = __leftop3341__ <= __rightop3344__;
4737     if (maybe)
4738       {
4739       __Success = 0;
4740       printf("maybe fail 6. ");
4741       exit(1);
4742       }
4743     else if (!__constraintboolean3340__)
4744       {
4745       __Success = 0;
4746       printf("fail 6. ");
4747       exit(1);
4748       }
4749     }
4750   }
4751
4752
4753 // checking c7
4754   {
4755   for (SimpleIterator* __b___iterator = __FileDirectoryBlock___hash->iterator(); __b___iterator->hasNext(); )
4756     {
4757     int __b__ = (int) __b___iterator->next();
4758     int maybe = 0;
4759     int __leftop3348__ = __contents___hashinv->count(__b__);
4760     int __rightop3349__ = 1;
4761     int __constraintboolean3347__ = __leftop3348__ == __rightop3349__;
4762     if (maybe)
4763       {
4764       __Success = 0;
4765       printf("maybe fail 7. ");
4766       exit(1);
4767       }
4768     else if (!__constraintboolean3347__)
4769       {
4770       __Success = 0;
4771       printf("fail 7. ");
4772       exit(1);
4773       }
4774     }
4775   }
4776
4777
4778 // checking c8
4779   {
4780   int maybe = 0;
4781   int __leftop3351__ = __SuperBlock___hash->count();
4782   int __rightop3352__ = 1;
4783   int __constraintboolean3350__ = __leftop3351__ == __rightop3352__;
4784   if (maybe)
4785     {
4786     __Success = 0;
4787     printf("maybe fail 8. ");
4788     exit(1);
4789     }
4790   else if (!__constraintboolean3350__)
4791     {
4792     __Success = 0;
4793     printf("fail 8. ");
4794     exit(1);
4795     }
4796   }
4797
4798
4799 // checking c9
4800   {
4801   int maybe = 0;
4802   int __leftop3354__ = __GroupBlock___hash->count();
4803   int __rightop3355__ = 1;
4804   int __constraintboolean3353__ = __leftop3354__ == __rightop3355__;
4805   if (maybe)
4806     {
4807     __Success = 0;
4808     printf("maybe fail 9. ");
4809     exit(1);
4810     }
4811   else if (!__constraintboolean3353__)
4812     {
4813     __Success = 0;
4814     printf("fail 9. ");
4815     exit(1);
4816     }
4817   }
4818
4819
4820 // checking c10
4821   {
4822   int maybe = 0;
4823   int __leftop3357__ = __InodeTableBlock___hash->count();
4824   int __rightop3358__ = 1;
4825   int __constraintboolean3356__ = __leftop3357__ == __rightop3358__;
4826   if (maybe)
4827     {
4828     __Success = 0;
4829     printf("maybe fail 10. ");
4830     exit(1);
4831     }
4832   else if (!__constraintboolean3356__)
4833     {
4834     __Success = 0;
4835     printf("fail 10. ");
4836     exit(1);
4837     }
4838   }
4839
4840
4841 // checking c11
4842   {
4843   int maybe = 0;
4844   int __leftop3360__ = __InodeBitmapBlock___hash->count();
4845   int __rightop3361__ = 1;
4846   int __constraintboolean3359__ = __leftop3360__ == __rightop3361__;
4847   if (maybe)
4848     {
4849     __Success = 0;
4850     printf("maybe fail 11. ");
4851     exit(1);
4852     }
4853   else if (!__constraintboolean3359__)
4854     {
4855     __Success = 0;
4856     printf("fail 11. ");
4857     exit(1);
4858     }
4859   }
4860
4861
4862 // checking c12
4863   {
4864   int maybe = 0;
4865   int __leftop3363__ = __BlockBitmapBlock___hash->count();
4866   int __rightop3364__ = 1;
4867   int __constraintboolean3362__ = __leftop3363__ == __rightop3364__;
4868   if (maybe)
4869     {
4870     __Success = 0;
4871     printf("maybe fail 12. ");
4872     exit(1);
4873     }
4874   else if (!__constraintboolean3362__)
4875     {
4876     __Success = 0;
4877     printf("fail 12. ");
4878     exit(1);
4879     }
4880   }
4881
4882
4883 // checking c13
4884   {
4885   int maybe = 0;
4886   int __leftop3366__ = __RootDirectoryInode___hash->count();
4887   int __rightop3367__ = 1;
4888   int __constraintboolean3365__ = __leftop3366__ == __rightop3367__;
4889   if (maybe)
4890     {
4891     __Success = 0;
4892     printf("maybe fail 13. ");
4893     exit(1);
4894     }
4895   else if (!__constraintboolean3365__)
4896     {
4897     __Success = 0;
4898     printf("fail 13. ");
4899     exit(1);
4900     }
4901   }
4902
4903
4904 // checking c14
4905   {
4906   for (SimpleIterator* __partitionvar___iterator = __UsedBlock___hash->iterator(); __partitionvar___iterator->hasNext(); )
4907     {
4908     int __partitionvar__ = (int) __partitionvar___iterator->next();
4909     int maybe = 0;
4910     int __constraintboolean3368__;
4911     int __leftboolean3369__;
4912     int __leftboolean3371__;
4913     int __leftboolean3373__;
4914     int __leftboolean3375__;
4915     int __leftboolean3377__;
4916     int __leftboolean3379__;
4917     int __leftboolean3381__;
4918     int __leftboolean3383__;
4919     int __leftboolean3385__;
4920     int __exprval3389__ = (int) __partitionvar__; //varexpr
4921     int __leftboolean3387__ = __SuperBlock___hash->contains(__exprval3389__);
4922     int __leftmaybe3388__ = maybe;
4923     int __rightboolean3390__;
4924     int __exprval3393__ = (int) __partitionvar__; //varexpr
4925     int __leftboolean3392__ = __GroupBlock___hash->contains(__exprval3393__);
4926     // 3-valued NOT
4927     if (!maybe)
4928       {
4929       __rightboolean3390__ =  !__leftboolean3392__;
4930       }
4931     int __rightmaybe3391__ = maybe;
4932     maybe = (__leftboolean3387__ && __rightmaybe3391__) || (__rightboolean3390__ && __leftmaybe3388__) || (__leftmaybe3388__ && __rightmaybe3391__);
4933     __leftboolean3385__ = __leftboolean3387__ && __rightboolean3390__;
4934     int __leftmaybe3386__ = maybe;
4935     int __rightboolean3394__;
4936     int __exprval3397__ = (int) __partitionvar__; //varexpr
4937     int __leftboolean3396__ = __FileDirectoryBlock___hash->contains(__exprval3397__);
4938     // 3-valued NOT
4939     if (!maybe)
4940       {
4941       __rightboolean3394__ =  !__leftboolean3396__;
4942       }
4943     int __rightmaybe3395__ = maybe;
4944     maybe = (__leftboolean3385__ && __rightmaybe3395__) || (__rightboolean3394__ && __leftmaybe3386__) || (__leftmaybe3386__ && __rightmaybe3395__);
4945     __leftboolean3383__ = __leftboolean3385__ && __rightboolean3394__;
4946     int __leftmaybe3384__ = maybe;
4947     int __rightboolean3398__;
4948     int __exprval3401__ = (int) __partitionvar__; //varexpr
4949     int __leftboolean3400__ = __InodeTableBlock___hash->contains(__exprval3401__);
4950     // 3-valued NOT
4951     if (!maybe)
4952       {
4953       __rightboolean3398__ =  !__leftboolean3400__;
4954       }
4955     int __rightmaybe3399__ = maybe;
4956     maybe = (__leftboolean3383__ && __rightmaybe3399__) || (__rightboolean3398__ && __leftmaybe3384__) || (__leftmaybe3384__ && __rightmaybe3399__);
4957     __leftboolean3381__ = __leftboolean3383__ && __rightboolean3398__;
4958     int __leftmaybe3382__ = maybe;
4959     int __rightboolean3402__;
4960     int __exprval3405__ = (int) __partitionvar__; //varexpr
4961     int __leftboolean3404__ = __InodeBitmapBlock___hash->contains(__exprval3405__);
4962     // 3-valued NOT
4963     if (!maybe)
4964       {
4965       __rightboolean3402__ =  !__leftboolean3404__;
4966       }
4967     int __rightmaybe3403__ = maybe;
4968     maybe = (__leftboolean3381__ && __rightmaybe3403__) || (__rightboolean3402__ && __leftmaybe3382__) || (__leftmaybe3382__ && __rightmaybe3403__);
4969     __leftboolean3379__ = __leftboolean3381__ && __rightboolean3402__;
4970     int __leftmaybe3380__ = maybe;
4971     int __rightboolean3406__;
4972     int __exprval3409__ = (int) __partitionvar__; //varexpr
4973     int __leftboolean3408__ = __BlockBitmapBlock___hash->contains(__exprval3409__);
4974     // 3-valued NOT
4975     if (!maybe)
4976       {
4977       __rightboolean3406__ =  !__leftboolean3408__;
4978       }
4979     int __rightmaybe3407__ = maybe;
4980     maybe = (__leftboolean3379__ && __rightmaybe3407__) || (__rightboolean3406__ && __leftmaybe3380__) || (__leftmaybe3380__ && __rightmaybe3407__);
4981     __leftboolean3377__ = __leftboolean3379__ && __rightboolean3406__;
4982     int __leftmaybe3378__ = maybe;
4983     int __rightboolean3410__;
4984     int __leftboolean3412__;
4985     int __leftboolean3414__;
4986     int __leftboolean3416__;
4987     int __leftboolean3418__;
4988     int __leftboolean3420__;
4989     int __exprval3423__ = (int) __partitionvar__; //varexpr
4990     int __leftboolean3422__ = __SuperBlock___hash->contains(__exprval3423__);
4991     // 3-valued NOT
4992     if (!maybe)
4993       {
4994       __leftboolean3420__ =  !__leftboolean3422__;
4995       }
4996     int __leftmaybe3421__ = maybe;
4997     int __exprval3426__ = (int) __partitionvar__; //varexpr
4998     int __rightboolean3424__ = __GroupBlock___hash->contains(__exprval3426__);
4999     int __rightmaybe3425__ = maybe;
5000     maybe = (__leftboolean3420__ && __rightmaybe3425__) || (__rightboolean3424__ && __leftmaybe3421__) || (__leftmaybe3421__ && __rightmaybe3425__);
5001     __leftboolean3418__ = __leftboolean3420__ && __rightboolean3424__;
5002     int __leftmaybe3419__ = maybe;
5003     int __rightboolean3427__;
5004     int __exprval3430__ = (int) __partitionvar__; //varexpr
5005     int __leftboolean3429__ = __FileDirectoryBlock___hash->contains(__exprval3430__);
5006     // 3-valued NOT
5007     if (!maybe)
5008       {
5009       __rightboolean3427__ =  !__leftboolean3429__;
5010       }
5011     int __rightmaybe3428__ = maybe;
5012     maybe = (__leftboolean3418__ && __rightmaybe3428__) || (__rightboolean3427__ && __leftmaybe3419__) || (__leftmaybe3419__ && __rightmaybe3428__);
5013     __leftboolean3416__ = __leftboolean3418__ && __rightboolean3427__;
5014     int __leftmaybe3417__ = maybe;
5015     int __rightboolean3431__;
5016     int __exprval3434__ = (int) __partitionvar__; //varexpr
5017     int __leftboolean3433__ = __InodeTableBlock___hash->contains(__exprval3434__);
5018     // 3-valued NOT
5019     if (!maybe)
5020       {
5021       __rightboolean3431__ =  !__leftboolean3433__;
5022       }
5023     int __rightmaybe3432__ = maybe;
5024     maybe = (__leftboolean3416__ && __rightmaybe3432__) || (__rightboolean3431__ && __leftmaybe3417__) || (__leftmaybe3417__ && __rightmaybe3432__);
5025     __leftboolean3414__ = __leftboolean3416__ && __rightboolean3431__;
5026     int __leftmaybe3415__ = maybe;
5027     int __rightboolean3435__;
5028     int __exprval3438__ = (int) __partitionvar__; //varexpr
5029     int __leftboolean3437__ = __InodeBitmapBlock___hash->contains(__exprval3438__);
5030     // 3-valued NOT
5031     if (!maybe)
5032       {
5033       __rightboolean3435__ =  !__leftboolean3437__;
5034       }
5035     int __rightmaybe3436__ = maybe;
5036     maybe = (__leftboolean3414__ && __rightmaybe3436__) || (__rightboolean3435__ && __leftmaybe3415__) || (__leftmaybe3415__ && __rightmaybe3436__);
5037     __leftboolean3412__ = __leftboolean3414__ && __rightboolean3435__;
5038     int __leftmaybe3413__ = maybe;
5039     int __rightboolean3439__;
5040     int __exprval3442__ = (int) __partitionvar__; //varexpr
5041     int __leftboolean3441__ = __BlockBitmapBlock___hash->contains(__exprval3442__);
5042     // 3-valued NOT
5043     if (!maybe)
5044       {
5045       __rightboolean3439__ =  !__leftboolean3441__;
5046       }
5047     int __rightmaybe3440__ = maybe;
5048     maybe = (__leftboolean3412__ && __rightmaybe3440__) || (__rightboolean3439__ && __leftmaybe3413__) || (__leftmaybe3413__ && __rightmaybe3440__);
5049     __rightboolean3410__ = __leftboolean3412__ && __rightboolean3439__;
5050     int __rightmaybe3411__ = maybe;
5051     maybe = (!__leftboolean3377__ && __rightmaybe3411__) || (!__rightboolean3410__ && __leftmaybe3378__) || (__leftmaybe3378__ && __rightmaybe3411__);
5052     __leftboolean3375__ = __leftboolean3377__ || __rightboolean3410__;
5053     int __leftmaybe3376__ = maybe;
5054     int __rightboolean3443__;
5055     int __leftboolean3445__;
5056     int __leftboolean3447__;
5057     int __leftboolean3449__;
5058     int __leftboolean3451__;
5059     int __leftboolean3453__;
5060     int __exprval3456__ = (int) __partitionvar__; //varexpr
5061     int __leftboolean3455__ = __SuperBlock___hash->contains(__exprval3456__);
5062     // 3-valued NOT
5063     if (!maybe)
5064       {
5065       __leftboolean3453__ =  !__leftboolean3455__;
5066       }
5067     int __leftmaybe3454__ = maybe;
5068     int __rightboolean3457__;
5069     int __exprval3460__ = (int) __partitionvar__; //varexpr
5070     int __leftboolean3459__ = __GroupBlock___hash->contains(__exprval3460__);
5071     // 3-valued NOT
5072     if (!maybe)
5073       {
5074       __rightboolean3457__ =  !__leftboolean3459__;
5075       }
5076     int __rightmaybe3458__ = maybe;
5077     maybe = (__leftboolean3453__ && __rightmaybe3458__) || (__rightboolean3457__ && __leftmaybe3454__) || (__leftmaybe3454__ && __rightmaybe3458__);
5078     __leftboolean3451__ = __leftboolean3453__ && __rightboolean3457__;
5079     int __leftmaybe3452__ = maybe;
5080     int __exprval3463__ = (int) __partitionvar__; //varexpr
5081     int __rightboolean3461__ = __FileDirectoryBlock___hash->contains(__exprval3463__);
5082     int __rightmaybe3462__ = maybe;
5083     maybe = (__leftboolean3451__ && __rightmaybe3462__) || (__rightboolean3461__ && __leftmaybe3452__) || (__leftmaybe3452__ && __rightmaybe3462__);
5084     __leftboolean3449__ = __leftboolean3451__ && __rightboolean3461__;
5085     int __leftmaybe3450__ = maybe;
5086     int __rightboolean3464__;
5087     int __exprval3467__ = (int) __partitionvar__; //varexpr
5088     int __leftboolean3466__ = __InodeTableBlock___hash->contains(__exprval3467__);
5089     // 3-valued NOT
5090     if (!maybe)
5091       {
5092       __rightboolean3464__ =  !__leftboolean3466__;
5093       }
5094     int __rightmaybe3465__ = maybe;
5095     maybe = (__leftboolean3449__ && __rightmaybe3465__) || (__rightboolean3464__ && __leftmaybe3450__) || (__leftmaybe3450__ && __rightmaybe3465__);
5096     __leftboolean3447__ = __leftboolean3449__ && __rightboolean3464__;
5097     int __leftmaybe3448__ = maybe;
5098     int __rightboolean3468__;
5099     int __exprval3471__ = (int) __partitionvar__; //varexpr
5100     int __leftboolean3470__ = __InodeBitmapBlock___hash->contains(__exprval3471__);
5101     // 3-valued NOT
5102     if (!maybe)
5103       {
5104       __rightboolean3468__ =  !__leftboolean3470__;
5105       }
5106     int __rightmaybe3469__ = maybe;
5107     maybe = (__leftboolean3447__ && __rightmaybe3469__) || (__rightboolean3468__ && __leftmaybe3448__) || (__leftmaybe3448__ && __rightmaybe3469__);
5108     __leftboolean3445__ = __leftboolean3447__ && __rightboolean3468__;
5109     int __leftmaybe3446__ = maybe;
5110     int __rightboolean3472__;
5111     int __exprval3475__ = (int) __partitionvar__; //varexpr
5112     int __leftboolean3474__ = __BlockBitmapBlock___hash->contains(__exprval3475__);
5113     // 3-valued NOT
5114     if (!maybe)
5115       {
5116       __rightboolean3472__ =  !__leftboolean3474__;
5117       }
5118     int __rightmaybe3473__ = maybe;
5119     maybe = (__leftboolean3445__ && __rightmaybe3473__) || (__rightboolean3472__ && __leftmaybe3446__) || (__leftmaybe3446__ && __rightmaybe3473__);
5120     __rightboolean3443__ = __leftboolean3445__ && __rightboolean3472__;
5121     int __rightmaybe3444__ = maybe;
5122     maybe = (!__leftboolean3375__ && __rightmaybe3444__) || (!__rightboolean3443__ && __leftmaybe3376__) || (__leftmaybe3376__ && __rightmaybe3444__);
5123     __leftboolean3373__ = __leftboolean3375__ || __rightboolean3443__;
5124     int __leftmaybe3374__ = maybe;
5125     int __rightboolean3476__;
5126     int __leftboolean3478__;
5127     int __leftboolean3480__;
5128     int __leftboolean3482__;
5129     int __leftboolean3484__;
5130     int __leftboolean3486__;
5131     int __exprval3489__ = (int) __partitionvar__; //varexpr
5132     int __leftboolean3488__ = __SuperBlock___hash->contains(__exprval3489__);
5133     // 3-valued NOT
5134     if (!maybe)
5135       {
5136       __leftboolean3486__ =  !__leftboolean3488__;
5137       }
5138     int __leftmaybe3487__ = maybe;
5139     int __rightboolean3490__;
5140     int __exprval3493__ = (int) __partitionvar__; //varexpr
5141     int __leftboolean3492__ = __GroupBlock___hash->contains(__exprval3493__);
5142     // 3-valued NOT
5143     if (!maybe)
5144       {
5145       __rightboolean3490__ =  !__leftboolean3492__;
5146       }
5147     int __rightmaybe3491__ = maybe;
5148     maybe = (__leftboolean3486__ && __rightmaybe3491__) || (__rightboolean3490__ && __leftmaybe3487__) || (__leftmaybe3487__ && __rightmaybe3491__);
5149     __leftboolean3484__ = __leftboolean3486__ && __rightboolean3490__;
5150     int __leftmaybe3485__ = maybe;
5151     int __rightboolean3494__;
5152     int __exprval3497__ = (int) __partitionvar__; //varexpr
5153     int __leftboolean3496__ = __FileDirectoryBlock___hash->contains(__exprval3497__);
5154     // 3-valued NOT
5155     if (!maybe)
5156       {
5157       __rightboolean3494__ =  !__leftboolean3496__;
5158       }
5159     int __rightmaybe3495__ = maybe;
5160     maybe = (__leftboolean3484__ && __rightmaybe3495__) || (__rightboolean3494__ && __leftmaybe3485__) || (__leftmaybe3485__ && __rightmaybe3495__);
5161     __leftboolean3482__ = __leftboolean3484__ && __rightboolean3494__;
5162     int __leftmaybe3483__ = maybe;
5163     int __exprval3500__ = (int) __partitionvar__; //varexpr
5164     int __rightboolean3498__ = __InodeTableBlock___hash->contains(__exprval3500__);
5165     int __rightmaybe3499__ = maybe;
5166     maybe = (__leftboolean3482__ && __rightmaybe3499__) || (__rightboolean3498__ && __leftmaybe3483__) || (__leftmaybe3483__ && __rightmaybe3499__);
5167     __leftboolean3480__ = __leftboolean3482__ && __rightboolean3498__;
5168     int __leftmaybe3481__ = maybe;
5169     int __rightboolean3501__;
5170     int __exprval3504__ = (int) __partitionvar__; //varexpr
5171     int __leftboolean3503__ = __InodeBitmapBlock___hash->contains(__exprval3504__);
5172     // 3-valued NOT
5173     if (!maybe)
5174       {
5175       __rightboolean3501__ =  !__leftboolean3503__;
5176       }
5177     int __rightmaybe3502__ = maybe;
5178     maybe = (__leftboolean3480__ && __rightmaybe3502__) || (__rightboolean3501__ && __leftmaybe3481__) || (__leftmaybe3481__ && __rightmaybe3502__);
5179     __leftboolean3478__ = __leftboolean3480__ && __rightboolean3501__;
5180     int __leftmaybe3479__ = maybe;
5181     int __rightboolean3505__;
5182     int __exprval3508__ = (int) __partitionvar__; //varexpr
5183     int __leftboolean3507__ = __BlockBitmapBlock___hash->contains(__exprval3508__);
5184     // 3-valued NOT
5185     if (!maybe)
5186       {
5187       __rightboolean3505__ =  !__leftboolean3507__;
5188       }
5189     int __rightmaybe3506__ = maybe;
5190     maybe = (__leftboolean3478__ && __rightmaybe3506__) || (__rightboolean3505__ && __leftmaybe3479__) || (__leftmaybe3479__ && __rightmaybe3506__);
5191     __rightboolean3476__ = __leftboolean3478__ && __rightboolean3505__;
5192     int __rightmaybe3477__ = maybe;
5193     maybe = (!__leftboolean3373__ && __rightmaybe3477__) || (!__rightboolean3476__ && __leftmaybe3374__) || (__leftmaybe3374__ && __rightmaybe3477__);
5194     __leftboolean3371__ = __leftboolean3373__ || __rightboolean3476__;
5195     int __leftmaybe3372__ = maybe;
5196     int __rightboolean3509__;
5197     int __leftboolean3511__;
5198     int __leftboolean3513__;
5199     int __leftboolean3515__;
5200     int __leftboolean3517__;
5201     int __leftboolean3519__;
5202     int __exprval3522__ = (int) __partitionvar__; //varexpr
5203     int __leftboolean3521__ = __SuperBlock___hash->contains(__exprval3522__);
5204     // 3-valued NOT
5205     if (!maybe)
5206       {
5207       __leftboolean3519__ =  !__leftboolean3521__;
5208       }
5209     int __leftmaybe3520__ = maybe;
5210     int __rightboolean3523__;
5211     int __exprval3526__ = (int) __partitionvar__; //varexpr
5212     int __leftboolean3525__ = __GroupBlock___hash->contains(__exprval3526__);
5213     // 3-valued NOT
5214     if (!maybe)
5215       {
5216       __rightboolean3523__ =  !__leftboolean3525__;
5217       }
5218     int __rightmaybe3524__ = maybe;
5219     maybe = (__leftboolean3519__ && __rightmaybe3524__) || (__rightboolean3523__ && __leftmaybe3520__) || (__leftmaybe3520__ && __rightmaybe3524__);
5220     __leftboolean3517__ = __leftboolean3519__ && __rightboolean3523__;
5221     int __leftmaybe3518__ = maybe;
5222     int __rightboolean3527__;
5223     int __exprval3530__ = (int) __partitionvar__; //varexpr
5224     int __leftboolean3529__ = __FileDirectoryBlock___hash->contains(__exprval3530__);
5225     // 3-valued NOT
5226     if (!maybe)
5227       {
5228       __rightboolean3527__ =  !__leftboolean3529__;
5229       }
5230     int __rightmaybe3528__ = maybe;
5231     maybe = (__leftboolean3517__ && __rightmaybe3528__) || (__rightboolean3527__ && __leftmaybe3518__) || (__leftmaybe3518__ && __rightmaybe3528__);
5232     __leftboolean3515__ = __leftboolean3517__ && __rightboolean3527__;
5233     int __leftmaybe3516__ = maybe;
5234     int __rightboolean3531__;
5235     int __exprval3534__ = (int) __partitionvar__; //varexpr
5236     int __leftboolean3533__ = __InodeTableBlock___hash->contains(__exprval3534__);
5237     // 3-valued NOT
5238     if (!maybe)
5239       {
5240       __rightboolean3531__ =  !__leftboolean3533__;
5241       }
5242     int __rightmaybe3532__ = maybe;
5243     maybe = (__leftboolean3515__ && __rightmaybe3532__) || (__rightboolean3531__ && __leftmaybe3516__) || (__leftmaybe3516__ && __rightmaybe3532__);
5244     __leftboolean3513__ = __leftboolean3515__ && __rightboolean3531__;
5245     int __leftmaybe3514__ = maybe;
5246     int __exprval3537__ = (int) __partitionvar__; //varexpr
5247     int __rightboolean3535__ = __InodeBitmapBlock___hash->contains(__exprval3537__);
5248     int __rightmaybe3536__ = maybe;
5249     maybe = (__leftboolean3513__ && __rightmaybe3536__) || (__rightboolean3535__ && __leftmaybe3514__) || (__leftmaybe3514__ && __rightmaybe3536__);
5250     __leftboolean3511__ = __leftboolean3513__ && __rightboolean3535__;
5251     int __leftmaybe3512__ = maybe;
5252     int __rightboolean3538__;
5253     int __exprval3541__ = (int) __partitionvar__; //varexpr
5254     int __leftboolean3540__ = __BlockBitmapBlock___hash->contains(__exprval3541__);
5255     // 3-valued NOT
5256     if (!maybe)
5257       {
5258       __rightboolean3538__ =  !__leftboolean3540__;
5259       }
5260     int __rightmaybe3539__ = maybe;
5261     maybe = (__leftboolean3511__ && __rightmaybe3539__) || (__rightboolean3538__ && __leftmaybe3512__) || (__leftmaybe3512__ && __rightmaybe3539__);
5262     __rightboolean3509__ = __leftboolean3511__ && __rightboolean3538__;
5263     int __rightmaybe3510__ = maybe;
5264     maybe = (!__leftboolean3371__ && __rightmaybe3510__) || (!__rightboolean3509__ && __leftmaybe3372__) || (__leftmaybe3372__ && __rightmaybe3510__);
5265     __leftboolean3369__ = __leftboolean3371__ || __rightboolean3509__;
5266     int __leftmaybe3370__ = maybe;
5267     int __rightboolean3542__;
5268     int __leftboolean3544__;
5269     int __leftboolean3546__;
5270     int __leftboolean3548__;
5271     int __leftboolean3550__;
5272     int __leftboolean3552__;
5273     int __exprval3555__ = (int) __partitionvar__; //varexpr
5274     int __leftboolean3554__ = __SuperBlock___hash->contains(__exprval3555__);
5275     // 3-valued NOT
5276     if (!maybe)
5277       {
5278       __leftboolean3552__ =  !__leftboolean3554__;
5279       }
5280     int __leftmaybe3553__ = maybe;
5281     int __rightboolean3556__;
5282     int __exprval3559__ = (int) __partitionvar__; //varexpr
5283     int __leftboolean3558__ = __GroupBlock___hash->contains(__exprval3559__);
5284     // 3-valued NOT
5285     if (!maybe)
5286       {
5287       __rightboolean3556__ =  !__leftboolean3558__;
5288       }
5289     int __rightmaybe3557__ = maybe;
5290     maybe = (__leftboolean3552__ && __rightmaybe3557__) || (__rightboolean3556__ && __leftmaybe3553__) || (__leftmaybe3553__ && __rightmaybe3557__);
5291     __leftboolean3550__ = __leftboolean3552__ && __rightboolean3556__;
5292     int __leftmaybe3551__ = maybe;
5293     int __rightboolean3560__;
5294     int __exprval3563__ = (int) __partitionvar__; //varexpr
5295     int __leftboolean3562__ = __FileDirectoryBlock___hash->contains(__exprval3563__);
5296     // 3-valued NOT
5297     if (!maybe)
5298       {
5299       __rightboolean3560__ =  !__leftboolean3562__;
5300       }
5301     int __rightmaybe3561__ = maybe;
5302     maybe = (__leftboolean3550__ && __rightmaybe3561__) || (__rightboolean3560__ && __leftmaybe3551__) || (__leftmaybe3551__ && __rightmaybe3561__);
5303     __leftboolean3548__ = __leftboolean3550__ && __rightboolean3560__;
5304     int __leftmaybe3549__ = maybe;
5305     int __rightboolean3564__;
5306     int __exprval3567__ = (int) __partitionvar__; //varexpr
5307     int __leftboolean3566__ = __InodeTableBlock___hash->contains(__exprval3567__);
5308     // 3-valued NOT
5309     if (!maybe)
5310       {
5311       __rightboolean3564__ =  !__leftboolean3566__;
5312       }
5313     int __rightmaybe3565__ = maybe;
5314     maybe = (__leftboolean3548__ && __rightmaybe3565__) || (__rightboolean3564__ && __leftmaybe3549__) || (__leftmaybe3549__ && __rightmaybe3565__);
5315     __leftboolean3546__ = __leftboolean3548__ && __rightboolean3564__;
5316     int __leftmaybe3547__ = maybe;
5317     int __rightboolean3568__;
5318     int __exprval3571__ = (int) __partitionvar__; //varexpr
5319     int __leftboolean3570__ = __InodeBitmapBlock___hash->contains(__exprval3571__);
5320     // 3-valued NOT
5321     if (!maybe)
5322       {
5323       __rightboolean3568__ =  !__leftboolean3570__;
5324       }
5325     int __rightmaybe3569__ = maybe;
5326     maybe = (__leftboolean3546__ && __rightmaybe3569__) || (__rightboolean3568__ && __leftmaybe3547__) || (__leftmaybe3547__ && __rightmaybe3569__);
5327     __leftboolean3544__ = __leftboolean3546__ && __rightboolean3568__;
5328     int __leftmaybe3545__ = maybe;
5329     int __exprval3574__ = (int) __partitionvar__; //varexpr
5330     int __rightboolean3572__ = __BlockBitmapBlock___hash->contains(__exprval3574__);
5331     int __rightmaybe3573__ = maybe;
5332     maybe = (__leftboolean3544__ && __rightmaybe3573__) || (__rightboolean3572__ && __leftmaybe3545__) || (__leftmaybe3545__ && __rightmaybe3573__);
5333     __rightboolean3542__ = __leftboolean3544__ && __rightboolean3572__;
5334     int __rightmaybe3543__ = maybe;
5335     maybe = (!__leftboolean3369__ && __rightmaybe3543__) || (!__rightboolean3542__ && __leftmaybe3370__) || (__leftmaybe3370__ && __rightmaybe3543__);
5336     __constraintboolean3368__ = __leftboolean3369__ || __rightboolean3542__;
5337     if (maybe)
5338       {
5339       __Success = 0;
5340       printf("maybe fail 14. ");
5341       exit(1);
5342       }
5343     else if (!__constraintboolean3368__)
5344       {
5345       __Success = 0;
5346       printf("fail 14. ");
5347       exit(1);
5348       }
5349     }
5350   }
5351
5352
5353 // checking c15
5354   {
5355   for (SimpleIterator* __partitionvar___iterator = __UsedInode___hash->iterator(); __partitionvar___iterator->hasNext(); )
5356     {
5357     int __partitionvar__ = (int) __partitionvar___iterator->next();
5358     int maybe = 0;
5359     int __constraintboolean3575__;
5360     int __leftboolean3576__;
5361     int __exprval3580__ = (int) __partitionvar__; //varexpr
5362     int __leftboolean3578__ = __FileInode___hash->contains(__exprval3580__);
5363     int __leftmaybe3579__ = maybe;
5364     int __rightboolean3581__;
5365     int __exprval3584__ = (int) __partitionvar__; //varexpr
5366     int __leftboolean3583__ = __DirectoryInode___hash->contains(__exprval3584__);
5367     // 3-valued NOT
5368     if (!maybe)
5369       {
5370       __rightboolean3581__ =  !__leftboolean3583__;
5371       }
5372     int __rightmaybe3582__ = maybe;
5373     maybe = (__leftboolean3578__ && __rightmaybe3582__) || (__rightboolean3581__ && __leftmaybe3579__) || (__leftmaybe3579__ && __rightmaybe3582__);
5374     __leftboolean3576__ = __leftboolean3578__ && __rightboolean3581__;
5375     int __leftmaybe3577__ = maybe;
5376     int __rightboolean3585__;
5377     int __leftboolean3587__;
5378     int __exprval3590__ = (int) __partitionvar__; //varexpr
5379     int __leftboolean3589__ = __FileInode___hash->contains(__exprval3590__);
5380     // 3-valued NOT
5381     if (!maybe)
5382       {
5383       __leftboolean3587__ =  !__leftboolean3589__;
5384       }
5385     int __leftmaybe3588__ = maybe;
5386     int __exprval3593__ = (int) __partitionvar__; //varexpr
5387     int __rightboolean3591__ = __DirectoryInode___hash->contains(__exprval3593__);
5388     int __rightmaybe3592__ = maybe;
5389     maybe = (__leftboolean3587__ && __rightmaybe3592__) || (__rightboolean3591__ && __leftmaybe3588__) || (__leftmaybe3588__ && __rightmaybe3592__);
5390     __rightboolean3585__ = __leftboolean3587__ && __rightboolean3591__;
5391     int __rightmaybe3586__ = maybe;
5392     maybe = (!__leftboolean3576__ && __rightmaybe3586__) || (!__rightboolean3585__ && __leftmaybe3577__) || (__leftmaybe3577__ && __rightmaybe3586__);
5393     __constraintboolean3575__ = __leftboolean3576__ || __rightboolean3585__;
5394     if (maybe)
5395       {
5396       __Success = 0;
5397       printf("maybe fail 15. ");
5398       exit(1);
5399       }
5400     else if (!__constraintboolean3575__)
5401       {
5402       __Success = 0;
5403       printf("fail 15. ");
5404       exit(1);
5405       }
5406     }
5407   }
5408
5409
5410 // checking c16
5411   {
5412   for (SimpleIterator* __partitionvar___iterator = __Block___hash->iterator(); __partitionvar___iterator->hasNext(); )
5413     {
5414     int __partitionvar__ = (int) __partitionvar___iterator->next();
5415     int maybe = 0;
5416     int __constraintboolean3594__;
5417     int __leftboolean3595__;
5418     int __exprval3599__ = (int) __partitionvar__; //varexpr
5419     int __leftboolean3597__ = __UsedBlock___hash->contains(__exprval3599__);
5420     int __leftmaybe3598__ = maybe;
5421     int __rightboolean3600__;
5422     int __exprval3603__ = (int) __partitionvar__; //varexpr
5423     int __leftboolean3602__ = __FreeBlock___hash->contains(__exprval3603__);
5424     // 3-valued NOT
5425     if (!maybe)
5426       {
5427       __rightboolean3600__ =  !__leftboolean3602__;
5428       }
5429     int __rightmaybe3601__ = maybe;
5430     maybe = (__leftboolean3597__ && __rightmaybe3601__) || (__rightboolean3600__ && __leftmaybe3598__) || (__leftmaybe3598__ && __rightmaybe3601__);
5431     __leftboolean3595__ = __leftboolean3597__ && __rightboolean3600__;
5432     int __leftmaybe3596__ = maybe;
5433     int __rightboolean3604__;
5434     int __leftboolean3606__;
5435     int __exprval3609__ = (int) __partitionvar__; //varexpr
5436     int __leftboolean3608__ = __UsedBlock___hash->contains(__exprval3609__);
5437     // 3-valued NOT
5438     if (!maybe)
5439       {
5440       __leftboolean3606__ =  !__leftboolean3608__;
5441       }
5442     int __leftmaybe3607__ = maybe;
5443     int __exprval3612__ = (int) __partitionvar__; //varexpr
5444     int __rightboolean3610__ = __FreeBlock___hash->contains(__exprval3612__);
5445     int __rightmaybe3611__ = maybe;
5446     maybe = (__leftboolean3606__ && __rightmaybe3611__) || (__rightboolean3610__ && __leftmaybe3607__) || (__leftmaybe3607__ && __rightmaybe3611__);
5447     __rightboolean3604__ = __leftboolean3606__ && __rightboolean3610__;
5448     int __rightmaybe3605__ = maybe;
5449     maybe = (!__leftboolean3595__ && __rightmaybe3605__) || (!__rightboolean3604__ && __leftmaybe3596__) || (__leftmaybe3596__ && __rightmaybe3605__);
5450     __constraintboolean3594__ = __leftboolean3595__ || __rightboolean3604__;
5451     if (maybe)
5452       {
5453       __Success = 0;
5454       printf("maybe fail 16. ");
5455       exit(1);
5456       }
5457     else if (!__constraintboolean3594__)
5458       {
5459       __Success = 0;
5460       printf("fail 16. ");
5461       exit(1);
5462       }
5463     }
5464   }
5465
5466
5467 // checking c17
5468   {
5469   for (SimpleIterator* __partitionvar___iterator = __Inode___hash->iterator(); __partitionvar___iterator->hasNext(); )
5470     {
5471     int __partitionvar__ = (int) __partitionvar___iterator->next();
5472     int maybe = 0;
5473     int __constraintboolean3613__;
5474     int __leftboolean3614__;
5475     int __exprval3618__ = (int) __partitionvar__; //varexpr
5476     int __leftboolean3616__ = __UsedInode___hash->contains(__exprval3618__);
5477     int __leftmaybe3617__ = maybe;
5478     int __rightboolean3619__;
5479     int __exprval3622__ = (int) __partitionvar__; //varexpr
5480     int __leftboolean3621__ = __FreeInode___hash->contains(__exprval3622__);
5481     // 3-valued NOT
5482     if (!maybe)
5483       {
5484       __rightboolean3619__ =  !__leftboolean3621__;
5485       }
5486     int __rightmaybe3620__ = maybe;
5487     maybe = (__leftboolean3616__ && __rightmaybe3620__) || (__rightboolean3619__ && __leftmaybe3617__) || (__leftmaybe3617__ && __rightmaybe3620__);
5488     __leftboolean3614__ = __leftboolean3616__ && __rightboolean3619__;
5489     int __leftmaybe3615__ = maybe;
5490     int __rightboolean3623__;
5491     int __leftboolean3625__;
5492     int __exprval3628__ = (int) __partitionvar__; //varexpr
5493     int __leftboolean3627__ = __UsedInode___hash->contains(__exprval3628__);
5494     // 3-valued NOT
5495     if (!maybe)
5496       {
5497       __leftboolean3625__ =  !__leftboolean3627__;
5498       }
5499     int __leftmaybe3626__ = maybe;
5500     int __exprval3631__ = (int) __partitionvar__; //varexpr
5501     int __rightboolean3629__ = __FreeInode___hash->contains(__exprval3631__);
5502     int __rightmaybe3630__ = maybe;
5503     maybe = (__leftboolean3625__ && __rightmaybe3630__) || (__rightboolean3629__ && __leftmaybe3626__) || (__leftmaybe3626__ && __rightmaybe3630__);
5504     __rightboolean3623__ = __leftboolean3625__ && __rightboolean3629__;
5505     int __rightmaybe3624__ = maybe;
5506     maybe = (!__leftboolean3614__ && __rightmaybe3624__) || (!__rightboolean3623__ && __leftmaybe3615__) || (__leftmaybe3615__ && __rightmaybe3624__);
5507     __constraintboolean3613__ = __leftboolean3614__ || __rightboolean3623__;
5508     if (maybe)
5509       {
5510       __Success = 0;
5511       printf("maybe fail 17. ");
5512       exit(1);
5513       }
5514     else if (!__constraintboolean3613__)
5515       {
5516       __Success = 0;
5517       printf("fail 17. ");
5518       exit(1);
5519       }
5520     }
5521   }
5522
5523
5524 // checking c18
5525   {
5526   for (SimpleIterator* __partitionvar1___iterator = __referencecount___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5527     {
5528     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5529     int __partitionvar1__ = (int) __partitionvar1___iterator->key();
5530     int maybe = 0;
5531     int __constraintboolean3632__;
5532     int __exprval3635__ = (int) __partitionvar1__; //varexpr
5533     int __leftboolean3633__ = __Inode___hash->contains(__exprval3635__);
5534     int __leftmaybe3634__ = maybe;
5535     int __exprval3638__ = (int) __partitionvar2__; //varexpr
5536     int __rightboolean3636__ = __int___hash->contains(__exprval3638__);
5537     int __rightmaybe3637__ = maybe;
5538     maybe = (__leftboolean3633__ && __rightmaybe3637__) || (__rightboolean3636__ && __leftmaybe3634__) || (__leftmaybe3634__ && __rightmaybe3637__);
5539     __constraintboolean3632__ = __leftboolean3633__ && __rightboolean3636__;
5540     if (maybe)
5541       {
5542       __Success = 0;
5543       printf("maybe fail 18. ");
5544       exit(1);
5545       }
5546     else if (!__constraintboolean3632__)
5547       {
5548       __Success = 0;
5549       printf("fail 18. ");
5550       exit(1);
5551       }
5552     }
5553   }
5554
5555
5556 // checking c19
5557   {
5558   for (SimpleIterator* __partitionvar1___iterator = __filesize___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5559     {
5560     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5561     int __partitionvar1__ = (int) __partitionvar1___iterator->key();
5562     int maybe = 0;
5563     int __constraintboolean3639__;
5564     int __exprval3642__ = (int) __partitionvar1__; //varexpr
5565     int __leftboolean3640__ = __Inode___hash->contains(__exprval3642__);
5566     int __leftmaybe3641__ = maybe;
5567     int __exprval3645__ = (int) __partitionvar2__; //varexpr
5568     int __rightboolean3643__ = __int___hash->contains(__exprval3645__);
5569     int __rightmaybe3644__ = maybe;
5570     maybe = (__leftboolean3640__ && __rightmaybe3644__) || (__rightboolean3643__ && __leftmaybe3641__) || (__leftmaybe3641__ && __rightmaybe3644__);
5571     __constraintboolean3639__ = __leftboolean3640__ && __rightboolean3643__;
5572     if (maybe)
5573       {
5574       __Success = 0;
5575       printf("maybe fail 19. ");
5576       exit(1);
5577       }
5578     else if (!__constraintboolean3639__)
5579       {
5580       __Success = 0;
5581       printf("fail 19. ");
5582       exit(1);
5583       }
5584     }
5585   }
5586
5587
5588 // checking c20
5589   {
5590   for (SimpleIterator* __partitionvar1___iterator = __inodeof___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5591     {
5592     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5593     __DirectoryEntry__ __partitionvar1__ = (__DirectoryEntry__) __partitionvar1___iterator->key();
5594     int maybe = 0;
5595     int __constraintboolean3646__;
5596     int __exprval3649__ = (int) __partitionvar1__; //varexpr
5597     int __leftboolean3647__ = __DirectoryEntry___hash->contains(__exprval3649__);
5598     int __leftmaybe3648__ = maybe;
5599     int __exprval3652__ = (int) __partitionvar2__; //varexpr
5600     int __rightboolean3650__ = __UsedInode___hash->contains(__exprval3652__);
5601     int __rightmaybe3651__ = maybe;
5602     maybe = (__leftboolean3647__ && __rightmaybe3651__) || (__rightboolean3650__ && __leftmaybe3648__) || (__leftmaybe3648__ && __rightmaybe3651__);
5603     __constraintboolean3646__ = __leftboolean3647__ && __rightboolean3650__;
5604     if (maybe)
5605       {
5606       __Success = 0;
5607       printf("maybe fail 20. ");
5608       exit(1);
5609       }
5610     else if (!__constraintboolean3646__)
5611       {
5612       __Success = 0;
5613       printf("fail 20. ");
5614       exit(1);
5615       }
5616     }
5617   }
5618
5619
5620 // checking c21
5621   {
5622   for (SimpleIterator* __partitionvar1___iterator = __contents___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5623     {
5624     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5625     int __partitionvar1__ = (int) __partitionvar1___iterator->key();
5626     int maybe = 0;
5627     int __constraintboolean3653__;
5628     int __exprval3656__ = (int) __partitionvar1__; //varexpr
5629     int __leftboolean3654__ = __UsedInode___hash->contains(__exprval3656__);
5630     int __leftmaybe3655__ = maybe;
5631     int __exprval3659__ = (int) __partitionvar2__; //varexpr
5632     int __rightboolean3657__ = __FileDirectoryBlock___hash->contains(__exprval3659__);
5633     int __rightmaybe3658__ = maybe;
5634     maybe = (__leftboolean3654__ && __rightmaybe3658__) || (__rightboolean3657__ && __leftmaybe3655__) || (__leftmaybe3655__ && __rightmaybe3658__);
5635     __constraintboolean3653__ = __leftboolean3654__ && __rightboolean3657__;
5636     if (maybe)
5637       {
5638       __Success = 0;
5639       printf("maybe fail 21. ");
5640       exit(1);
5641       }
5642     else if (!__constraintboolean3653__)
5643       {
5644       __Success = 0;
5645       printf("fail 21. ");
5646       exit(1);
5647       }
5648     }
5649   }
5650
5651
5652 // checking c22
5653   {
5654   for (SimpleIterator* __partitionvar1___iterator = __inodestatus___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5655     {
5656     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5657     int __partitionvar1__ = (int) __partitionvar1___iterator->key();
5658     int maybe = 0;
5659     int __constraintboolean3660__;
5660     int __exprval3663__ = (int) __partitionvar1__; //varexpr
5661     int __leftboolean3661__ = __Inode___hash->contains(__exprval3663__);
5662     int __leftmaybe3662__ = maybe;
5663     int __exprval3666__ = (int) __partitionvar2__; //varexpr
5664     int __rightboolean3664__ = __token___hash->contains(__exprval3666__);
5665     int __rightmaybe3665__ = maybe;
5666     maybe = (__leftboolean3661__ && __rightmaybe3665__) || (__rightboolean3664__ && __leftmaybe3662__) || (__leftmaybe3662__ && __rightmaybe3665__);
5667     __constraintboolean3660__ = __leftboolean3661__ && __rightboolean3664__;
5668     if (maybe)
5669       {
5670       __Success = 0;
5671       printf("maybe fail 22. ");
5672       exit(1);
5673       }
5674     else if (!__constraintboolean3660__)
5675       {
5676       __Success = 0;
5677       printf("fail 22. ");
5678       exit(1);
5679       }
5680     }
5681   }
5682
5683
5684 // checking c23
5685   {
5686   for (SimpleIterator* __partitionvar1___iterator = __blockstatus___hash->iterator(); __partitionvar1___iterator->hasNext(); )
5687     {
5688     int __partitionvar2__ = (int) __partitionvar1___iterator->next();
5689     int __partitionvar1__ = (int) __partitionvar1___iterator->key();
5690     int maybe = 0;
5691     int __constraintboolean3667__;
5692     int __exprval3670__ = (int) __partitionvar1__; //varexpr
5693     int __leftboolean3668__ = __Block___hash->contains(__exprval3670__);
5694     int __leftmaybe3669__ = maybe;
5695     int __exprval3673__ = (int) __partitionvar2__; //varexpr
5696     int __rightboolean3671__ = __token___hash->contains(__exprval3673__);
5697     int __rightmaybe3672__ = maybe;
5698     maybe = (__leftboolean3668__ && __rightmaybe3672__) || (__rightboolean3671__ && __leftmaybe3669__) || (__leftmaybe3669__ && __rightmaybe3672__);
5699     __constraintboolean3667__ = __leftboolean3668__ && __rightboolean3671__;
5700     if (maybe)
5701       {
5702       __Success = 0;
5703       printf("maybe fail 23. ");
5704       exit(1);
5705       }
5706     else if (!__constraintboolean3667__)
5707       {
5708       __Success = 0;
5709       printf("fail 23. ");
5710       exit(1);
5711       }
5712     }
5713   }
5714
5715
5716 //if (__Success) { printf("all tests passed"); }