Repair/RepairCompiler/MCC/test2.cc

   1 // creating hashtables
   2 SimpleHash* __int___hash = new SimpleHash();
   3 SimpleHash* __FileBlock___hash = new SimpleHash();
   4 SimpleHash* __UsedBlock___hash = new SimpleHash();
   5 SimpleHash* __FileInode___hash = new SimpleHash();
   6 SimpleHash* __SuperBlock___hash = new SimpleHash();
   7 SimpleHash* __UsedInode___hash = new SimpleHash();
   8 SimpleHash* __InodeBitmapBlock___hash = new SimpleHash();
   9 SimpleHash* __BlockBitmapBlock___hash = new SimpleHash();
  10 SimpleHash* __FileDirectoryBlock___hash = new SimpleHash();
  11 SimpleHash* __token___hash = new SimpleHash();
  12 SimpleHash* __DirectoryEntry___hash = new SimpleHash();
  13 SimpleHash* __RootDirectoryInode___hash = new SimpleHash();
  14 SimpleHash* __FreeBlock___hash = new SimpleHash();
  15 SimpleHash* __GroupBlock___hash = new SimpleHash();
  16 SimpleHash* __Block___hash = new SimpleHash();
  17 SimpleHash* __DirectoryBlock___hash = new SimpleHash();
  18 SimpleHash* __FreeInode___hash = new SimpleHash();
  19 SimpleHash* __Inode___hash = new SimpleHash();
  20 SimpleHash* __DirectoryInode___hash = new SimpleHash();
  21 SimpleHash* __InodeTableBlock___hash = new SimpleHash();
  22 __SuperBlock___hash->addParent(__UsedBlock___hash);
  23 __GroupBlock___hash->addParent(__UsedBlock___hash);
  24 __FileDirectoryBlock___hash->addParent(__UsedBlock___hash);
  25 __InodeTableBlock___hash->addParent(__UsedBlock___hash);
  26 __InodeBitmapBlock___hash->addParent(__UsedBlock___hash);
  27 __BlockBitmapBlock___hash->addParent(__UsedBlock___hash);
  28 __FileInode___hash->addParent(__UsedInode___hash);
  29 __DirectoryInode___hash->addParent(__UsedInode___hash);
  30 __DirectoryBlock___hash->addParent(__FileDirectoryBlock___hash);
  31 __FileBlock___hash->addParent(__FileDirectoryBlock___hash);
  32 __UsedBlock___hash->addParent(__Block___hash);
  33 __FreeBlock___hash->addParent(__Block___hash);
  34 __UsedInode___hash->addParent(__Inode___hash);
  35 __FreeInode___hash->addParent(__Inode___hash);
  36 __RootDirectoryInode___hash->addParent(__DirectoryInode___hash);
  37 SimpleHash* __referencecount___hash = new SimpleHash();
  38 SimpleHash* __filesize___hash = new SimpleHash();
  39 SimpleHash* __inodeof___hash = new SimpleHash();
  40 SimpleHash* __contents___hash = new SimpleHash();
  41 SimpleHash* __inodestatus___hash = new SimpleHash();
  42 SimpleHash* __blockstatus___hash = new SimpleHash();
  43
  44
  45 // build rule1
  46 {
  47   //true
  48   int __tempvar0__ = 1;
  49   if (__tempvar0__) {
  50     int __element1__ = 0;
  51     __SuperBlock___hash->add((int)__element1__, (int)__element1__);
  52   }
  53 }
  54
  55
  56 // build rule2
  57 {
  58   //true
  59   int __tempvar2__ = 1;
  60   if (__tempvar2__) {
  61     int __element3__ = 1;
  62     __GroupBlock___hash->add((int)__element3__, (int)__element3__);
  63   }
  64 }
  65
  66
  67 // build rule3
  68 {
  69   //d.g.InodeTableBlock < d.s.NumberofBlocks
  70   // __left6__ <-- d.g
  71   // __left7__ <-- d
  72   int __left7__ = (int) d;
  73   // __left7__ = d
  74   // __offsetinbits8__ <-- 0 + 8 * d.s.blocksize + 0 * 1
  75   int __leftop9__ = 0;
  76   int __leftop13__ = 8;
  77   // __left15__ <-- d.s
  78   // __left16__ <-- d
  79   int __left16__ = (int) d;
  80   // __left16__ = d
  81   int __left15__ = (__left16__ + 0);
  82   // __left15__ = d.s
  83   // __offsetinbits17__ <-- 32 + 32 + 32 + 32 + 32 + 0
  84   int __leftop18__ = 32;
  85   int __leftop20__ = 32;
  86   int __leftop22__ = 32;
  87   int __leftop24__ = 32;
  88   int __leftop26__ = 32;
  89   int __rightop27__ = 0;
  90   int __rightop25__ = __leftop26__ + __rightop27__;
  91   int __rightop23__ = __leftop24__ + __rightop25__;
  92   int __rightop21__ = __leftop22__ + __rightop23__;
  93   int __rightop19__ = __leftop20__ + __rightop21__;
  94   int __offsetinbits17__ = __leftop18__ + __rightop19__;
  95   // __offsetinbits17__ = 32 + 32 + 32 + 32 + 32 + 0
  96   int __offset28__ = __offsetinbits17__ >> 3;
  97   int __shift29__ = __offsetinbits17__ - (__offset28__ << 3);
  98   int __rightop14__ = ((*(int *)(__left15__ + __offset28__))  >> __shift29__) & 0xffffffff;
  99   int __leftop12__ = __leftop13__ * __rightop14__;
 100   int __rightop30__ = 0;
 101   int __leftop11__ = __leftop12__ + __rightop30__;
 102   int __rightop31__ = 1;
 103   int __rightop10__ = __leftop11__ * __rightop31__;
 104   int __offsetinbits8__ = __leftop9__ + __rightop10__;
 105   // __offsetinbits8__ = 0 + 8 * d.s.blocksize + 0 * 1
 106   int __offset32__ = __offsetinbits8__ >> 3;
 107   int __left6__ = (__left7__ + __offset32__);
 108   // __left6__ = d.g
 109   // __offsetinbits33__ <-- 32 + 32 + 0
 110   int __leftop34__ = 32;
 111   int __leftop36__ = 32;
 112   int __rightop37__ = 0;
 113   int __rightop35__ = __leftop36__ + __rightop37__;
 114   int __offsetinbits33__ = __leftop34__ + __rightop35__;
 115   // __offsetinbits33__ = 32 + 32 + 0
 116   int __offset38__ = __offsetinbits33__ >> 3;
 117   int __shift39__ = __offsetinbits33__ - (__offset38__ << 3);
 118   int __leftop5__ = ((*(int *)(__left6__ + __offset38__))  >> __shift39__) & 0xffffffff;
 119   // __left41__ <-- d.s
 120   // __left42__ <-- d
 121   int __left42__ = (int) d;
 122   // __left42__ = d
 123   int __left41__ = (__left42__ + 0);
 124   // __left41__ = d.s
 125   // __offsetinbits43__ <-- 32 + 32 + 0
 126   int __leftop44__ = 32;
 127   int __leftop46__ = 32;
 128   int __rightop47__ = 0;
 129   int __rightop45__ = __leftop46__ + __rightop47__;
 130   int __offsetinbits43__ = __leftop44__ + __rightop45__;
 131   // __offsetinbits43__ = 32 + 32 + 0
 132   int __offset48__ = __offsetinbits43__ >> 3;
 133   int __shift49__ = __offsetinbits43__ - (__offset48__ << 3);
 134   int __rightop40__ = ((*(int *)(__left41__ + __offset48__))  >> __shift49__) & 0xffffffff;
 135   int __tempvar4__ = __leftop5__ < __rightop40__;
 136   if (__tempvar4__) {
 137     // __left51__ <-- d.g
 138     // __left52__ <-- d
 139     int __left52__ = (int) d;
 140     // __left52__ = d
 141     // __offsetinbits53__ <-- 0 + 8 * d.s.blocksize + 0 * 1
 142     int __leftop54__ = 0;
 143     int __leftop58__ = 8;
 144     // __left60__ <-- d.s
 145     // __left61__ <-- d
 146     int __left61__ = (int) d;
 147     // __left61__ = d
 148     int __left60__ = (__left61__ + 0);
 149     // __left60__ = d.s
 150     // __offsetinbits62__ <-- 32 + 32 + 32 + 32 + 32 + 0
 151     int __leftop63__ = 32;
 152     int __leftop65__ = 32;
 153     int __leftop67__ = 32;
 154     int __leftop69__ = 32;
 155     int __leftop71__ = 32;
 156     int __rightop72__ = 0;
 157     int __rightop70__ = __leftop71__ + __rightop72__;
 158     int __rightop68__ = __leftop69__ + __rightop70__;
 159     int __rightop66__ = __leftop67__ + __rightop68__;
 160     int __rightop64__ = __leftop65__ + __rightop66__;
 161     int __offsetinbits62__ = __leftop63__ + __rightop64__;
 162     // __offsetinbits62__ = 32 + 32 + 32 + 32 + 32 + 0
 163     int __offset73__ = __offsetinbits62__ >> 3;
 164     int __shift74__ = __offsetinbits62__ - (__offset73__ << 3);
 165     int __rightop59__ = ((*(int *)(__left60__ + __offset73__))  >> __shift74__) & 0xffffffff;
 166     int __leftop57__ = __leftop58__ * __rightop59__;
 167     int __rightop75__ = 0;
 168     int __leftop56__ = __leftop57__ + __rightop75__;
 169     int __rightop76__ = 1;
 170     int __rightop55__ = __leftop56__ * __rightop76__;
 171     int __offsetinbits53__ = __leftop54__ + __rightop55__;
 172     // __offsetinbits53__ = 0 + 8 * d.s.blocksize + 0 * 1
 173     int __offset77__ = __offsetinbits53__ >> 3;
 174     int __left51__ = (__left52__ + __offset77__);
 175     // __left51__ = d.g
 176     // __offsetinbits78__ <-- 32 + 32 + 0
 177     int __leftop79__ = 32;
 178     int __leftop81__ = 32;
 179     int __rightop82__ = 0;
 180     int __rightop80__ = __leftop81__ + __rightop82__;
 181     int __offsetinbits78__ = __leftop79__ + __rightop80__;
 182     // __offsetinbits78__ = 32 + 32 + 0
 183     int __offset83__ = __offsetinbits78__ >> 3;
 184     int __shift84__ = __offsetinbits78__ - (__offset83__ << 3);
 185     int __element50__ = ((*(int *)(__left51__ + __offset83__))  >> __shift84__) & 0xffffffff;
 186     __InodeTableBlock___hash->add((int)__element50__, (int)__element50__);
 187   }
 188 }
 189
 190
 191 // build rule4
 192 {
 193   //d.g.InodeBitmapBlock < d.s.NumberofBlocks
 194   // __left87__ <-- d.g
 195   // __left88__ <-- d
 196   int __left88__ = (int) d;
 197   // __left88__ = d
 198   // __offsetinbits89__ <-- 0 + 8 * d.s.blocksize + 0 * 1
 199   int __leftop90__ = 0;
 200   int __leftop94__ = 8;
 201   // __left96__ <-- d.s
 202   // __left97__ <-- d
 203   int __left97__ = (int) d;
 204   // __left97__ = d
 205   int __left96__ = (__left97__ + 0);
 206   // __left96__ = d.s
 207   // __offsetinbits98__ <-- 32 + 32 + 32 + 32 + 32 + 0
 208   int __leftop99__ = 32;
 209   int __leftop101__ = 32;
 210   int __leftop103__ = 32;
 211   int __leftop105__ = 32;
 212   int __leftop107__ = 32;
 213   int __rightop108__ = 0;
 214   int __rightop106__ = __leftop107__ + __rightop108__;
 215   int __rightop104__ = __leftop105__ + __rightop106__;
 216   int __rightop102__ = __leftop103__ + __rightop104__;
 217   int __rightop100__ = __leftop101__ + __rightop102__;
 218   int __offsetinbits98__ = __leftop99__ + __rightop100__;
 219   // __offsetinbits98__ = 32 + 32 + 32 + 32 + 32 + 0
 220   int __offset109__ = __offsetinbits98__ >> 3;
 221   int __shift110__ = __offsetinbits98__ - (__offset109__ << 3);
 222   int __rightop95__ = ((*(int *)(__left96__ + __offset109__))  >> __shift110__) & 0xffffffff;
 223   int __leftop93__ = __leftop94__ * __rightop95__;
 224   int __rightop111__ = 0;
 225   int __leftop92__ = __leftop93__ + __rightop111__;
 226   int __rightop112__ = 1;
 227   int __rightop91__ = __leftop92__ * __rightop112__;
 228   int __offsetinbits89__ = __leftop90__ + __rightop91__;
 229   // __offsetinbits89__ = 0 + 8 * d.s.blocksize + 0 * 1
 230   int __offset113__ = __offsetinbits89__ >> 3;
 231   int __left87__ = (__left88__ + __offset113__);
 232   // __left87__ = d.g
 233   // __offsetinbits114__ <-- 32 + 0
 234   int __leftop115__ = 32;
 235   int __rightop116__ = 0;
 236   int __offsetinbits114__ = __leftop115__ + __rightop116__;
 237   // __offsetinbits114__ = 32 + 0
 238   int __offset117__ = __offsetinbits114__ >> 3;
 239   int __shift118__ = __offsetinbits114__ - (__offset117__ << 3);
 240   int __leftop86__ = ((*(int *)(__left87__ + __offset117__))  >> __shift118__) & 0xffffffff;
 241   // __left120__ <-- d.s
 242   // __left121__ <-- d
 243   int __left121__ = (int) d;
 244   // __left121__ = d
 245   int __left120__ = (__left121__ + 0);
 246   // __left120__ = d.s
 247   // __offsetinbits122__ <-- 32 + 32 + 0
 248   int __leftop123__ = 32;
 249   int __leftop125__ = 32;
 250   int __rightop126__ = 0;
 251   int __rightop124__ = __leftop125__ + __rightop126__;
 252   int __offsetinbits122__ = __leftop123__ + __rightop124__;
 253   // __offsetinbits122__ = 32 + 32 + 0
 254   int __offset127__ = __offsetinbits122__ >> 3;
 255   int __shift128__ = __offsetinbits122__ - (__offset127__ << 3);
 256   int __rightop119__ = ((*(int *)(__left120__ + __offset127__))  >> __shift128__) & 0xffffffff;
 257   int __tempvar85__ = __leftop86__ < __rightop119__;
 258   if (__tempvar85__) {
 259     // __left130__ <-- d.g
 260     // __left131__ <-- d
 261     int __left131__ = (int) d;
 262     // __left131__ = d
 263     // __offsetinbits132__ <-- 0 + 8 * d.s.blocksize + 0 * 1
 264     int __leftop133__ = 0;
 265     int __leftop137__ = 8;
 266     // __left139__ <-- d.s
 267     // __left140__ <-- d
 268     int __left140__ = (int) d;
 269     // __left140__ = d
 270     int __left139__ = (__left140__ + 0);
 271     // __left139__ = d.s
 272     // __offsetinbits141__ <-- 32 + 32 + 32 + 32 + 32 + 0
 273     int __leftop142__ = 32;
 274     int __leftop144__ = 32;
 275     int __leftop146__ = 32;
 276     int __leftop148__ = 32;
 277     int __leftop150__ = 32;
 278     int __rightop151__ = 0;
 279     int __rightop149__ = __leftop150__ + __rightop151__;
 280     int __rightop147__ = __leftop148__ + __rightop149__;
 281     int __rightop145__ = __leftop146__ + __rightop147__;
 282     int __rightop143__ = __leftop144__ + __rightop145__;
 283     int __offsetinbits141__ = __leftop142__ + __rightop143__;
 284     // __offsetinbits141__ = 32 + 32 + 32 + 32 + 32 + 0
 285     int __offset152__ = __offsetinbits141__ >> 3;
 286     int __shift153__ = __offsetinbits141__ - (__offset152__ << 3);
 287     int __rightop138__ = ((*(int *)(__left139__ + __offset152__))  >> __shift153__) & 0xffffffff;
 288     int __leftop136__ = __leftop137__ * __rightop138__;
 289     int __rightop154__ = 0;
 290     int __leftop135__ = __leftop136__ + __rightop154__;
 291     int __rightop155__ = 1;
 292     int __rightop134__ = __leftop135__ * __rightop155__;
 293     int __offsetinbits132__ = __leftop133__ + __rightop134__;
 294     // __offsetinbits132__ = 0 + 8 * d.s.blocksize + 0 * 1
 295     int __offset156__ = __offsetinbits132__ >> 3;
 296     int __left130__ = (__left131__ + __offset156__);
 297     // __left130__ = d.g
 298     // __offsetinbits157__ <-- 32 + 0
 299     int __leftop158__ = 32;
 300     int __rightop159__ = 0;
 301     int __offsetinbits157__ = __leftop158__ + __rightop159__;
 302     // __offsetinbits157__ = 32 + 0
 303     int __offset160__ = __offsetinbits157__ >> 3;
 304     int __shift161__ = __offsetinbits157__ - (__offset160__ << 3);
 305     int __element129__ = ((*(int *)(__left130__ + __offset160__))  >> __shift161__) & 0xffffffff;
 306     __InodeBitmapBlock___hash->add((int)__element129__, (int)__element129__);
 307   }
 308 }
 309
 310
 311 // build rule12
 312 {
 313   int __tempvar162__ = 0;
 314   // __left165__ <-- d.s
 315   // __left166__ <-- d
 316   int __left166__ = (int) d;
 317   // __left166__ = d
 318   int __left165__ = (__left166__ + 0);
 319   // __left165__ = d.s
 320   // __offsetinbits167__ <-- 32 + 32 + 32 + 0
 321   int __leftop168__ = 32;
 322   int __leftop170__ = 32;
 323   int __leftop172__ = 32;
 324   int __rightop173__ = 0;
 325   int __rightop171__ = __leftop172__ + __rightop173__;
 326   int __rightop169__ = __leftop170__ + __rightop171__;
 327   int __offsetinbits167__ = __leftop168__ + __rightop169__;
 328   // __offsetinbits167__ = 32 + 32 + 32 + 0
 329   int __offset174__ = __offsetinbits167__ >> 3;
 330   int __shift175__ = __offsetinbits167__ - (__offset174__ << 3);
 331   int __leftop164__ = ((*(int *)(__left165__ + __offset174__))  >> __shift175__) & 0xffffffff;
 332   int __rightop176__ = 1;
 333   int __tempvar163__ = __leftop164__ - __rightop176__;
 334   for (int __j__ = __tempvar162__; __j__ <= __tempvar163__; __j__++) {
 335     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); ) {
 336       int __ibb__ = (int) __ibb___iterator->next();
 337       //cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == {false = 104}
 338       // __left179__ <-- cast(__InodeBitmap__, d.b[ibb])
 339       // __left181__ <-- d
 340       int __left181__ = (int) d;
 341       // __left181__ = d
 342       // __offsetinbits182__ <-- 0 + 8 * d.s.blocksize + 0 * ibb
 343       int __leftop183__ = 0;
 344       int __leftop187__ = 8;
 345       // __left189__ <-- d.s
 346       // __left190__ <-- d
 347       int __left190__ = (int) d;
 348       // __left190__ = d
 349       int __left189__ = (__left190__ + 0);
 350       // __left189__ = d.s
 351       // __offsetinbits191__ <-- 32 + 32 + 32 + 32 + 32 + 0
 352       int __leftop192__ = 32;
 353       int __leftop194__ = 32;
 354       int __leftop196__ = 32;
 355       int __leftop198__ = 32;
 356       int __leftop200__ = 32;
 357       int __rightop201__ = 0;
 358       int __rightop199__ = __leftop200__ + __rightop201__;
 359       int __rightop197__ = __leftop198__ + __rightop199__;
 360       int __rightop195__ = __leftop196__ + __rightop197__;
 361       int __rightop193__ = __leftop194__ + __rightop195__;
 362       int __offsetinbits191__ = __leftop192__ + __rightop193__;
 363       // __offsetinbits191__ = 32 + 32 + 32 + 32 + 32 + 0
 364       int __offset202__ = __offsetinbits191__ >> 3;
 365       int __shift203__ = __offsetinbits191__ - (__offset202__ << 3);
 366       int __rightop188__ = ((*(int *)(__left189__ + __offset202__))  >> __shift203__) & 0xffffffff;
 367       int __leftop186__ = __leftop187__ * __rightop188__;
 368       int __rightop204__ = 0;
 369       int __leftop185__ = __leftop186__ + __rightop204__;
 370       int __rightop205__ = (int) __ibb__;
 371       int __rightop184__ = __leftop185__ * __rightop205__;
 372       int __offsetinbits182__ = __leftop183__ + __rightop184__;
 373       // __offsetinbits182__ = 0 + 8 * d.s.blocksize + 0 * ibb
 374       int __offset206__ = __offsetinbits182__ >> 3;
 375       int __expr180__ = (__left181__ + __offset206__);
 376       int __left179__ = (int) __expr180__;
 377       // __left179__ = cast(__InodeBitmap__, d.b[ibb])
 378       // __offsetinbits207__ <-- 0 + 1 * j
 379       int __leftop208__ = 0;
 380       int __leftop210__ = 1;
 381       int __rightop211__ = (int) __j__;
 382       int __rightop209__ = __leftop210__ * __rightop211__;
 383       int __offsetinbits207__ = __leftop208__ + __rightop209__;
 384       // __offsetinbits207__ = 0 + 1 * j
 385       int __offset212__ = __offsetinbits207__ >> 3;
 386       int __shift213__ = __offsetinbits207__ - (__offset212__ << 3);
 387       int __leftop178__ = ((*(int *)(__left179__ + __offset212__))  >> __shift213__) & 0x1;
 388       int __rightop214__ = 104;
 389       int __tempvar177__ = __leftop178__ == __rightop214__;
 390       if (__tempvar177__) {
 391         int __leftele215__ = (int) __j__;
 392         int __rightele216__ = 105;
 393         __inodestatus___hash->add((int)__leftele215__, (int)__rightele216__);
 394       }
 395     }
 396   }
 397 }
 398
 399
 400 // build rule5
 401 {
 402   //d.g.BlockBitmapBlock < d.s.NumberofBlocks
 403   // __left219__ <-- d.g
 404   // __left220__ <-- d
 405   int __left220__ = (int) d;
 406   // __left220__ = d
 407   // __offsetinbits221__ <-- 0 + 8 * d.s.blocksize + 0 * 1
 408   int __leftop222__ = 0;
 409   int __leftop226__ = 8;
 410   // __left228__ <-- d.s
 411   // __left229__ <-- d
 412   int __left229__ = (int) d;
 413   // __left229__ = d
 414   int __left228__ = (__left229__ + 0);
 415   // __left228__ = d.s
 416   // __offsetinbits230__ <-- 32 + 32 + 32 + 32 + 32 + 0
 417   int __leftop231__ = 32;
 418   int __leftop233__ = 32;
 419   int __leftop235__ = 32;
 420   int __leftop237__ = 32;
 421   int __leftop239__ = 32;
 422   int __rightop240__ = 0;
 423   int __rightop238__ = __leftop239__ + __rightop240__;
 424   int __rightop236__ = __leftop237__ + __rightop238__;
 425   int __rightop234__ = __leftop235__ + __rightop236__;
 426   int __rightop232__ = __leftop233__ + __rightop234__;
 427   int __offsetinbits230__ = __leftop231__ + __rightop232__;
 428   // __offsetinbits230__ = 32 + 32 + 32 + 32 + 32 + 0
 429   int __offset241__ = __offsetinbits230__ >> 3;
 430   int __shift242__ = __offsetinbits230__ - (__offset241__ << 3);
 431   int __rightop227__ = ((*(int *)(__left228__ + __offset241__))  >> __shift242__) & 0xffffffff;
 432   int __leftop225__ = __leftop226__ * __rightop227__;
 433   int __rightop243__ = 0;
 434   int __leftop224__ = __leftop225__ + __rightop243__;
 435   int __rightop244__ = 1;
 436   int __rightop223__ = __leftop224__ * __rightop244__;
 437   int __offsetinbits221__ = __leftop222__ + __rightop223__;
 438   // __offsetinbits221__ = 0 + 8 * d.s.blocksize + 0 * 1
 439   int __offset245__ = __offsetinbits221__ >> 3;
 440   int __left219__ = (__left220__ + __offset245__);
 441   // __left219__ = d.g
 442   int __leftop218__ = ((*(int *)(__left219__ + 0))  >> 0) & 0xffffffff;
 443   // __left247__ <-- d.s
 444   // __left248__ <-- d
 445   int __left248__ = (int) d;
 446   // __left248__ = d
 447   int __left247__ = (__left248__ + 0);
 448   // __left247__ = d.s
 449   // __offsetinbits249__ <-- 32 + 32 + 0
 450   int __leftop250__ = 32;
 451   int __leftop252__ = 32;
 452   int __rightop253__ = 0;
 453   int __rightop251__ = __leftop252__ + __rightop253__;
 454   int __offsetinbits249__ = __leftop250__ + __rightop251__;
 455   // __offsetinbits249__ = 32 + 32 + 0
 456   int __offset254__ = __offsetinbits249__ >> 3;
 457   int __shift255__ = __offsetinbits249__ - (__offset254__ << 3);
 458   int __rightop246__ = ((*(int *)(__left247__ + __offset254__))  >> __shift255__) & 0xffffffff;
 459   int __tempvar217__ = __leftop218__ < __rightop246__;
 460   if (__tempvar217__) {
 461     // __left257__ <-- d.g
 462     // __left258__ <-- d
 463     int __left258__ = (int) d;
 464     // __left258__ = d
 465     // __offsetinbits259__ <-- 0 + 8 * d.s.blocksize + 0 * 1
 466     int __leftop260__ = 0;
 467     int __leftop264__ = 8;
 468     // __left266__ <-- d.s
 469     // __left267__ <-- d
 470     int __left267__ = (int) d;
 471     // __left267__ = d
 472     int __left266__ = (__left267__ + 0);
 473     // __left266__ = d.s
 474     // __offsetinbits268__ <-- 32 + 32 + 32 + 32 + 32 + 0
 475     int __leftop269__ = 32;
 476     int __leftop271__ = 32;
 477     int __leftop273__ = 32;
 478     int __leftop275__ = 32;
 479     int __leftop277__ = 32;
 480     int __rightop278__ = 0;
 481     int __rightop276__ = __leftop277__ + __rightop278__;
 482     int __rightop274__ = __leftop275__ + __rightop276__;
 483     int __rightop272__ = __leftop273__ + __rightop274__;
 484     int __rightop270__ = __leftop271__ + __rightop272__;
 485     int __offsetinbits268__ = __leftop269__ + __rightop270__;
 486     // __offsetinbits268__ = 32 + 32 + 32 + 32 + 32 + 0
 487     int __offset279__ = __offsetinbits268__ >> 3;
 488     int __shift280__ = __offsetinbits268__ - (__offset279__ << 3);
 489     int __rightop265__ = ((*(int *)(__left266__ + __offset279__))  >> __shift280__) & 0xffffffff;
 490     int __leftop263__ = __leftop264__ * __rightop265__;
 491     int __rightop281__ = 0;
 492     int __leftop262__ = __leftop263__ + __rightop281__;
 493     int __rightop282__ = 1;
 494     int __rightop261__ = __leftop262__ * __rightop282__;
 495     int __offsetinbits259__ = __leftop260__ + __rightop261__;
 496     // __offsetinbits259__ = 0 + 8 * d.s.blocksize + 0 * 1
 497     int __offset283__ = __offsetinbits259__ >> 3;
 498     int __left257__ = (__left258__ + __offset283__);
 499     // __left257__ = d.g
 500     int __element256__ = ((*(int *)(__left257__ + 0))  >> 0) & 0xffffffff;
 501     __BlockBitmapBlock___hash->add((int)__element256__, (int)__element256__);
 502   }
 503 }
 504
 505
 506 // build rule13
 507 {
 508   int __tempvar284__ = 0;
 509   // __left287__ <-- d.s
 510   // __left288__ <-- d
 511   int __left288__ = (int) d;
 512   // __left288__ = d
 513   int __left287__ = (__left288__ + 0);
 514   // __left287__ = d.s
 515   // __offsetinbits289__ <-- 32 + 32 + 32 + 0
 516   int __leftop290__ = 32;
 517   int __leftop292__ = 32;
 518   int __leftop294__ = 32;
 519   int __rightop295__ = 0;
 520   int __rightop293__ = __leftop294__ + __rightop295__;
 521   int __rightop291__ = __leftop292__ + __rightop293__;
 522   int __offsetinbits289__ = __leftop290__ + __rightop291__;
 523   // __offsetinbits289__ = 32 + 32 + 32 + 0
 524   int __offset296__ = __offsetinbits289__ >> 3;
 525   int __shift297__ = __offsetinbits289__ - (__offset296__ << 3);
 526   int __leftop286__ = ((*(int *)(__left287__ + __offset296__))  >> __shift297__) & 0xffffffff;
 527   int __rightop298__ = 1;
 528   int __tempvar285__ = __leftop286__ - __rightop298__;
 529   for (int __j__ = __tempvar284__; __j__ <= __tempvar285__; __j__++) {
 530     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); ) {
 531       int __ibb__ = (int) __ibb___iterator->next();
 532       //cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == true
 533       // __left301__ <-- cast(__InodeBitmap__, d.b[ibb])
 534       // __left303__ <-- d
 535       int __left303__ = (int) d;
 536       // __left303__ = d
 537       // __offsetinbits304__ <-- 0 + 8 * d.s.blocksize + 0 * ibb
 538       int __leftop305__ = 0;
 539       int __leftop309__ = 8;
 540       // __left311__ <-- d.s
 541       // __left312__ <-- d
 542       int __left312__ = (int) d;
 543       // __left312__ = d
 544       int __left311__ = (__left312__ + 0);
 545       // __left311__ = d.s
 546       // __offsetinbits313__ <-- 32 + 32 + 32 + 32 + 32 + 0
 547       int __leftop314__ = 32;
 548       int __leftop316__ = 32;
 549       int __leftop318__ = 32;
 550       int __leftop320__ = 32;
 551       int __leftop322__ = 32;
 552       int __rightop323__ = 0;
 553       int __rightop321__ = __leftop322__ + __rightop323__;
 554       int __rightop319__ = __leftop320__ + __rightop321__;
 555       int __rightop317__ = __leftop318__ + __rightop319__;
 556       int __rightop315__ = __leftop316__ + __rightop317__;
 557       int __offsetinbits313__ = __leftop314__ + __rightop315__;
 558       // __offsetinbits313__ = 32 + 32 + 32 + 32 + 32 + 0
 559       int __offset324__ = __offsetinbits313__ >> 3;
 560       int __shift325__ = __offsetinbits313__ - (__offset324__ << 3);
 561       int __rightop310__ = ((*(int *)(__left311__ + __offset324__))  >> __shift325__) & 0xffffffff;
 562       int __leftop308__ = __leftop309__ * __rightop310__;
 563       int __rightop326__ = 0;
 564       int __leftop307__ = __leftop308__ + __rightop326__;
 565       int __rightop327__ = (int) __ibb__;
 566       int __rightop306__ = __leftop307__ * __rightop327__;
 567       int __offsetinbits304__ = __leftop305__ + __rightop306__;
 568       // __offsetinbits304__ = 0 + 8 * d.s.blocksize + 0 * ibb
 569       int __offset328__ = __offsetinbits304__ >> 3;
 570       int __expr302__ = (__left303__ + __offset328__);
 571       int __left301__ = (int) __expr302__;
 572       // __left301__ = cast(__InodeBitmap__, d.b[ibb])
 573       // __offsetinbits329__ <-- 0 + 1 * j
 574       int __leftop330__ = 0;
 575       int __leftop332__ = 1;
 576       int __rightop333__ = (int) __j__;
 577       int __rightop331__ = __leftop332__ * __rightop333__;
 578       int __offsetinbits329__ = __leftop330__ + __rightop331__;
 579       // __offsetinbits329__ = 0 + 1 * j
 580       int __offset334__ = __offsetinbits329__ >> 3;
 581       int __shift335__ = __offsetinbits329__ - (__offset334__ << 3);
 582       int __leftop300__ = ((*(int *)(__left301__ + __offset334__))  >> __shift335__) & 0x1;
 583       int __rightop336__ = 1;
 584       int __tempvar299__ = __leftop300__ == __rightop336__;
 585       if (__tempvar299__) {
 586         int __leftele337__ = (int) __j__;
 587         int __rightele338__ = 106;
 588         __inodestatus___hash->add((int)__leftele337__, (int)__rightele338__);
 589       }
 590     }
 591   }
 592 }
 593
 594
 595 // build rule6
 596 {
 597   //d.s.RootDirectoryInode < d.s.NumberofInodes
 598   // __left341__ <-- d.s
 599   // __left342__ <-- d
 600   int __left342__ = (int) d;
 601   // __left342__ = d
 602   int __left341__ = (__left342__ + 0);
 603   // __left341__ = d.s
 604   // __offsetinbits343__ <-- 32 + 32 + 32 + 32 + 0
 605   int __leftop344__ = 32;
 606   int __leftop346__ = 32;
 607   int __leftop348__ = 32;
 608   int __leftop350__ = 32;
 609   int __rightop351__ = 0;
 610   int __rightop349__ = __leftop350__ + __rightop351__;
 611   int __rightop347__ = __leftop348__ + __rightop349__;
 612   int __rightop345__ = __leftop346__ + __rightop347__;
 613   int __offsetinbits343__ = __leftop344__ + __rightop345__;
 614   // __offsetinbits343__ = 32 + 32 + 32 + 32 + 0
 615   int __offset352__ = __offsetinbits343__ >> 3;
 616   int __shift353__ = __offsetinbits343__ - (__offset352__ << 3);
 617   int __leftop340__ = ((*(int *)(__left341__ + __offset352__))  >> __shift353__) & 0xffffffff;
 618   // __left355__ <-- d.s
 619   // __left356__ <-- d
 620   int __left356__ = (int) d;
 621   // __left356__ = d
 622   int __left355__ = (__left356__ + 0);
 623   // __left355__ = d.s
 624   // __offsetinbits357__ <-- 32 + 32 + 32 + 0
 625   int __leftop358__ = 32;
 626   int __leftop360__ = 32;
 627   int __leftop362__ = 32;
 628   int __rightop363__ = 0;
 629   int __rightop361__ = __leftop362__ + __rightop363__;
 630   int __rightop359__ = __leftop360__ + __rightop361__;
 631   int __offsetinbits357__ = __leftop358__ + __rightop359__;
 632   // __offsetinbits357__ = 32 + 32 + 32 + 0
 633   int __offset364__ = __offsetinbits357__ >> 3;
 634   int __shift365__ = __offsetinbits357__ - (__offset364__ << 3);
 635   int __rightop354__ = ((*(int *)(__left355__ + __offset364__))  >> __shift365__) & 0xffffffff;
 636   int __tempvar339__ = __leftop340__ < __rightop354__;
 637   if (__tempvar339__) {
 638     // __left367__ <-- d.s
 639     // __left368__ <-- d
 640     int __left368__ = (int) d;
 641     // __left368__ = d
 642     int __left367__ = (__left368__ + 0);
 643     // __left367__ = d.s
 644     // __offsetinbits369__ <-- 32 + 32 + 32 + 32 + 0
 645     int __leftop370__ = 32;
 646     int __leftop372__ = 32;
 647     int __leftop374__ = 32;
 648     int __leftop376__ = 32;
 649     int __rightop377__ = 0;
 650     int __rightop375__ = __leftop376__ + __rightop377__;
 651     int __rightop373__ = __leftop374__ + __rightop375__;
 652     int __rightop371__ = __leftop372__ + __rightop373__;
 653     int __offsetinbits369__ = __leftop370__ + __rightop371__;
 654     // __offsetinbits369__ = 32 + 32 + 32 + 32 + 0
 655     int __offset378__ = __offsetinbits369__ >> 3;
 656     int __shift379__ = __offsetinbits369__ - (__offset378__ << 3);
 657     int __element366__ = ((*(int *)(__left367__ + __offset378__))  >> __shift379__) & 0xffffffff;
 658     __RootDirectoryInode___hash->add((int)__element366__, (int)__element366__);
 659   }
 660 }
 661
 662
 663 // build rule9
 664 {
 665   for (SimpleIterator* __di___iterator = __DirectoryInode___hash->iterator(); __di___iterator->hasNext(); ) {
 666     int __di__ = (int) __di___iterator->next();
 667     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
 668       int __itb__ = (int) __itb___iterator->next();
 669       int __tempvar380__ = 0;
 670       // __left384__ <-- d.s
 671       // __left385__ <-- d
 672       int __left385__ = (int) d;
 673       // __left385__ = d
 674       int __left384__ = (__left385__ + 0);
 675       // __left384__ = d.s
 676       // __offsetinbits386__ <-- 32 + 32 + 32 + 32 + 32 + 0
 677       int __leftop387__ = 32;
 678       int __leftop389__ = 32;
 679       int __leftop391__ = 32;
 680       int __leftop393__ = 32;
 681       int __leftop395__ = 32;
 682       int __rightop396__ = 0;
 683       int __rightop394__ = __leftop395__ + __rightop396__;
 684       int __rightop392__ = __leftop393__ + __rightop394__;
 685       int __rightop390__ = __leftop391__ + __rightop392__;
 686       int __rightop388__ = __leftop389__ + __rightop390__;
 687       int __offsetinbits386__ = __leftop387__ + __rightop388__;
 688       // __offsetinbits386__ = 32 + 32 + 32 + 32 + 32 + 0
 689       int __offset397__ = __offsetinbits386__ >> 3;
 690       int __shift398__ = __offsetinbits386__ - (__offset397__ << 3);
 691       int __leftop383__ = ((*(int *)(__left384__ + __offset397__))  >> __shift398__) & 0xffffffff;
 692       int __rightop399__ = 128;
 693       int __leftop382__ = __leftop383__ / __rightop399__;
 694       int __rightop400__ = 1;
 695       int __tempvar381__ = __leftop382__ - __rightop400__;
 696       for (int __j__ = __tempvar380__; __j__ <= __tempvar381__; __j__++) {
 697         int __tempvar401__ = 0;
 698         int __tempvar402__ = 11;
 699         for (int __k__ = __tempvar401__; __k__ <= __tempvar402__; __k__++) {
 700           //cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k] < d.s.NumberofBlocks
 701           // __left405__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
 702           // __left406__ <-- cast(__InodeTable__, d.b[itb])
 703           // __left408__ <-- d
 704           int __left408__ = (int) d;
 705           // __left408__ = d
 706           // __offsetinbits409__ <-- 0 + 8 * d.s.blocksize + 0 * itb
 707           int __leftop410__ = 0;
 708           int __leftop414__ = 8;
 709           // __left416__ <-- d.s
 710           // __left417__ <-- d
 711           int __left417__ = (int) d;
 712           // __left417__ = d
 713           int __left416__ = (__left417__ + 0);
 714           // __left416__ = d.s
 715           // __offsetinbits418__ <-- 32 + 32 + 32 + 32 + 32 + 0
 716           int __leftop419__ = 32;
 717           int __leftop421__ = 32;
 718           int __leftop423__ = 32;
 719           int __leftop425__ = 32;
 720           int __leftop427__ = 32;
 721           int __rightop428__ = 0;
 722           int __rightop426__ = __leftop427__ + __rightop428__;
 723           int __rightop424__ = __leftop425__ + __rightop426__;
 724           int __rightop422__ = __leftop423__ + __rightop424__;
 725           int __rightop420__ = __leftop421__ + __rightop422__;
 726           int __offsetinbits418__ = __leftop419__ + __rightop420__;
 727           // __offsetinbits418__ = 32 + 32 + 32 + 32 + 32 + 0
 728           int __offset429__ = __offsetinbits418__ >> 3;
 729           int __shift430__ = __offsetinbits418__ - (__offset429__ << 3);
 730           int __rightop415__ = ((*(int *)(__left416__ + __offset429__))  >> __shift430__) & 0xffffffff;
 731           int __leftop413__ = __leftop414__ * __rightop415__;
 732           int __rightop431__ = 0;
 733           int __leftop412__ = __leftop413__ + __rightop431__;
 734           int __rightop432__ = (int) __itb__;
 735           int __rightop411__ = __leftop412__ * __rightop432__;
 736           int __offsetinbits409__ = __leftop410__ + __rightop411__;
 737           // __offsetinbits409__ = 0 + 8 * d.s.blocksize + 0 * itb
 738           int __offset433__ = __offsetinbits409__ >> 3;
 739           int __expr407__ = (__left408__ + __offset433__);
 740           int __left406__ = (int) __expr407__;
 741           // __left406__ = cast(__InodeTable__, d.b[itb])
 742           // __offsetinbits434__ <-- 0 + 32 + 32 * 12 + 32 + 0 * di
 743           int __leftop435__ = 0;
 744           int __leftop438__ = 32;
 745           int __leftop441__ = 32;
 746           int __rightop442__ = 12;
 747           int __leftop440__ = __leftop441__ * __rightop442__;
 748           int __leftop444__ = 32;
 749           int __rightop445__ = 0;
 750           int __rightop443__ = __leftop444__ + __rightop445__;
 751           int __rightop439__ = __leftop440__ + __rightop443__;
 752           int __leftop437__ = __leftop438__ + __rightop439__;
 753           int __rightop446__ = (int) __di__;
 754           int __rightop436__ = __leftop437__ * __rightop446__;
 755           int __offsetinbits434__ = __leftop435__ + __rightop436__;
 756           // __offsetinbits434__ = 0 + 32 + 32 * 12 + 32 + 0 * di
 757           int __offset447__ = __offsetinbits434__ >> 3;
 758           int __left405__ = (__left406__ + __offset447__);
 759           // __left405__ = cast(__InodeTable__, d.b[itb]).itable[di]
 760           // __offsetinbits448__ <-- 32 + 0 + 32 * k
 761           int __leftop450__ = 32;
 762           int __rightop451__ = 0;
 763           int __leftop449__ = __leftop450__ + __rightop451__;
 764           int __leftop453__ = 32;
 765           int __rightop454__ = (int) __k__;
 766           int __rightop452__ = __leftop453__ * __rightop454__;
 767           int __offsetinbits448__ = __leftop449__ + __rightop452__;
 768           // __offsetinbits448__ = 32 + 0 + 32 * k
 769           int __offset455__ = __offsetinbits448__ >> 3;
 770           int __shift456__ = __offsetinbits448__ - (__offset455__ << 3);
 771           int __leftop404__ = ((*(int *)(__left405__ + __offset455__))  >> __shift456__) & 0xffffffff;
 772           // __left458__ <-- d.s
 773           // __left459__ <-- d
 774           int __left459__ = (int) d;
 775           // __left459__ = d
 776           int __left458__ = (__left459__ + 0);
 777           // __left458__ = d.s
 778           // __offsetinbits460__ <-- 32 + 32 + 0
 779           int __leftop461__ = 32;
 780           int __leftop463__ = 32;
 781           int __rightop464__ = 0;
 782           int __rightop462__ = __leftop463__ + __rightop464__;
 783           int __offsetinbits460__ = __leftop461__ + __rightop462__;
 784           // __offsetinbits460__ = 32 + 32 + 0
 785           int __offset465__ = __offsetinbits460__ >> 3;
 786           int __shift466__ = __offsetinbits460__ - (__offset465__ << 3);
 787           int __rightop457__ = ((*(int *)(__left458__ + __offset465__))  >> __shift466__) & 0xffffffff;
 788           int __tempvar403__ = __leftop404__ < __rightop457__;
 789           if (__tempvar403__) {
 790             // __left468__ <-- cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
 791             // __left470__ <-- d
 792             int __left470__ = (int) d;
 793             // __left470__ = d
 794             // __offsetinbits471__ <-- 0 + 8 * d.s.blocksize + 0 * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]
 795             int __leftop472__ = 0;
 796             int __leftop476__ = 8;
 797             // __left478__ <-- d.s
 798             // __left479__ <-- d
 799             int __left479__ = (int) d;
 800             // __left479__ = d
 801             int __left478__ = (__left479__ + 0);
 802             // __left478__ = d.s
 803             // __offsetinbits480__ <-- 32 + 32 + 32 + 32 + 32 + 0
 804             int __leftop481__ = 32;
 805             int __leftop483__ = 32;
 806             int __leftop485__ = 32;
 807             int __leftop487__ = 32;
 808             int __leftop489__ = 32;
 809             int __rightop490__ = 0;
 810             int __rightop488__ = __leftop489__ + __rightop490__;
 811             int __rightop486__ = __leftop487__ + __rightop488__;
 812             int __rightop484__ = __leftop485__ + __rightop486__;
 813             int __rightop482__ = __leftop483__ + __rightop484__;
 814             int __offsetinbits480__ = __leftop481__ + __rightop482__;
 815             // __offsetinbits480__ = 32 + 32 + 32 + 32 + 32 + 0
 816             int __offset491__ = __offsetinbits480__ >> 3;
 817             int __shift492__ = __offsetinbits480__ - (__offset491__ << 3);
 818             int __rightop477__ = ((*(int *)(__left478__ + __offset491__))  >> __shift492__) & 0xffffffff;
 819             int __leftop475__ = __leftop476__ * __rightop477__;
 820             int __rightop493__ = 0;
 821             int __leftop474__ = __leftop475__ + __rightop493__;
 822             // __left495__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
 823             // __left496__ <-- cast(__InodeTable__, d.b[itb])
 824             // __left498__ <-- d
 825             int __left498__ = (int) d;
 826             // __left498__ = d
 827             // __offsetinbits499__ <-- 0 + 8 * d.s.blocksize + 0 * itb
 828             int __leftop500__ = 0;
 829             int __leftop504__ = 8;
 830             // __left506__ <-- d.s
 831             // __left507__ <-- d
 832             int __left507__ = (int) d;
 833             // __left507__ = d
 834             int __left506__ = (__left507__ + 0);
 835             // __left506__ = d.s
 836             // __offsetinbits508__ <-- 32 + 32 + 32 + 32 + 32 + 0
 837             int __leftop509__ = 32;
 838             int __leftop511__ = 32;
 839             int __leftop513__ = 32;
 840             int __leftop515__ = 32;
 841             int __leftop517__ = 32;
 842             int __rightop518__ = 0;
 843             int __rightop516__ = __leftop517__ + __rightop518__;
 844             int __rightop514__ = __leftop515__ + __rightop516__;
 845             int __rightop512__ = __leftop513__ + __rightop514__;
 846             int __rightop510__ = __leftop511__ + __rightop512__;
 847             int __offsetinbits508__ = __leftop509__ + __rightop510__;
 848             // __offsetinbits508__ = 32 + 32 + 32 + 32 + 32 + 0
 849             int __offset519__ = __offsetinbits508__ >> 3;
 850             int __shift520__ = __offsetinbits508__ - (__offset519__ << 3);
 851             int __rightop505__ = ((*(int *)(__left506__ + __offset519__))  >> __shift520__) & 0xffffffff;
 852             int __leftop503__ = __leftop504__ * __rightop505__;
 853             int __rightop521__ = 0;
 854             int __leftop502__ = __leftop503__ + __rightop521__;
 855             int __rightop522__ = (int) __itb__;
 856             int __rightop501__ = __leftop502__ * __rightop522__;
 857             int __offsetinbits499__ = __leftop500__ + __rightop501__;
 858             // __offsetinbits499__ = 0 + 8 * d.s.blocksize + 0 * itb
 859             int __offset523__ = __offsetinbits499__ >> 3;
 860             int __expr497__ = (__left498__ + __offset523__);
 861             int __left496__ = (int) __expr497__;
 862             // __left496__ = cast(__InodeTable__, d.b[itb])
 863             // __offsetinbits524__ <-- 0 + 32 + 32 * 12 + 32 + 0 * di
 864             int __leftop525__ = 0;
 865             int __leftop528__ = 32;
 866             int __leftop531__ = 32;
 867             int __rightop532__ = 12;
 868             int __leftop530__ = __leftop531__ * __rightop532__;
 869             int __leftop534__ = 32;
 870             int __rightop535__ = 0;
 871             int __rightop533__ = __leftop534__ + __rightop535__;
 872             int __rightop529__ = __leftop530__ + __rightop533__;
 873             int __leftop527__ = __leftop528__ + __rightop529__;
 874             int __rightop536__ = (int) __di__;
 875             int __rightop526__ = __leftop527__ * __rightop536__;
 876             int __offsetinbits524__ = __leftop525__ + __rightop526__;
 877             // __offsetinbits524__ = 0 + 32 + 32 * 12 + 32 + 0 * di
 878             int __offset537__ = __offsetinbits524__ >> 3;
 879             int __left495__ = (__left496__ + __offset537__);
 880             // __left495__ = cast(__InodeTable__, d.b[itb]).itable[di]
 881             // __offsetinbits538__ <-- 32 + 0 + 32 * k
 882             int __leftop540__ = 32;
 883             int __rightop541__ = 0;
 884             int __leftop539__ = __leftop540__ + __rightop541__;
 885             int __leftop543__ = 32;
 886             int __rightop544__ = (int) __k__;
 887             int __rightop542__ = __leftop543__ * __rightop544__;
 888             int __offsetinbits538__ = __leftop539__ + __rightop542__;
 889             // __offsetinbits538__ = 32 + 0 + 32 * k
 890             int __offset545__ = __offsetinbits538__ >> 3;
 891             int __shift546__ = __offsetinbits538__ - (__offset545__ << 3);
 892             int __rightop494__ = ((*(int *)(__left495__ + __offset545__))  >> __shift546__) & 0xffffffff;
 893             int __rightop473__ = __leftop474__ * __rightop494__;
 894             int __offsetinbits471__ = __leftop472__ + __rightop473__;
 895             // __offsetinbits471__ = 0 + 8 * d.s.blocksize + 0 * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]
 896             int __offset547__ = __offsetinbits471__ >> 3;
 897             int __expr469__ = (__left470__ + __offset547__);
 898             int __left468__ = (int) __expr469__;
 899             // __left468__ = cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
 900             // __offsetinbits548__ <-- 0 + 32 + 8 * 124 + 0 * j
 901             int __leftop549__ = 0;
 902             int __leftop552__ = 32;
 903             int __leftop555__ = 8;
 904             int __rightop556__ = 124;
 905             int __leftop554__ = __leftop555__ * __rightop556__;
 906             int __rightop557__ = 0;
 907             int __rightop553__ = __leftop554__ + __rightop557__;
 908             int __leftop551__ = __leftop552__ + __rightop553__;
 909             int __rightop558__ = (int) __j__;
 910             int __rightop550__ = __leftop551__ * __rightop558__;
 911             int __offsetinbits548__ = __leftop549__ + __rightop550__;
 912             // __offsetinbits548__ = 0 + 32 + 8 * 124 + 0 * j
 913             int __offset559__ = __offsetinbits548__ >> 3;
 914             int __element467__ = (__left468__ + __offset559__);
 915             __DirectoryEntry___hash->add((int)__element467__, (int)__element467__);
 916           }
 917         }
 918       }
 919     }
 920   }
 921 }
 922
 923
 924 // build rule15
 925 {
 926   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); ) {
 927     int __de__ = (int) __de___iterator->next();
 928     //de.inodenumber < d.s.NumberofInodes
 929     // __left562__ <-- de
 930     int __left562__ = (int) __de__;
 931     // __left562__ = de
 932     // __offsetinbits563__ <-- 8 * 124 + 0
 933     int __leftop565__ = 8;
 934     int __rightop566__ = 124;
 935     int __leftop564__ = __leftop565__ * __rightop566__;
 936     int __rightop567__ = 0;
 937     int __offsetinbits563__ = __leftop564__ + __rightop567__;
 938     // __offsetinbits563__ = 8 * 124 + 0
 939     int __offset568__ = __offsetinbits563__ >> 3;
 940     int __shift569__ = __offsetinbits563__ - (__offset568__ << 3);
 941     int __leftop561__ = ((*(int *)(__left562__ + __offset568__))  >> __shift569__) & 0xffffffff;
 942     // __left571__ <-- d.s
 943     // __left572__ <-- d
 944     int __left572__ = (int) d;
 945     // __left572__ = d
 946     int __left571__ = (__left572__ + 0);
 947     // __left571__ = d.s
 948     // __offsetinbits573__ <-- 32 + 32 + 32 + 0
 949     int __leftop574__ = 32;
 950     int __leftop576__ = 32;
 951     int __leftop578__ = 32;
 952     int __rightop579__ = 0;
 953     int __rightop577__ = __leftop578__ + __rightop579__;
 954     int __rightop575__ = __leftop576__ + __rightop577__;
 955     int __offsetinbits573__ = __leftop574__ + __rightop575__;
 956     // __offsetinbits573__ = 32 + 32 + 32 + 0
 957     int __offset580__ = __offsetinbits573__ >> 3;
 958     int __shift581__ = __offsetinbits573__ - (__offset580__ << 3);
 959     int __rightop570__ = ((*(int *)(__left571__ + __offset580__))  >> __shift581__) & 0xffffffff;
 960     int __tempvar560__ = __leftop561__ < __rightop570__;
 961     if (__tempvar560__) {
 962       int __leftele582__ = (int) __de__;
 963       // __left584__ <-- de
 964       int __left584__ = (int) __de__;
 965       // __left584__ = de
 966       // __offsetinbits585__ <-- 8 * 124 + 0
 967       int __leftop587__ = 8;
 968       int __rightop588__ = 124;
 969       int __leftop586__ = __leftop587__ * __rightop588__;
 970       int __rightop589__ = 0;
 971       int __offsetinbits585__ = __leftop586__ + __rightop589__;
 972       // __offsetinbits585__ = 8 * 124 + 0
 973       int __offset590__ = __offsetinbits585__ >> 3;
 974       int __shift591__ = __offsetinbits585__ - (__offset590__ << 3);
 975       int __rightele583__ = ((*(int *)(__left584__ + __offset590__))  >> __shift591__) & 0xffffffff;
 976       __inodeof___hash->add((int)__leftele582__, (int)__rightele583__);
 977     }
 978   }
 979 }
 980
 981
 982 // build rule14
 983 {
 984   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); ) {
 985     int __de__ = (int) __de___iterator->next();
 986     //de.inodenumber < d.s.NumberofInodes && !de.inodenumber == 0
 987     // __left595__ <-- de
 988     int __left595__ = (int) __de__;
 989     // __left595__ = de
 990     // __offsetinbits596__ <-- 8 * 124 + 0
 991     int __leftop598__ = 8;
 992     int __rightop599__ = 124;
 993     int __leftop597__ = __leftop598__ * __rightop599__;
 994     int __rightop600__ = 0;
 995     int __offsetinbits596__ = __leftop597__ + __rightop600__;
 996     // __offsetinbits596__ = 8 * 124 + 0
 997     int __offset601__ = __offsetinbits596__ >> 3;
 998     int __shift602__ = __offsetinbits596__ - (__offset601__ << 3);
 999     int __leftop594__ = ((*(int *)(__left595__ + __offset601__))  >> __shift602__) & 0xffffffff;
1000     // __left604__ <-- d.s
1001     // __left605__ <-- d
1002     int __left605__ = (int) d;
1003     // __left605__ = d
1004     int __left604__ = (__left605__ + 0);
1005     // __left604__ = d.s
1006     // __offsetinbits606__ <-- 32 + 32 + 32 + 0
1007     int __leftop607__ = 32;
1008     int __leftop609__ = 32;
1009     int __leftop611__ = 32;
1010     int __rightop612__ = 0;
1011     int __rightop610__ = __leftop611__ + __rightop612__;
1012     int __rightop608__ = __leftop609__ + __rightop610__;
1013     int __offsetinbits606__ = __leftop607__ + __rightop608__;
1014     // __offsetinbits606__ = 32 + 32 + 32 + 0
1015     int __offset613__ = __offsetinbits606__ >> 3;
1016     int __shift614__ = __offsetinbits606__ - (__offset613__ << 3);
1017     int __rightop603__ = ((*(int *)(__left604__ + __offset613__))  >> __shift614__) & 0xffffffff;
1018     int __leftop593__ = __leftop594__ < __rightop603__;
1019     // __left618__ <-- de
1020     int __left618__ = (int) __de__;
1021     // __left618__ = de
1022     // __offsetinbits619__ <-- 8 * 124 + 0
1023     int __leftop621__ = 8;
1024     int __rightop622__ = 124;
1025     int __leftop620__ = __leftop621__ * __rightop622__;
1026     int __rightop623__ = 0;
1027     int __offsetinbits619__ = __leftop620__ + __rightop623__;
1028     // __offsetinbits619__ = 8 * 124 + 0
1029     int __offset624__ = __offsetinbits619__ >> 3;
1030     int __shift625__ = __offsetinbits619__ - (__offset624__ << 3);
1031     int __leftop617__ = ((*(int *)(__left618__ + __offset624__))  >> __shift625__) & 0xffffffff;
1032     int __rightop626__ = 0;
1033     int __leftop616__ = __leftop617__ == __rightop626__;
1034     int __rightop615__ = !__leftop616__;
1035     int __tempvar592__ = __leftop593__ && __rightop615__;
1036     if (__tempvar592__) {
1037       // __left628__ <-- de
1038       int __left628__ = (int) __de__;
1039       // __left628__ = de
1040       // __offsetinbits629__ <-- 8 * 124 + 0
1041       int __leftop631__ = 8;
1042       int __rightop632__ = 124;
1043       int __leftop630__ = __leftop631__ * __rightop632__;
1044       int __rightop633__ = 0;
1045       int __offsetinbits629__ = __leftop630__ + __rightop633__;
1046       // __offsetinbits629__ = 8 * 124 + 0
1047       int __offset634__ = __offsetinbits629__ >> 3;
1048       int __shift635__ = __offsetinbits629__ - (__offset634__ << 3);
1049       int __element627__ = ((*(int *)(__left628__ + __offset634__))  >> __shift635__) & 0xffffffff;
1050       __FileInode___hash->add((int)__element627__, (int)__element627__);
1051     }
1052   }
1053 }
1054
1055
1056 // build rule16
1057 {
1058   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); ) {
1059     int __j__ = (int) __j___iterator->next();
1060     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1061       int __itb__ = (int) __itb___iterator->next();
1062       //true
1063       int __tempvar636__ = 1;
1064       if (__tempvar636__) {
1065         int __leftele637__ = (int) __j__;
1066         // __left639__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1067         // __left640__ <-- cast(__InodeTable__, d.b[itb])
1068         // __left642__ <-- d
1069         int __left642__ = (int) d;
1070         // __left642__ = d
1071         // __offsetinbits643__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1072         int __leftop644__ = 0;
1073         int __leftop648__ = 8;
1074         // __left650__ <-- d.s
1075         // __left651__ <-- d
1076         int __left651__ = (int) d;
1077         // __left651__ = d
1078         int __left650__ = (__left651__ + 0);
1079         // __left650__ = d.s
1080         // __offsetinbits652__ <-- 32 + 32 + 32 + 32 + 32 + 0
1081         int __leftop653__ = 32;
1082         int __leftop655__ = 32;
1083         int __leftop657__ = 32;
1084         int __leftop659__ = 32;
1085         int __leftop661__ = 32;
1086         int __rightop662__ = 0;
1087         int __rightop660__ = __leftop661__ + __rightop662__;
1088         int __rightop658__ = __leftop659__ + __rightop660__;
1089         int __rightop656__ = __leftop657__ + __rightop658__;
1090         int __rightop654__ = __leftop655__ + __rightop656__;
1091         int __offsetinbits652__ = __leftop653__ + __rightop654__;
1092         // __offsetinbits652__ = 32 + 32 + 32 + 32 + 32 + 0
1093         int __offset663__ = __offsetinbits652__ >> 3;
1094         int __shift664__ = __offsetinbits652__ - (__offset663__ << 3);
1095         int __rightop649__ = ((*(int *)(__left650__ + __offset663__))  >> __shift664__) & 0xffffffff;
1096         int __leftop647__ = __leftop648__ * __rightop649__;
1097         int __rightop665__ = 0;
1098         int __leftop646__ = __leftop647__ + __rightop665__;
1099         int __rightop666__ = (int) __itb__;
1100         int __rightop645__ = __leftop646__ * __rightop666__;
1101         int __offsetinbits643__ = __leftop644__ + __rightop645__;
1102         // __offsetinbits643__ = 0 + 8 * d.s.blocksize + 0 * itb
1103         int __offset667__ = __offsetinbits643__ >> 3;
1104         int __expr641__ = (__left642__ + __offset667__);
1105         int __left640__ = (int) __expr641__;
1106         // __left640__ = cast(__InodeTable__, d.b[itb])
1107         // __offsetinbits668__ <-- 0 + 32 + 32 * 12 + 32 + 0 * j
1108         int __leftop669__ = 0;
1109         int __leftop672__ = 32;
1110         int __leftop675__ = 32;
1111         int __rightop676__ = 12;
1112         int __leftop674__ = __leftop675__ * __rightop676__;
1113         int __leftop678__ = 32;
1114         int __rightop679__ = 0;
1115         int __rightop677__ = __leftop678__ + __rightop679__;
1116         int __rightop673__ = __leftop674__ + __rightop677__;
1117         int __leftop671__ = __leftop672__ + __rightop673__;
1118         int __rightop680__ = (int) __j__;
1119         int __rightop670__ = __leftop671__ * __rightop680__;
1120         int __offsetinbits668__ = __leftop669__ + __rightop670__;
1121         // __offsetinbits668__ = 0 + 32 + 32 * 12 + 32 + 0 * j
1122         int __offset681__ = __offsetinbits668__ >> 3;
1123         int __left639__ = (__left640__ + __offset681__);
1124         // __left639__ = cast(__InodeTable__, d.b[itb]).itable[j]
1125         // __offsetinbits682__ <-- 32 * 12 + 32 + 0
1126         int __leftop684__ = 32;
1127         int __rightop685__ = 12;
1128         int __leftop683__ = __leftop684__ * __rightop685__;
1129         int __leftop687__ = 32;
1130         int __rightop688__ = 0;
1131         int __rightop686__ = __leftop687__ + __rightop688__;
1132         int __offsetinbits682__ = __leftop683__ + __rightop686__;
1133         // __offsetinbits682__ = 32 * 12 + 32 + 0
1134         int __offset689__ = __offsetinbits682__ >> 3;
1135         int __shift690__ = __offsetinbits682__ - (__offset689__ << 3);
1136         int __rightele638__ = ((*(int *)(__left639__ + __offset689__))  >> __shift690__) & 0xffffffff;
1137         __referencecount___hash->add((int)__leftele637__, (int)__rightele638__);
1138       }
1139     }
1140   }
1141 }
1142
1143
1144 // build rule11
1145 {
1146   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1147     int __i__ = (int) __i___iterator->next();
1148     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1149       int __itb__ = (int) __itb___iterator->next();
1150       int __tempvar691__ = 0;
1151       int __tempvar692__ = 11;
1152       for (int __j__ = __tempvar691__; __j__ <= __tempvar692__; __j__++) {
1153         //cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks && !cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0
1154         // __left696__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1155         // __left697__ <-- cast(__InodeTable__, d.b[itb])
1156         // __left699__ <-- d
1157         int __left699__ = (int) d;
1158         // __left699__ = d
1159         // __offsetinbits700__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1160         int __leftop701__ = 0;
1161         int __leftop705__ = 8;
1162         // __left707__ <-- d.s
1163         // __left708__ <-- d
1164         int __left708__ = (int) d;
1165         // __left708__ = d
1166         int __left707__ = (__left708__ + 0);
1167         // __left707__ = d.s
1168         // __offsetinbits709__ <-- 32 + 32 + 32 + 32 + 32 + 0
1169         int __leftop710__ = 32;
1170         int __leftop712__ = 32;
1171         int __leftop714__ = 32;
1172         int __leftop716__ = 32;
1173         int __leftop718__ = 32;
1174         int __rightop719__ = 0;
1175         int __rightop717__ = __leftop718__ + __rightop719__;
1176         int __rightop715__ = __leftop716__ + __rightop717__;
1177         int __rightop713__ = __leftop714__ + __rightop715__;
1178         int __rightop711__ = __leftop712__ + __rightop713__;
1179         int __offsetinbits709__ = __leftop710__ + __rightop711__;
1180         // __offsetinbits709__ = 32 + 32 + 32 + 32 + 32 + 0
1181         int __offset720__ = __offsetinbits709__ >> 3;
1182         int __shift721__ = __offsetinbits709__ - (__offset720__ << 3);
1183         int __rightop706__ = ((*(int *)(__left707__ + __offset720__))  >> __shift721__) & 0xffffffff;
1184         int __leftop704__ = __leftop705__ * __rightop706__;
1185         int __rightop722__ = 0;
1186         int __leftop703__ = __leftop704__ + __rightop722__;
1187         int __rightop723__ = (int) __itb__;
1188         int __rightop702__ = __leftop703__ * __rightop723__;
1189         int __offsetinbits700__ = __leftop701__ + __rightop702__;
1190         // __offsetinbits700__ = 0 + 8 * d.s.blocksize + 0 * itb
1191         int __offset724__ = __offsetinbits700__ >> 3;
1192         int __expr698__ = (__left699__ + __offset724__);
1193         int __left697__ = (int) __expr698__;
1194         // __left697__ = cast(__InodeTable__, d.b[itb])
1195         // __offsetinbits725__ <-- 0 + 32 + 32 * 12 + 32 + 0 * i
1196         int __leftop726__ = 0;
1197         int __leftop729__ = 32;
1198         int __leftop732__ = 32;
1199         int __rightop733__ = 12;
1200         int __leftop731__ = __leftop732__ * __rightop733__;
1201         int __leftop735__ = 32;
1202         int __rightop736__ = 0;
1203         int __rightop734__ = __leftop735__ + __rightop736__;
1204         int __rightop730__ = __leftop731__ + __rightop734__;
1205         int __leftop728__ = __leftop729__ + __rightop730__;
1206         int __rightop737__ = (int) __i__;
1207         int __rightop727__ = __leftop728__ * __rightop737__;
1208         int __offsetinbits725__ = __leftop726__ + __rightop727__;
1209         // __offsetinbits725__ = 0 + 32 + 32 * 12 + 32 + 0 * i
1210         int __offset738__ = __offsetinbits725__ >> 3;
1211         int __left696__ = (__left697__ + __offset738__);
1212         // __left696__ = cast(__InodeTable__, d.b[itb]).itable[i]
1213         // __offsetinbits739__ <-- 32 + 0 + 32 * j
1214         int __leftop741__ = 32;
1215         int __rightop742__ = 0;
1216         int __leftop740__ = __leftop741__ + __rightop742__;
1217         int __leftop744__ = 32;
1218         int __rightop745__ = (int) __j__;
1219         int __rightop743__ = __leftop744__ * __rightop745__;
1220         int __offsetinbits739__ = __leftop740__ + __rightop743__;
1221         // __offsetinbits739__ = 32 + 0 + 32 * j
1222         int __offset746__ = __offsetinbits739__ >> 3;
1223         int __shift747__ = __offsetinbits739__ - (__offset746__ << 3);
1224         int __leftop695__ = ((*(int *)(__left696__ + __offset746__))  >> __shift747__) & 0xffffffff;
1225         // __left749__ <-- d.s
1226         // __left750__ <-- d
1227         int __left750__ = (int) d;
1228         // __left750__ = d
1229         int __left749__ = (__left750__ + 0);
1230         // __left749__ = d.s
1231         // __offsetinbits751__ <-- 32 + 32 + 0
1232         int __leftop752__ = 32;
1233         int __leftop754__ = 32;
1234         int __rightop755__ = 0;
1235         int __rightop753__ = __leftop754__ + __rightop755__;
1236         int __offsetinbits751__ = __leftop752__ + __rightop753__;
1237         // __offsetinbits751__ = 32 + 32 + 0
1238         int __offset756__ = __offsetinbits751__ >> 3;
1239         int __shift757__ = __offsetinbits751__ - (__offset756__ << 3);
1240         int __rightop748__ = ((*(int *)(__left749__ + __offset756__))  >> __shift757__) & 0xffffffff;
1241         int __leftop694__ = __leftop695__ < __rightop748__;
1242         // __left761__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1243         // __left762__ <-- cast(__InodeTable__, d.b[itb])
1244         // __left764__ <-- d
1245         int __left764__ = (int) d;
1246         // __left764__ = d
1247         // __offsetinbits765__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1248         int __leftop766__ = 0;
1249         int __leftop770__ = 8;
1250         // __left772__ <-- d.s
1251         // __left773__ <-- d
1252         int __left773__ = (int) d;
1253         // __left773__ = d
1254         int __left772__ = (__left773__ + 0);
1255         // __left772__ = d.s
1256         // __offsetinbits774__ <-- 32 + 32 + 32 + 32 + 32 + 0
1257         int __leftop775__ = 32;
1258         int __leftop777__ = 32;
1259         int __leftop779__ = 32;
1260         int __leftop781__ = 32;
1261         int __leftop783__ = 32;
1262         int __rightop784__ = 0;
1263         int __rightop782__ = __leftop783__ + __rightop784__;
1264         int __rightop780__ = __leftop781__ + __rightop782__;
1265         int __rightop778__ = __leftop779__ + __rightop780__;
1266         int __rightop776__ = __leftop777__ + __rightop778__;
1267         int __offsetinbits774__ = __leftop775__ + __rightop776__;
1268         // __offsetinbits774__ = 32 + 32 + 32 + 32 + 32 + 0
1269         int __offset785__ = __offsetinbits774__ >> 3;
1270         int __shift786__ = __offsetinbits774__ - (__offset785__ << 3);
1271         int __rightop771__ = ((*(int *)(__left772__ + __offset785__))  >> __shift786__) & 0xffffffff;
1272         int __leftop769__ = __leftop770__ * __rightop771__;
1273         int __rightop787__ = 0;
1274         int __leftop768__ = __leftop769__ + __rightop787__;
1275         int __rightop788__ = (int) __itb__;
1276         int __rightop767__ = __leftop768__ * __rightop788__;
1277         int __offsetinbits765__ = __leftop766__ + __rightop767__;
1278         // __offsetinbits765__ = 0 + 8 * d.s.blocksize + 0 * itb
1279         int __offset789__ = __offsetinbits765__ >> 3;
1280         int __expr763__ = (__left764__ + __offset789__);
1281         int __left762__ = (int) __expr763__;
1282         // __left762__ = cast(__InodeTable__, d.b[itb])
1283         // __offsetinbits790__ <-- 0 + 32 + 32 * 12 + 32 + 0 * i
1284         int __leftop791__ = 0;
1285         int __leftop794__ = 32;
1286         int __leftop797__ = 32;
1287         int __rightop798__ = 12;
1288         int __leftop796__ = __leftop797__ * __rightop798__;
1289         int __leftop800__ = 32;
1290         int __rightop801__ = 0;
1291         int __rightop799__ = __leftop800__ + __rightop801__;
1292         int __rightop795__ = __leftop796__ + __rightop799__;
1293         int __leftop793__ = __leftop794__ + __rightop795__;
1294         int __rightop802__ = (int) __i__;
1295         int __rightop792__ = __leftop793__ * __rightop802__;
1296         int __offsetinbits790__ = __leftop791__ + __rightop792__;
1297         // __offsetinbits790__ = 0 + 32 + 32 * 12 + 32 + 0 * i
1298         int __offset803__ = __offsetinbits790__ >> 3;
1299         int __left761__ = (__left762__ + __offset803__);
1300         // __left761__ = cast(__InodeTable__, d.b[itb]).itable[i]
1301         // __offsetinbits804__ <-- 32 + 0 + 32 * j
1302         int __leftop806__ = 32;
1303         int __rightop807__ = 0;
1304         int __leftop805__ = __leftop806__ + __rightop807__;
1305         int __leftop809__ = 32;
1306         int __rightop810__ = (int) __j__;
1307         int __rightop808__ = __leftop809__ * __rightop810__;
1308         int __offsetinbits804__ = __leftop805__ + __rightop808__;
1309         // __offsetinbits804__ = 32 + 0 + 32 * j
1310         int __offset811__ = __offsetinbits804__ >> 3;
1311         int __shift812__ = __offsetinbits804__ - (__offset811__ << 3);
1312         int __leftop760__ = ((*(int *)(__left761__ + __offset811__))  >> __shift812__) & 0xffffffff;
1313         int __rightop813__ = 0;
1314         int __leftop759__ = __leftop760__ == __rightop813__;
1315         int __rightop758__ = !__leftop759__;
1316         int __tempvar693__ = __leftop694__ && __rightop758__;
1317         if (__tempvar693__) {
1318           // __left815__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1319           // __left816__ <-- cast(__InodeTable__, d.b[itb])
1320           // __left818__ <-- d
1321           int __left818__ = (int) d;
1322           // __left818__ = d
1323           // __offsetinbits819__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1324           int __leftop820__ = 0;
1325           int __leftop824__ = 8;
1326           // __left826__ <-- d.s
1327           // __left827__ <-- d
1328           int __left827__ = (int) d;
1329           // __left827__ = d
1330           int __left826__ = (__left827__ + 0);
1331           // __left826__ = d.s
1332           // __offsetinbits828__ <-- 32 + 32 + 32 + 32 + 32 + 0
1333           int __leftop829__ = 32;
1334           int __leftop831__ = 32;
1335           int __leftop833__ = 32;
1336           int __leftop835__ = 32;
1337           int __leftop837__ = 32;
1338           int __rightop838__ = 0;
1339           int __rightop836__ = __leftop837__ + __rightop838__;
1340           int __rightop834__ = __leftop835__ + __rightop836__;
1341           int __rightop832__ = __leftop833__ + __rightop834__;
1342           int __rightop830__ = __leftop831__ + __rightop832__;
1343           int __offsetinbits828__ = __leftop829__ + __rightop830__;
1344           // __offsetinbits828__ = 32 + 32 + 32 + 32 + 32 + 0
1345           int __offset839__ = __offsetinbits828__ >> 3;
1346           int __shift840__ = __offsetinbits828__ - (__offset839__ << 3);
1347           int __rightop825__ = ((*(int *)(__left826__ + __offset839__))  >> __shift840__) & 0xffffffff;
1348           int __leftop823__ = __leftop824__ * __rightop825__;
1349           int __rightop841__ = 0;
1350           int __leftop822__ = __leftop823__ + __rightop841__;
1351           int __rightop842__ = (int) __itb__;
1352           int __rightop821__ = __leftop822__ * __rightop842__;
1353           int __offsetinbits819__ = __leftop820__ + __rightop821__;
1354           // __offsetinbits819__ = 0 + 8 * d.s.blocksize + 0 * itb
1355           int __offset843__ = __offsetinbits819__ >> 3;
1356           int __expr817__ = (__left818__ + __offset843__);
1357           int __left816__ = (int) __expr817__;
1358           // __left816__ = cast(__InodeTable__, d.b[itb])
1359           // __offsetinbits844__ <-- 0 + 32 + 32 * 12 + 32 + 0 * i
1360           int __leftop845__ = 0;
1361           int __leftop848__ = 32;
1362           int __leftop851__ = 32;
1363           int __rightop852__ = 12;
1364           int __leftop850__ = __leftop851__ * __rightop852__;
1365           int __leftop854__ = 32;
1366           int __rightop855__ = 0;
1367           int __rightop853__ = __leftop854__ + __rightop855__;
1368           int __rightop849__ = __leftop850__ + __rightop853__;
1369           int __leftop847__ = __leftop848__ + __rightop849__;
1370           int __rightop856__ = (int) __i__;
1371           int __rightop846__ = __leftop847__ * __rightop856__;
1372           int __offsetinbits844__ = __leftop845__ + __rightop846__;
1373           // __offsetinbits844__ = 0 + 32 + 32 * 12 + 32 + 0 * i
1374           int __offset857__ = __offsetinbits844__ >> 3;
1375           int __left815__ = (__left816__ + __offset857__);
1376           // __left815__ = cast(__InodeTable__, d.b[itb]).itable[i]
1377           // __offsetinbits858__ <-- 32 + 0 + 32 * j
1378           int __leftop860__ = 32;
1379           int __rightop861__ = 0;
1380           int __leftop859__ = __leftop860__ + __rightop861__;
1381           int __leftop863__ = 32;
1382           int __rightop864__ = (int) __j__;
1383           int __rightop862__ = __leftop863__ * __rightop864__;
1384           int __offsetinbits858__ = __leftop859__ + __rightop862__;
1385           // __offsetinbits858__ = 32 + 0 + 32 * j
1386           int __offset865__ = __offsetinbits858__ >> 3;
1387           int __shift866__ = __offsetinbits858__ - (__offset865__ << 3);
1388           int __element814__ = ((*(int *)(__left815__ + __offset865__))  >> __shift866__) & 0xffffffff;
1389           __FileBlock___hash->add((int)__element814__, (int)__element814__);
1390         }
1391       }
1392     }
1393   }
1394 }
1395
1396
1397 // build rule8
1398 {
1399   int __tempvar867__ = 0;
1400   // __left870__ <-- d.s
1401   // __left871__ <-- d
1402   int __left871__ = (int) d;
1403   // __left871__ = d
1404   int __left870__ = (__left871__ + 0);
1405   // __left870__ = d.s
1406   // __offsetinbits872__ <-- 32 + 32 + 0
1407   int __leftop873__ = 32;
1408   int __leftop875__ = 32;
1409   int __rightop876__ = 0;
1410   int __rightop874__ = __leftop875__ + __rightop876__;
1411   int __offsetinbits872__ = __leftop873__ + __rightop874__;
1412   // __offsetinbits872__ = 32 + 32 + 0
1413   int __offset877__ = __offsetinbits872__ >> 3;
1414   int __shift878__ = __offsetinbits872__ - (__offset877__ << 3);
1415   int __leftop869__ = ((*(int *)(__left870__ + __offset877__))  >> __shift878__) & 0xffffffff;
1416   int __rightop879__ = 1;
1417   int __tempvar868__ = __leftop869__ - __rightop879__;
1418   for (int __j__ = __tempvar867__; __j__ <= __tempvar868__; __j__++) {
1419     //!j in? __UsedBlock__
1420     int __element882__ = (int) __j__;
1421     int __leftop881__ = __UsedBlock___hash->contains(__element882__);
1422     int __tempvar880__ = !__leftop881__;
1423     if (__tempvar880__) {
1424       int __element883__ = (int) __j__;
1425       __FreeBlock___hash->add((int)__element883__, (int)__element883__);
1426     }
1427   }
1428 }
1429
1430
1431 // build rule10
1432 {
1433   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1434     int __i__ = (int) __i___iterator->next();
1435     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1436       int __itb__ = (int) __itb___iterator->next();
1437       int __tempvar884__ = 0;
1438       int __tempvar885__ = 11;
1439       for (int __j__ = __tempvar884__; __j__ <= __tempvar885__; __j__++) {
1440         //!cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0
1441         // __left889__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1442         // __left890__ <-- cast(__InodeTable__, d.b[itb])
1443         // __left892__ <-- d
1444         int __left892__ = (int) d;
1445         // __left892__ = d
1446         // __offsetinbits893__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1447         int __leftop894__ = 0;
1448         int __leftop898__ = 8;
1449         // __left900__ <-- d.s
1450         // __left901__ <-- d
1451         int __left901__ = (int) d;
1452         // __left901__ = d
1453         int __left900__ = (__left901__ + 0);
1454         // __left900__ = d.s
1455         // __offsetinbits902__ <-- 32 + 32 + 32 + 32 + 32 + 0
1456         int __leftop903__ = 32;
1457         int __leftop905__ = 32;
1458         int __leftop907__ = 32;
1459         int __leftop909__ = 32;
1460         int __leftop911__ = 32;
1461         int __rightop912__ = 0;
1462         int __rightop910__ = __leftop911__ + __rightop912__;
1463         int __rightop908__ = __leftop909__ + __rightop910__;
1464         int __rightop906__ = __leftop907__ + __rightop908__;
1465         int __rightop904__ = __leftop905__ + __rightop906__;
1466         int __offsetinbits902__ = __leftop903__ + __rightop904__;
1467         // __offsetinbits902__ = 32 + 32 + 32 + 32 + 32 + 0
1468         int __offset913__ = __offsetinbits902__ >> 3;
1469         int __shift914__ = __offsetinbits902__ - (__offset913__ << 3);
1470         int __rightop899__ = ((*(int *)(__left900__ + __offset913__))  >> __shift914__) & 0xffffffff;
1471         int __leftop897__ = __leftop898__ * __rightop899__;
1472         int __rightop915__ = 0;
1473         int __leftop896__ = __leftop897__ + __rightop915__;
1474         int __rightop916__ = (int) __itb__;
1475         int __rightop895__ = __leftop896__ * __rightop916__;
1476         int __offsetinbits893__ = __leftop894__ + __rightop895__;
1477         // __offsetinbits893__ = 0 + 8 * d.s.blocksize + 0 * itb
1478         int __offset917__ = __offsetinbits893__ >> 3;
1479         int __expr891__ = (__left892__ + __offset917__);
1480         int __left890__ = (int) __expr891__;
1481         // __left890__ = cast(__InodeTable__, d.b[itb])
1482         // __offsetinbits918__ <-- 0 + 32 + 32 * 12 + 32 + 0 * i
1483         int __leftop919__ = 0;
1484         int __leftop922__ = 32;
1485         int __leftop925__ = 32;
1486         int __rightop926__ = 12;
1487         int __leftop924__ = __leftop925__ * __rightop926__;
1488         int __leftop928__ = 32;
1489         int __rightop929__ = 0;
1490         int __rightop927__ = __leftop928__ + __rightop929__;
1491         int __rightop923__ = __leftop924__ + __rightop927__;
1492         int __leftop921__ = __leftop922__ + __rightop923__;
1493         int __rightop930__ = (int) __i__;
1494         int __rightop920__ = __leftop921__ * __rightop930__;
1495         int __offsetinbits918__ = __leftop919__ + __rightop920__;
1496         // __offsetinbits918__ = 0 + 32 + 32 * 12 + 32 + 0 * i
1497         int __offset931__ = __offsetinbits918__ >> 3;
1498         int __left889__ = (__left890__ + __offset931__);
1499         // __left889__ = cast(__InodeTable__, d.b[itb]).itable[i]
1500         // __offsetinbits932__ <-- 32 + 0 + 32 * j
1501         int __leftop934__ = 32;
1502         int __rightop935__ = 0;
1503         int __leftop933__ = __leftop934__ + __rightop935__;
1504         int __leftop937__ = 32;
1505         int __rightop938__ = (int) __j__;
1506         int __rightop936__ = __leftop937__ * __rightop938__;
1507         int __offsetinbits932__ = __leftop933__ + __rightop936__;
1508         // __offsetinbits932__ = 32 + 0 + 32 * j
1509         int __offset939__ = __offsetinbits932__ >> 3;
1510         int __shift940__ = __offsetinbits932__ - (__offset939__ << 3);
1511         int __leftop888__ = ((*(int *)(__left889__ + __offset939__))  >> __shift940__) & 0xffffffff;
1512         int __rightop941__ = 0;
1513         int __leftop887__ = __leftop888__ == __rightop941__;
1514         int __tempvar886__ = !__leftop887__;
1515         if (__tempvar886__) {
1516           int __leftele942__ = (int) __i__;
1517           // __left944__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1518           // __left945__ <-- cast(__InodeTable__, d.b[itb])
1519           // __left947__ <-- d
1520           int __left947__ = (int) d;
1521           // __left947__ = d
1522           // __offsetinbits948__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1523           int __leftop949__ = 0;
1524           int __leftop953__ = 8;
1525           // __left955__ <-- d.s
1526           // __left956__ <-- d
1527           int __left956__ = (int) d;
1528           // __left956__ = d
1529           int __left955__ = (__left956__ + 0);
1530           // __left955__ = d.s
1531           // __offsetinbits957__ <-- 32 + 32 + 32 + 32 + 32 + 0
1532           int __leftop958__ = 32;
1533           int __leftop960__ = 32;
1534           int __leftop962__ = 32;
1535           int __leftop964__ = 32;
1536           int __leftop966__ = 32;
1537           int __rightop967__ = 0;
1538           int __rightop965__ = __leftop966__ + __rightop967__;
1539           int __rightop963__ = __leftop964__ + __rightop965__;
1540           int __rightop961__ = __leftop962__ + __rightop963__;
1541           int __rightop959__ = __leftop960__ + __rightop961__;
1542           int __offsetinbits957__ = __leftop958__ + __rightop959__;
1543           // __offsetinbits957__ = 32 + 32 + 32 + 32 + 32 + 0
1544           int __offset968__ = __offsetinbits957__ >> 3;
1545           int __shift969__ = __offsetinbits957__ - (__offset968__ << 3);
1546           int __rightop954__ = ((*(int *)(__left955__ + __offset968__))  >> __shift969__) & 0xffffffff;
1547           int __leftop952__ = __leftop953__ * __rightop954__;
1548           int __rightop970__ = 0;
1549           int __leftop951__ = __leftop952__ + __rightop970__;
1550           int __rightop971__ = (int) __itb__;
1551           int __rightop950__ = __leftop951__ * __rightop971__;
1552           int __offsetinbits948__ = __leftop949__ + __rightop950__;
1553           // __offsetinbits948__ = 0 + 8 * d.s.blocksize + 0 * itb
1554           int __offset972__ = __offsetinbits948__ >> 3;
1555           int __expr946__ = (__left947__ + __offset972__);
1556           int __left945__ = (int) __expr946__;
1557           // __left945__ = cast(__InodeTable__, d.b[itb])
1558           // __offsetinbits973__ <-- 0 + 32 + 32 * 12 + 32 + 0 * i
1559           int __leftop974__ = 0;
1560           int __leftop977__ = 32;
1561           int __leftop980__ = 32;
1562           int __rightop981__ = 12;
1563           int __leftop979__ = __leftop980__ * __rightop981__;
1564           int __leftop983__ = 32;
1565           int __rightop984__ = 0;
1566           int __rightop982__ = __leftop983__ + __rightop984__;
1567           int __rightop978__ = __leftop979__ + __rightop982__;
1568           int __leftop976__ = __leftop977__ + __rightop978__;
1569           int __rightop985__ = (int) __i__;
1570           int __rightop975__ = __leftop976__ * __rightop985__;
1571           int __offsetinbits973__ = __leftop974__ + __rightop975__;
1572           // __offsetinbits973__ = 0 + 32 + 32 * 12 + 32 + 0 * i
1573           int __offset986__ = __offsetinbits973__ >> 3;
1574           int __left944__ = (__left945__ + __offset986__);
1575           // __left944__ = cast(__InodeTable__, d.b[itb]).itable[i]
1576           // __offsetinbits987__ <-- 32 + 0 + 32 * j
1577           int __leftop989__ = 32;
1578           int __rightop990__ = 0;
1579           int __leftop988__ = __leftop989__ + __rightop990__;
1580           int __leftop992__ = 32;
1581           int __rightop993__ = (int) __j__;
1582           int __rightop991__ = __leftop992__ * __rightop993__;
1583           int __offsetinbits987__ = __leftop988__ + __rightop991__;
1584           // __offsetinbits987__ = 32 + 0 + 32 * j
1585           int __offset994__ = __offsetinbits987__ >> 3;
1586           int __shift995__ = __offsetinbits987__ - (__offset994__ << 3);
1587           int __rightele943__ = ((*(int *)(__left944__ + __offset994__))  >> __shift995__) & 0xffffffff;
1588           __contents___hash->add((int)__leftele942__, (int)__rightele943__);
1589         }
1590       }
1591     }
1592   }
1593 }
1594
1595
1596 // build rule7
1597 {
1598   int __tempvar996__ = 0;
1599   // __left999__ <-- d.s
1600   // __left1000__ <-- d
1601   int __left1000__ = (int) d;
1602   // __left1000__ = d
1603   int __left999__ = (__left1000__ + 0);
1604   // __left999__ = d.s
1605   // __offsetinbits1001__ <-- 32 + 32 + 32 + 0
1606   int __leftop1002__ = 32;
1607   int __leftop1004__ = 32;
1608   int __leftop1006__ = 32;
1609   int __rightop1007__ = 0;
1610   int __rightop1005__ = __leftop1006__ + __rightop1007__;
1611   int __rightop1003__ = __leftop1004__ + __rightop1005__;
1612   int __offsetinbits1001__ = __leftop1002__ + __rightop1003__;
1613   // __offsetinbits1001__ = 32 + 32 + 32 + 0
1614   int __offset1008__ = __offsetinbits1001__ >> 3;
1615   int __shift1009__ = __offsetinbits1001__ - (__offset1008__ << 3);
1616   int __leftop998__ = ((*(int *)(__left999__ + __offset1008__))  >> __shift1009__) & 0xffffffff;
1617   int __rightop1010__ = 1;
1618   int __tempvar997__ = __leftop998__ - __rightop1010__;
1619   for (int __j__ = __tempvar996__; __j__ <= __tempvar997__; __j__++) {
1620     //!j in? __UsedInode__
1621     int __element1013__ = (int) __j__;
1622     int __leftop1012__ = __UsedInode___hash->contains(__element1013__);
1623     int __tempvar1011__ = !__leftop1012__;
1624     if (__tempvar1011__) {
1625       int __element1014__ = (int) __j__;
1626       __FreeInode___hash->add((int)__element1014__, (int)__element1014__);
1627     }
1628   }
1629 }
1630
1631
1632 // build rule17
1633 {
1634   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); ) {
1635     int __j__ = (int) __j___iterator->next();
1636     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1637       int __itb__ = (int) __itb___iterator->next();
1638       //true
1639       int __tempvar1015__ = 1;
1640       if (__tempvar1015__) {
1641         int __leftele1016__ = (int) __j__;
1642         // __left1018__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1643         // __left1019__ <-- cast(__InodeTable__, d.b[itb])
1644         // __left1021__ <-- d
1645         int __left1021__ = (int) d;
1646         // __left1021__ = d
1647         // __offsetinbits1022__ <-- 0 + 8 * d.s.blocksize + 0 * itb
1648         int __leftop1023__ = 0;
1649         int __leftop1027__ = 8;
1650         // __left1029__ <-- d.s
1651         // __left1030__ <-- d
1652         int __left1030__ = (int) d;
1653         // __left1030__ = d
1654         int __left1029__ = (__left1030__ + 0);
1655         // __left1029__ = d.s
1656         // __offsetinbits1031__ <-- 32 + 32 + 32 + 32 + 32 + 0
1657         int __leftop1032__ = 32;
1658         int __leftop1034__ = 32;
1659         int __leftop1036__ = 32;
1660         int __leftop1038__ = 32;
1661         int __leftop1040__ = 32;
1662         int __rightop1041__ = 0;
1663         int __rightop1039__ = __leftop1040__ + __rightop1041__;
1664         int __rightop1037__ = __leftop1038__ + __rightop1039__;
1665         int __rightop1035__ = __leftop1036__ + __rightop1037__;
1666         int __rightop1033__ = __leftop1034__ + __rightop1035__;
1667         int __offsetinbits1031__ = __leftop1032__ + __rightop1033__;
1668         // __offsetinbits1031__ = 32 + 32 + 32 + 32 + 32 + 0
1669         int __offset1042__ = __offsetinbits1031__ >> 3;
1670         int __shift1043__ = __offsetinbits1031__ - (__offset1042__ << 3);
1671         int __rightop1028__ = ((*(int *)(__left1029__ + __offset1042__))  >> __shift1043__) & 0xffffffff;
1672         int __leftop1026__ = __leftop1027__ * __rightop1028__;
1673         int __rightop1044__ = 0;
1674         int __leftop1025__ = __leftop1026__ + __rightop1044__;
1675         int __rightop1045__ = (int) __itb__;
1676         int __rightop1024__ = __leftop1025__ * __rightop1045__;
1677         int __offsetinbits1022__ = __leftop1023__ + __rightop1024__;
1678         // __offsetinbits1022__ = 0 + 8 * d.s.blocksize + 0 * itb
1679         int __offset1046__ = __offsetinbits1022__ >> 3;
1680         int __expr1020__ = (__left1021__ + __offset1046__);
1681         int __left1019__ = (int) __expr1020__;
1682         // __left1019__ = cast(__InodeTable__, d.b[itb])
1683         // __offsetinbits1047__ <-- 0 + 32 + 32 * 12 + 32 + 0 * j
1684         int __leftop1048__ = 0;
1685         int __leftop1051__ = 32;
1686         int __leftop1054__ = 32;
1687         int __rightop1055__ = 12;
1688         int __leftop1053__ = __leftop1054__ * __rightop1055__;
1689         int __leftop1057__ = 32;
1690         int __rightop1058__ = 0;
1691         int __rightop1056__ = __leftop1057__ + __rightop1058__;
1692         int __rightop1052__ = __leftop1053__ + __rightop1056__;
1693         int __leftop1050__ = __leftop1051__ + __rightop1052__;
1694         int __rightop1059__ = (int) __j__;
1695         int __rightop1049__ = __leftop1050__ * __rightop1059__;
1696         int __offsetinbits1047__ = __leftop1048__ + __rightop1049__;
1697         // __offsetinbits1047__ = 0 + 32 + 32 * 12 + 32 + 0 * j
1698         int __offset1060__ = __offsetinbits1047__ >> 3;
1699         int __left1018__ = (__left1019__ + __offset1060__);
1700         // __left1018__ = cast(__InodeTable__, d.b[itb]).itable[j]
1701         int __rightele1017__ = ((*(int *)(__left1018__ + 0))  >> 0) & 0xffffffff;
1702         __filesize___hash->add((int)__leftele1016__, (int)__rightele1017__);
1703       }
1704     }
1705   }
1706 }
1707
1708
1709 // build rule18
1710 {
1711   int __tempvar1061__ = 0;
1712   // __left1064__ <-- d.s
1713   // __left1065__ <-- d
1714   int __left1065__ = (int) d;
1715   // __left1065__ = d
1716   int __left1064__ = (__left1065__ + 0);
1717   // __left1064__ = d.s
1718   // __offsetinbits1066__ <-- 32 + 32 + 0
1719   int __leftop1067__ = 32;
1720   int __leftop1069__ = 32;
1721   int __rightop1070__ = 0;
1722   int __rightop1068__ = __leftop1069__ + __rightop1070__;
1723   int __offsetinbits1066__ = __leftop1067__ + __rightop1068__;
1724   // __offsetinbits1066__ = 32 + 32 + 0
1725   int __offset1071__ = __offsetinbits1066__ >> 3;
1726   int __shift1072__ = __offsetinbits1066__ - (__offset1071__ << 3);
1727   int __leftop1063__ = ((*(int *)(__left1064__ + __offset1071__))  >> __shift1072__) & 0xffffffff;
1728   int __rightop1073__ = 1;
1729   int __tempvar1062__ = __leftop1063__ - __rightop1073__;
1730   for (int __j__ = __tempvar1061__; __j__ <= __tempvar1062__; __j__++) {
1731     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); ) {
1732       int __bbb__ = (int) __bbb___iterator->next();
1733       //cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == {false = 107}
1734       // __left1076__ <-- cast(__BlockBitmap__, d.b[bbb])
1735       // __left1078__ <-- d
1736       int __left1078__ = (int) d;
1737       // __left1078__ = d
1738       // __offsetinbits1079__ <-- 0 + 8 * d.s.blocksize + 0 * bbb
1739       int __leftop1080__ = 0;
1740       int __leftop1084__ = 8;
1741       // __left1086__ <-- d.s
1742       // __left1087__ <-- d
1743       int __left1087__ = (int) d;
1744       // __left1087__ = d
1745       int __left1086__ = (__left1087__ + 0);
1746       // __left1086__ = d.s
1747       // __offsetinbits1088__ <-- 32 + 32 + 32 + 32 + 32 + 0
1748       int __leftop1089__ = 32;
1749       int __leftop1091__ = 32;
1750       int __leftop1093__ = 32;
1751       int __leftop1095__ = 32;
1752       int __leftop1097__ = 32;
1753       int __rightop1098__ = 0;
1754       int __rightop1096__ = __leftop1097__ + __rightop1098__;
1755       int __rightop1094__ = __leftop1095__ + __rightop1096__;
1756       int __rightop1092__ = __leftop1093__ + __rightop1094__;
1757       int __rightop1090__ = __leftop1091__ + __rightop1092__;
1758       int __offsetinbits1088__ = __leftop1089__ + __rightop1090__;
1759       // __offsetinbits1088__ = 32 + 32 + 32 + 32 + 32 + 0
1760       int __offset1099__ = __offsetinbits1088__ >> 3;
1761       int __shift1100__ = __offsetinbits1088__ - (__offset1099__ << 3);
1762       int __rightop1085__ = ((*(int *)(__left1086__ + __offset1099__))  >> __shift1100__) & 0xffffffff;
1763       int __leftop1083__ = __leftop1084__ * __rightop1085__;
1764       int __rightop1101__ = 0;
1765       int __leftop1082__ = __leftop1083__ + __rightop1101__;
1766       int __rightop1102__ = (int) __bbb__;
1767       int __rightop1081__ = __leftop1082__ * __rightop1102__;
1768       int __offsetinbits1079__ = __leftop1080__ + __rightop1081__;
1769       // __offsetinbits1079__ = 0 + 8 * d.s.blocksize + 0 * bbb
1770       int __offset1103__ = __offsetinbits1079__ >> 3;
1771       int __expr1077__ = (__left1078__ + __offset1103__);
1772       int __left1076__ = (int) __expr1077__;
1773       // __left1076__ = cast(__BlockBitmap__, d.b[bbb])
1774       // __offsetinbits1104__ <-- 0 + 1 * j
1775       int __leftop1105__ = 0;
1776       int __leftop1107__ = 1;
1777       int __rightop1108__ = (int) __j__;
1778       int __rightop1106__ = __leftop1107__ * __rightop1108__;
1779       int __offsetinbits1104__ = __leftop1105__ + __rightop1106__;
1780       // __offsetinbits1104__ = 0 + 1 * j
1781       int __offset1109__ = __offsetinbits1104__ >> 3;
1782       int __shift1110__ = __offsetinbits1104__ - (__offset1109__ << 3);
1783       int __leftop1075__ = ((*(int *)(__left1076__ + __offset1109__))  >> __shift1110__) & 0x1;
1784       int __rightop1111__ = 107;
1785       int __tempvar1074__ = __leftop1075__ == __rightop1111__;
1786       if (__tempvar1074__) {
1787         int __leftele1112__ = (int) __j__;
1788         int __rightele1113__ = 108;
1789         __blockstatus___hash->add((int)__leftele1112__, (int)__rightele1113__);
1790       }
1791     }
1792   }
1793 }
1794
1795
1796 // build rule19
1797 {
1798   int __tempvar1114__ = 0;
1799   // __left1117__ <-- d.s
1800   // __left1118__ <-- d
1801   int __left1118__ = (int) d;
1802   // __left1118__ = d
1803   int __left1117__ = (__left1118__ + 0);
1804   // __left1117__ = d.s
1805   // __offsetinbits1119__ <-- 32 + 32 + 0
1806   int __leftop1120__ = 32;
1807   int __leftop1122__ = 32;
1808   int __rightop1123__ = 0;
1809   int __rightop1121__ = __leftop1122__ + __rightop1123__;
1810   int __offsetinbits1119__ = __leftop1120__ + __rightop1121__;
1811   // __offsetinbits1119__ = 32 + 32 + 0
1812   int __offset1124__ = __offsetinbits1119__ >> 3;
1813   int __shift1125__ = __offsetinbits1119__ - (__offset1124__ << 3);
1814   int __leftop1116__ = ((*(int *)(__left1117__ + __offset1124__))  >> __shift1125__) & 0xffffffff;
1815   int __rightop1126__ = 1;
1816   int __tempvar1115__ = __leftop1116__ - __rightop1126__;
1817   for (int __j__ = __tempvar1114__; __j__ <= __tempvar1115__; __j__++) {
1818     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); ) {
1819       int __bbb__ = (int) __bbb___iterator->next();
1820       //cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == true
1821       // __left1129__ <-- cast(__BlockBitmap__, d.b[bbb])
1822       // __left1131__ <-- d
1823       int __left1131__ = (int) d;
1824       // __left1131__ = d
1825       // __offsetinbits1132__ <-- 0 + 8 * d.s.blocksize + 0 * bbb
1826       int __leftop1133__ = 0;
1827       int __leftop1137__ = 8;
1828       // __left1139__ <-- d.s
1829       // __left1140__ <-- d
1830       int __left1140__ = (int) d;
1831       // __left1140__ = d
1832       int __left1139__ = (__left1140__ + 0);
1833       // __left1139__ = d.s
1834       // __offsetinbits1141__ <-- 32 + 32 + 32 + 32 + 32 + 0
1835       int __leftop1142__ = 32;
1836       int __leftop1144__ = 32;
1837       int __leftop1146__ = 32;
1838       int __leftop1148__ = 32;
1839       int __leftop1150__ = 32;
1840       int __rightop1151__ = 0;
1841       int __rightop1149__ = __leftop1150__ + __rightop1151__;
1842       int __rightop1147__ = __leftop1148__ + __rightop1149__;
1843       int __rightop1145__ = __leftop1146__ + __rightop1147__;
1844       int __rightop1143__ = __leftop1144__ + __rightop1145__;
1845       int __offsetinbits1141__ = __leftop1142__ + __rightop1143__;
1846       // __offsetinbits1141__ = 32 + 32 + 32 + 32 + 32 + 0
1847       int __offset1152__ = __offsetinbits1141__ >> 3;
1848       int __shift1153__ = __offsetinbits1141__ - (__offset1152__ << 3);
1849       int __rightop1138__ = ((*(int *)(__left1139__ + __offset1152__))  >> __shift1153__) & 0xffffffff;
1850       int __leftop1136__ = __leftop1137__ * __rightop1138__;
1851       int __rightop1154__ = 0;
1852       int __leftop1135__ = __leftop1136__ + __rightop1154__;
1853       int __rightop1155__ = (int) __bbb__;
1854       int __rightop1134__ = __leftop1135__ * __rightop1155__;
1855       int __offsetinbits1132__ = __leftop1133__ + __rightop1134__;
1856       // __offsetinbits1132__ = 0 + 8 * d.s.blocksize + 0 * bbb
1857       int __offset1156__ = __offsetinbits1132__ >> 3;
1858       int __expr1130__ = (__left1131__ + __offset1156__);
1859       int __left1129__ = (int) __expr1130__;
1860       // __left1129__ = cast(__BlockBitmap__, d.b[bbb])
1861       // __offsetinbits1157__ <-- 0 + 1 * j
1862       int __leftop1158__ = 0;
1863       int __leftop1160__ = 1;
1864       int __rightop1161__ = (int) __j__;
1865       int __rightop1159__ = __leftop1160__ * __rightop1161__;
1866       int __offsetinbits1157__ = __leftop1158__ + __rightop1159__;
1867       // __offsetinbits1157__ = 0 + 1 * j
1868       int __offset1162__ = __offsetinbits1157__ >> 3;
1869       int __shift1163__ = __offsetinbits1157__ - (__offset1162__ << 3);
1870       int __leftop1128__ = ((*(int *)(__left1129__ + __offset1162__))  >> __shift1163__) & 0x1;
1871       int __rightop1164__ = 1;
1872       int __tempvar1127__ = __leftop1128__ == __rightop1164__;
1873       if (__tempvar1127__) {
1874         int __leftele1165__ = (int) __j__;
1875         int __rightele1166__ = 109;
1876         __blockstatus___hash->add((int)__leftele1165__, (int)__rightele1166__);
1877       }
1878     }
1879   }
1880 }
1881
1882