Repair/RepairCompiler/MCC/test2.cc

   1
   2 // Token values
   3
   4 // Used = 100
   5 // Free = 101
   6
   7
   8 int __Success = 1;
   9
  10 // creating hashtables
  11 SimpleHash* __int___hash = new SimpleHash();
  12 SimpleHash* __FileBlock___hash = new SimpleHash();
  13 SimpleHash* __UsedBlock___hash = new SimpleHash();
  14 SimpleHash* __FileInode___hash = new SimpleHash();
  15 SimpleHash* __SuperBlock___hash = new SimpleHash();
  16 SimpleHash* __UsedInode___hash = new SimpleHash();
  17 SimpleHash* __InodeBitmapBlock___hash = new SimpleHash();
  18 SimpleHash* __BlockBitmapBlock___hash = new SimpleHash();
  19 SimpleHash* __FileDirectoryBlock___hash = new SimpleHash();
  20 SimpleHash* __token___hash = new SimpleHash();
  21 SimpleHash* __DirectoryEntry___hash = new SimpleHash();
  22 SimpleHash* __RootDirectoryInode___hash = new SimpleHash();
  23 SimpleHash* __FreeBlock___hash = new SimpleHash();
  24 SimpleHash* __GroupBlock___hash = new SimpleHash();
  25 SimpleHash* __Block___hash = new SimpleHash();
  26 SimpleHash* __DirectoryBlock___hash = new SimpleHash();
  27 SimpleHash* __FreeInode___hash = new SimpleHash();
  28 SimpleHash* __Inode___hash = new SimpleHash();
  29 SimpleHash* __DirectoryInode___hash = new SimpleHash();
  30 SimpleHash* __InodeTableBlock___hash = new SimpleHash();
  31 __SuperBlock___hash->addParent(__UsedBlock___hash);
  32 __GroupBlock___hash->addParent(__UsedBlock___hash);
  33 __FileDirectoryBlock___hash->addParent(__UsedBlock___hash);
  34 __InodeTableBlock___hash->addParent(__UsedBlock___hash);
  35 __InodeBitmapBlock___hash->addParent(__UsedBlock___hash);
  36 __BlockBitmapBlock___hash->addParent(__UsedBlock___hash);
  37 __FileInode___hash->addParent(__UsedInode___hash);
  38 __DirectoryInode___hash->addParent(__UsedInode___hash);
  39 __DirectoryBlock___hash->addParent(__FileDirectoryBlock___hash);
  40 __FileBlock___hash->addParent(__FileDirectoryBlock___hash);
  41 __UsedBlock___hash->addParent(__Block___hash);
  42 __FreeBlock___hash->addParent(__Block___hash);
  43 __UsedInode___hash->addParent(__Inode___hash);
  44 __FreeInode___hash->addParent(__Inode___hash);
  45 __RootDirectoryInode___hash->addParent(__DirectoryInode___hash);
  46 SimpleHash* __referencecount___hash = new SimpleHash();
  47 SimpleHash* __filesize___hash = new SimpleHash();
  48 SimpleHash* __inodeof___hashinv = new SimpleHash();
  49 SimpleHash* __contents___hash = new SimpleHash();
  50 SimpleHash* __contents___hashinv = new SimpleHash();
  51 SimpleHash* __inodestatus___hash = new SimpleHash();
  52 SimpleHash* __blockstatus___hash = new SimpleHash();
  53
  54
  55 // build rule1
  56   {
  57   //true
  58   int __tempvar0__ = 1;
  59   if (__tempvar0__)
  60     {
  61     int __element1__ = 0;
  62     __SuperBlock___hash->add((int)__element1__, (int)__element1__);
  63     }
  64   }
  65
  66
  67 // build rule2
  68   {
  69   //true
  70   int __tempvar2__ = 1;
  71   if (__tempvar2__)
  72     {
  73     int __element3__ = 1;
  74     __GroupBlock___hash->add((int)__element3__, (int)__element3__);
  75     }
  76   }
  77
  78
  79 // build rule3
  80   {
  81   //(d.g.InodeTableBlock < d.s.NumberofBlocks)
  82   // __left6__ <-- d.g
  83   // __left7__ <-- d
  84   int __left7__ = (int) d; //varexpr
  85   // __left7__ = d
  86   // __offsetinbits8__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
  87   int __leftop9__ = 0;
  88   int __leftop13__ = 8;
  89   // __left15__ <-- d.s
  90   // __left16__ <-- d
  91   int __left16__ = (int) d; //varexpr
  92   // __left16__ = d
  93   int __left15__ = (__left16__ + 0);
  94   int __leftop18__ = 32;
  95   int __leftop20__ = 32;
  96   int __leftop22__ = 32;
  97   int __leftop24__ = 32;
  98   int __leftop26__ = 32;
  99   int __leftop28__ = 32;
 100   int __rightop29__ = 0;
 101   int __rightop27__ = __leftop28__ + __rightop29__;
 102   int __rightop25__ = __leftop26__ + __rightop27__;
 103   int __rightop23__ = __leftop24__ + __rightop25__;
 104   int __rightop21__ = __leftop22__ + __rightop23__;
 105   int __rightop19__ = __leftop20__ + __rightop21__;
 106   int __sizeof17__ = __leftop18__ + __rightop19__;
 107   int __high30__ = __left15__ + __sizeof17__;
 108   assertvalidmemory(__left15__, __high30__);
 109   // __left15__ = d.s
 110   // __offsetinbits31__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 111   int __leftop32__ = 32;
 112   int __leftop34__ = 32;
 113   int __leftop36__ = 32;
 114   int __leftop38__ = 32;
 115   int __leftop40__ = 32;
 116   int __rightop41__ = 0;
 117   int __rightop39__ = __leftop40__ + __rightop41__;
 118   int __rightop37__ = __leftop38__ + __rightop39__;
 119   int __rightop35__ = __leftop36__ + __rightop37__;
 120   int __rightop33__ = __leftop34__ + __rightop35__;
 121   int __offsetinbits31__ = __leftop32__ + __rightop33__;
 122   // __offsetinbits31__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 123   int __offset42__ = __offsetinbits31__ >> 3;
 124   int __shift43__ = __offsetinbits31__ - (__offset42__ << 3);
 125   int __rightop14__ = ((*(int *)(__left15__ + __offset42__))  >> __shift43__) & 0xffffffff;
 126   int __leftop12__ = __leftop13__ * __rightop14__;
 127   int __rightop44__ = 0;
 128   int __leftop11__ = __leftop12__ + __rightop44__;
 129   int __rightop45__ = 1;
 130   int __rightop10__ = __leftop11__ * __rightop45__;
 131   int __offsetinbits8__ = __leftop9__ + __rightop10__;
 132   // __offsetinbits8__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 133   int __offset46__ = __offsetinbits8__ >> 3;
 134   int __left6__ = (__left7__ + __offset46__);
 135   int __leftop48__ = 32;
 136   int __leftop50__ = 32;
 137   int __leftop52__ = 32;
 138   int __leftop54__ = 32;
 139   int __leftop56__ = 32;
 140   int __rightop57__ = 0;
 141   int __rightop55__ = __leftop56__ + __rightop57__;
 142   int __rightop53__ = __leftop54__ + __rightop55__;
 143   int __rightop51__ = __leftop52__ + __rightop53__;
 144   int __rightop49__ = __leftop50__ + __rightop51__;
 145   int __sizeof47__ = __leftop48__ + __rightop49__;
 146   int __high58__ = __left6__ + __sizeof47__;
 147   assertvalidmemory(__left6__, __high58__);
 148   // __left6__ = d.g
 149   // __offsetinbits59__ <-- (32 + (32 + 0))
 150   int __leftop60__ = 32;
 151   int __leftop62__ = 32;
 152   int __rightop63__ = 0;
 153   int __rightop61__ = __leftop62__ + __rightop63__;
 154   int __offsetinbits59__ = __leftop60__ + __rightop61__;
 155   // __offsetinbits59__ = (32 + (32 + 0))
 156   int __offset64__ = __offsetinbits59__ >> 3;
 157   int __shift65__ = __offsetinbits59__ - (__offset64__ << 3);
 158   int __leftop5__ = ((*(int *)(__left6__ + __offset64__))  >> __shift65__) & 0xffffffff;
 159   // __left67__ <-- d.s
 160   // __left68__ <-- d
 161   int __left68__ = (int) d; //varexpr
 162   // __left68__ = d
 163   int __left67__ = (__left68__ + 0);
 164   int __leftop70__ = 32;
 165   int __leftop72__ = 32;
 166   int __leftop74__ = 32;
 167   int __leftop76__ = 32;
 168   int __leftop78__ = 32;
 169   int __leftop80__ = 32;
 170   int __rightop81__ = 0;
 171   int __rightop79__ = __leftop80__ + __rightop81__;
 172   int __rightop77__ = __leftop78__ + __rightop79__;
 173   int __rightop75__ = __leftop76__ + __rightop77__;
 174   int __rightop73__ = __leftop74__ + __rightop75__;
 175   int __rightop71__ = __leftop72__ + __rightop73__;
 176   int __sizeof69__ = __leftop70__ + __rightop71__;
 177   int __high82__ = __left67__ + __sizeof69__;
 178   assertvalidmemory(__left67__, __high82__);
 179   // __left67__ = d.s
 180   // __offsetinbits83__ <-- (32 + (32 + 0))
 181   int __leftop84__ = 32;
 182   int __leftop86__ = 32;
 183   int __rightop87__ = 0;
 184   int __rightop85__ = __leftop86__ + __rightop87__;
 185   int __offsetinbits83__ = __leftop84__ + __rightop85__;
 186   // __offsetinbits83__ = (32 + (32 + 0))
 187   int __offset88__ = __offsetinbits83__ >> 3;
 188   int __shift89__ = __offsetinbits83__ - (__offset88__ << 3);
 189   int __rightop66__ = ((*(int *)(__left67__ + __offset88__))  >> __shift89__) & 0xffffffff;
 190   int __tempvar4__ = __leftop5__ < __rightop66__;
 191   if (__tempvar4__)
 192     {
 193     // __left91__ <-- d.g
 194     // __left92__ <-- d
 195     int __left92__ = (int) d; //varexpr
 196     // __left92__ = d
 197     // __offsetinbits93__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 198     int __leftop94__ = 0;
 199     int __leftop98__ = 8;
 200     // __left100__ <-- d.s
 201     // __left101__ <-- d
 202     int __left101__ = (int) d; //varexpr
 203     // __left101__ = d
 204     int __left100__ = (__left101__ + 0);
 205     int __leftop103__ = 32;
 206     int __leftop105__ = 32;
 207     int __leftop107__ = 32;
 208     int __leftop109__ = 32;
 209     int __leftop111__ = 32;
 210     int __leftop113__ = 32;
 211     int __rightop114__ = 0;
 212     int __rightop112__ = __leftop113__ + __rightop114__;
 213     int __rightop110__ = __leftop111__ + __rightop112__;
 214     int __rightop108__ = __leftop109__ + __rightop110__;
 215     int __rightop106__ = __leftop107__ + __rightop108__;
 216     int __rightop104__ = __leftop105__ + __rightop106__;
 217     int __sizeof102__ = __leftop103__ + __rightop104__;
 218     int __high115__ = __left100__ + __sizeof102__;
 219     assertvalidmemory(__left100__, __high115__);
 220     // __left100__ = d.s
 221     // __offsetinbits116__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 222     int __leftop117__ = 32;
 223     int __leftop119__ = 32;
 224     int __leftop121__ = 32;
 225     int __leftop123__ = 32;
 226     int __leftop125__ = 32;
 227     int __rightop126__ = 0;
 228     int __rightop124__ = __leftop125__ + __rightop126__;
 229     int __rightop122__ = __leftop123__ + __rightop124__;
 230     int __rightop120__ = __leftop121__ + __rightop122__;
 231     int __rightop118__ = __leftop119__ + __rightop120__;
 232     int __offsetinbits116__ = __leftop117__ + __rightop118__;
 233     // __offsetinbits116__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 234     int __offset127__ = __offsetinbits116__ >> 3;
 235     int __shift128__ = __offsetinbits116__ - (__offset127__ << 3);
 236     int __rightop99__ = ((*(int *)(__left100__ + __offset127__))  >> __shift128__) & 0xffffffff;
 237     int __leftop97__ = __leftop98__ * __rightop99__;
 238     int __rightop129__ = 0;
 239     int __leftop96__ = __leftop97__ + __rightop129__;
 240     int __rightop130__ = 1;
 241     int __rightop95__ = __leftop96__ * __rightop130__;
 242     int __offsetinbits93__ = __leftop94__ + __rightop95__;
 243     // __offsetinbits93__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 244     int __offset131__ = __offsetinbits93__ >> 3;
 245     int __left91__ = (__left92__ + __offset131__);
 246     int __leftop133__ = 32;
 247     int __leftop135__ = 32;
 248     int __leftop137__ = 32;
 249     int __leftop139__ = 32;
 250     int __leftop141__ = 32;
 251     int __rightop142__ = 0;
 252     int __rightop140__ = __leftop141__ + __rightop142__;
 253     int __rightop138__ = __leftop139__ + __rightop140__;
 254     int __rightop136__ = __leftop137__ + __rightop138__;
 255     int __rightop134__ = __leftop135__ + __rightop136__;
 256     int __sizeof132__ = __leftop133__ + __rightop134__;
 257     int __high143__ = __left91__ + __sizeof132__;
 258     assertvalidmemory(__left91__, __high143__);
 259     // __left91__ = d.g
 260     // __offsetinbits144__ <-- (32 + (32 + 0))
 261     int __leftop145__ = 32;
 262     int __leftop147__ = 32;
 263     int __rightop148__ = 0;
 264     int __rightop146__ = __leftop147__ + __rightop148__;
 265     int __offsetinbits144__ = __leftop145__ + __rightop146__;
 266     // __offsetinbits144__ = (32 + (32 + 0))
 267     int __offset149__ = __offsetinbits144__ >> 3;
 268     int __shift150__ = __offsetinbits144__ - (__offset149__ << 3);
 269     int __element90__ = ((*(int *)(__left91__ + __offset149__))  >> __shift150__) & 0xffffffff;
 270     __InodeTableBlock___hash->add((int)__element90__, (int)__element90__);
 271     }
 272   }
 273
 274
 275 // build rule4
 276   {
 277   //(d.g.InodeBitmapBlock < d.s.NumberofBlocks)
 278   // __left153__ <-- d.g
 279   // __left154__ <-- d
 280   int __left154__ = (int) d; //varexpr
 281   // __left154__ = d
 282   // __offsetinbits155__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 283   int __leftop156__ = 0;
 284   int __leftop160__ = 8;
 285   // __left162__ <-- d.s
 286   // __left163__ <-- d
 287   int __left163__ = (int) d; //varexpr
 288   // __left163__ = d
 289   int __left162__ = (__left163__ + 0);
 290   int __leftop165__ = 32;
 291   int __leftop167__ = 32;
 292   int __leftop169__ = 32;
 293   int __leftop171__ = 32;
 294   int __leftop173__ = 32;
 295   int __leftop175__ = 32;
 296   int __rightop176__ = 0;
 297   int __rightop174__ = __leftop175__ + __rightop176__;
 298   int __rightop172__ = __leftop173__ + __rightop174__;
 299   int __rightop170__ = __leftop171__ + __rightop172__;
 300   int __rightop168__ = __leftop169__ + __rightop170__;
 301   int __rightop166__ = __leftop167__ + __rightop168__;
 302   int __sizeof164__ = __leftop165__ + __rightop166__;
 303   int __high177__ = __left162__ + __sizeof164__;
 304   assertvalidmemory(__left162__, __high177__);
 305   // __left162__ = d.s
 306   // __offsetinbits178__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 307   int __leftop179__ = 32;
 308   int __leftop181__ = 32;
 309   int __leftop183__ = 32;
 310   int __leftop185__ = 32;
 311   int __leftop187__ = 32;
 312   int __rightop188__ = 0;
 313   int __rightop186__ = __leftop187__ + __rightop188__;
 314   int __rightop184__ = __leftop185__ + __rightop186__;
 315   int __rightop182__ = __leftop183__ + __rightop184__;
 316   int __rightop180__ = __leftop181__ + __rightop182__;
 317   int __offsetinbits178__ = __leftop179__ + __rightop180__;
 318   // __offsetinbits178__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 319   int __offset189__ = __offsetinbits178__ >> 3;
 320   int __shift190__ = __offsetinbits178__ - (__offset189__ << 3);
 321   int __rightop161__ = ((*(int *)(__left162__ + __offset189__))  >> __shift190__) & 0xffffffff;
 322   int __leftop159__ = __leftop160__ * __rightop161__;
 323   int __rightop191__ = 0;
 324   int __leftop158__ = __leftop159__ + __rightop191__;
 325   int __rightop192__ = 1;
 326   int __rightop157__ = __leftop158__ * __rightop192__;
 327   int __offsetinbits155__ = __leftop156__ + __rightop157__;
 328   // __offsetinbits155__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 329   int __offset193__ = __offsetinbits155__ >> 3;
 330   int __left153__ = (__left154__ + __offset193__);
 331   int __leftop195__ = 32;
 332   int __leftop197__ = 32;
 333   int __leftop199__ = 32;
 334   int __leftop201__ = 32;
 335   int __leftop203__ = 32;
 336   int __rightop204__ = 0;
 337   int __rightop202__ = __leftop203__ + __rightop204__;
 338   int __rightop200__ = __leftop201__ + __rightop202__;
 339   int __rightop198__ = __leftop199__ + __rightop200__;
 340   int __rightop196__ = __leftop197__ + __rightop198__;
 341   int __sizeof194__ = __leftop195__ + __rightop196__;
 342   int __high205__ = __left153__ + __sizeof194__;
 343   assertvalidmemory(__left153__, __high205__);
 344   // __left153__ = d.g
 345   // __offsetinbits206__ <-- (32 + 0)
 346   int __leftop207__ = 32;
 347   int __rightop208__ = 0;
 348   int __offsetinbits206__ = __leftop207__ + __rightop208__;
 349   // __offsetinbits206__ = (32 + 0)
 350   int __offset209__ = __offsetinbits206__ >> 3;
 351   int __shift210__ = __offsetinbits206__ - (__offset209__ << 3);
 352   int __leftop152__ = ((*(int *)(__left153__ + __offset209__))  >> __shift210__) & 0xffffffff;
 353   // __left212__ <-- d.s
 354   // __left213__ <-- d
 355   int __left213__ = (int) d; //varexpr
 356   // __left213__ = d
 357   int __left212__ = (__left213__ + 0);
 358   int __leftop215__ = 32;
 359   int __leftop217__ = 32;
 360   int __leftop219__ = 32;
 361   int __leftop221__ = 32;
 362   int __leftop223__ = 32;
 363   int __leftop225__ = 32;
 364   int __rightop226__ = 0;
 365   int __rightop224__ = __leftop225__ + __rightop226__;
 366   int __rightop222__ = __leftop223__ + __rightop224__;
 367   int __rightop220__ = __leftop221__ + __rightop222__;
 368   int __rightop218__ = __leftop219__ + __rightop220__;
 369   int __rightop216__ = __leftop217__ + __rightop218__;
 370   int __sizeof214__ = __leftop215__ + __rightop216__;
 371   int __high227__ = __left212__ + __sizeof214__;
 372   assertvalidmemory(__left212__, __high227__);
 373   // __left212__ = d.s
 374   // __offsetinbits228__ <-- (32 + (32 + 0))
 375   int __leftop229__ = 32;
 376   int __leftop231__ = 32;
 377   int __rightop232__ = 0;
 378   int __rightop230__ = __leftop231__ + __rightop232__;
 379   int __offsetinbits228__ = __leftop229__ + __rightop230__;
 380   // __offsetinbits228__ = (32 + (32 + 0))
 381   int __offset233__ = __offsetinbits228__ >> 3;
 382   int __shift234__ = __offsetinbits228__ - (__offset233__ << 3);
 383   int __rightop211__ = ((*(int *)(__left212__ + __offset233__))  >> __shift234__) & 0xffffffff;
 384   int __tempvar151__ = __leftop152__ < __rightop211__;
 385   if (__tempvar151__)
 386     {
 387     // __left236__ <-- d.g
 388     // __left237__ <-- d
 389     int __left237__ = (int) d; //varexpr
 390     // __left237__ = d
 391     // __offsetinbits238__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 392     int __leftop239__ = 0;
 393     int __leftop243__ = 8;
 394     // __left245__ <-- d.s
 395     // __left246__ <-- d
 396     int __left246__ = (int) d; //varexpr
 397     // __left246__ = d
 398     int __left245__ = (__left246__ + 0);
 399     int __leftop248__ = 32;
 400     int __leftop250__ = 32;
 401     int __leftop252__ = 32;
 402     int __leftop254__ = 32;
 403     int __leftop256__ = 32;
 404     int __leftop258__ = 32;
 405     int __rightop259__ = 0;
 406     int __rightop257__ = __leftop258__ + __rightop259__;
 407     int __rightop255__ = __leftop256__ + __rightop257__;
 408     int __rightop253__ = __leftop254__ + __rightop255__;
 409     int __rightop251__ = __leftop252__ + __rightop253__;
 410     int __rightop249__ = __leftop250__ + __rightop251__;
 411     int __sizeof247__ = __leftop248__ + __rightop249__;
 412     int __high260__ = __left245__ + __sizeof247__;
 413     assertvalidmemory(__left245__, __high260__);
 414     // __left245__ = d.s
 415     // __offsetinbits261__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 416     int __leftop262__ = 32;
 417     int __leftop264__ = 32;
 418     int __leftop266__ = 32;
 419     int __leftop268__ = 32;
 420     int __leftop270__ = 32;
 421     int __rightop271__ = 0;
 422     int __rightop269__ = __leftop270__ + __rightop271__;
 423     int __rightop267__ = __leftop268__ + __rightop269__;
 424     int __rightop265__ = __leftop266__ + __rightop267__;
 425     int __rightop263__ = __leftop264__ + __rightop265__;
 426     int __offsetinbits261__ = __leftop262__ + __rightop263__;
 427     // __offsetinbits261__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 428     int __offset272__ = __offsetinbits261__ >> 3;
 429     int __shift273__ = __offsetinbits261__ - (__offset272__ << 3);
 430     int __rightop244__ = ((*(int *)(__left245__ + __offset272__))  >> __shift273__) & 0xffffffff;
 431     int __leftop242__ = __leftop243__ * __rightop244__;
 432     int __rightop274__ = 0;
 433     int __leftop241__ = __leftop242__ + __rightop274__;
 434     int __rightop275__ = 1;
 435     int __rightop240__ = __leftop241__ * __rightop275__;
 436     int __offsetinbits238__ = __leftop239__ + __rightop240__;
 437     // __offsetinbits238__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 438     int __offset276__ = __offsetinbits238__ >> 3;
 439     int __left236__ = (__left237__ + __offset276__);
 440     int __leftop278__ = 32;
 441     int __leftop280__ = 32;
 442     int __leftop282__ = 32;
 443     int __leftop284__ = 32;
 444     int __leftop286__ = 32;
 445     int __rightop287__ = 0;
 446     int __rightop285__ = __leftop286__ + __rightop287__;
 447     int __rightop283__ = __leftop284__ + __rightop285__;
 448     int __rightop281__ = __leftop282__ + __rightop283__;
 449     int __rightop279__ = __leftop280__ + __rightop281__;
 450     int __sizeof277__ = __leftop278__ + __rightop279__;
 451     int __high288__ = __left236__ + __sizeof277__;
 452     assertvalidmemory(__left236__, __high288__);
 453     // __left236__ = d.g
 454     // __offsetinbits289__ <-- (32 + 0)
 455     int __leftop290__ = 32;
 456     int __rightop291__ = 0;
 457     int __offsetinbits289__ = __leftop290__ + __rightop291__;
 458     // __offsetinbits289__ = (32 + 0)
 459     int __offset292__ = __offsetinbits289__ >> 3;
 460     int __shift293__ = __offsetinbits289__ - (__offset292__ << 3);
 461     int __element235__ = ((*(int *)(__left236__ + __offset292__))  >> __shift293__) & 0xffffffff;
 462     __InodeBitmapBlock___hash->add((int)__element235__, (int)__element235__);
 463     }
 464   }
 465
 466
 467 // build rule12
 468   {
 469   int __tempvar294__ = 0;
 470   // __left297__ <-- d.s
 471   // __left298__ <-- d
 472   int __left298__ = (int) d; //varexpr
 473   // __left298__ = d
 474   int __left297__ = (__left298__ + 0);
 475   int __leftop300__ = 32;
 476   int __leftop302__ = 32;
 477   int __leftop304__ = 32;
 478   int __leftop306__ = 32;
 479   int __leftop308__ = 32;
 480   int __leftop310__ = 32;
 481   int __rightop311__ = 0;
 482   int __rightop309__ = __leftop310__ + __rightop311__;
 483   int __rightop307__ = __leftop308__ + __rightop309__;
 484   int __rightop305__ = __leftop306__ + __rightop307__;
 485   int __rightop303__ = __leftop304__ + __rightop305__;
 486   int __rightop301__ = __leftop302__ + __rightop303__;
 487   int __sizeof299__ = __leftop300__ + __rightop301__;
 488   int __high312__ = __left297__ + __sizeof299__;
 489   assertvalidmemory(__left297__, __high312__);
 490   // __left297__ = d.s
 491   // __offsetinbits313__ <-- (32 + (32 + (32 + 0)))
 492   int __leftop314__ = 32;
 493   int __leftop316__ = 32;
 494   int __leftop318__ = 32;
 495   int __rightop319__ = 0;
 496   int __rightop317__ = __leftop318__ + __rightop319__;
 497   int __rightop315__ = __leftop316__ + __rightop317__;
 498   int __offsetinbits313__ = __leftop314__ + __rightop315__;
 499   // __offsetinbits313__ = (32 + (32 + (32 + 0)))
 500   int __offset320__ = __offsetinbits313__ >> 3;
 501   int __shift321__ = __offsetinbits313__ - (__offset320__ << 3);
 502   int __leftop296__ = ((*(int *)(__left297__ + __offset320__))  >> __shift321__) & 0xffffffff;
 503   int __rightop322__ = 1;
 504   int __tempvar295__ = __leftop296__ - __rightop322__;
 505   for (int __j__ = __tempvar294__; __j__ <= __tempvar295__; __j__++)
 506     {
 507     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); )
 508       {
 509       int __ibb__ = (int) __ibb___iterator->next();
 510       //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == false)
 511       // __left325__ <-- cast(__InodeBitmap__, d.b[ibb])
 512       // __left327__ <-- d
 513       int __left327__ = (int) d; //varexpr
 514       // __left327__ = d
 515       // __offsetinbits328__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
 516       int __leftop329__ = 0;
 517       int __leftop333__ = 8;
 518       // __left335__ <-- d.s
 519       // __left336__ <-- d
 520       int __left336__ = (int) d; //varexpr
 521       // __left336__ = d
 522       int __left335__ = (__left336__ + 0);
 523       int __leftop338__ = 32;
 524       int __leftop340__ = 32;
 525       int __leftop342__ = 32;
 526       int __leftop344__ = 32;
 527       int __leftop346__ = 32;
 528       int __leftop348__ = 32;
 529       int __rightop349__ = 0;
 530       int __rightop347__ = __leftop348__ + __rightop349__;
 531       int __rightop345__ = __leftop346__ + __rightop347__;
 532       int __rightop343__ = __leftop344__ + __rightop345__;
 533       int __rightop341__ = __leftop342__ + __rightop343__;
 534       int __rightop339__ = __leftop340__ + __rightop341__;
 535       int __sizeof337__ = __leftop338__ + __rightop339__;
 536       int __high350__ = __left335__ + __sizeof337__;
 537       assertvalidmemory(__left335__, __high350__);
 538       // __left335__ = d.s
 539       // __offsetinbits351__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 540       int __leftop352__ = 32;
 541       int __leftop354__ = 32;
 542       int __leftop356__ = 32;
 543       int __leftop358__ = 32;
 544       int __leftop360__ = 32;
 545       int __rightop361__ = 0;
 546       int __rightop359__ = __leftop360__ + __rightop361__;
 547       int __rightop357__ = __leftop358__ + __rightop359__;
 548       int __rightop355__ = __leftop356__ + __rightop357__;
 549       int __rightop353__ = __leftop354__ + __rightop355__;
 550       int __offsetinbits351__ = __leftop352__ + __rightop353__;
 551       // __offsetinbits351__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 552       int __offset362__ = __offsetinbits351__ >> 3;
 553       int __shift363__ = __offsetinbits351__ - (__offset362__ << 3);
 554       int __rightop334__ = ((*(int *)(__left335__ + __offset362__))  >> __shift363__) & 0xffffffff;
 555       int __leftop332__ = __leftop333__ * __rightop334__;
 556       int __rightop364__ = 0;
 557       int __leftop331__ = __leftop332__ + __rightop364__;
 558       int __rightop365__ = (int) __ibb__; //varexpr
 559       int __rightop330__ = __leftop331__ * __rightop365__;
 560       int __offsetinbits328__ = __leftop329__ + __rightop330__;
 561       // __offsetinbits328__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
 562       int __offset366__ = __offsetinbits328__ >> 3;
 563       int __expr326__ = (__left327__ + __offset366__);
 564       int __leftop369__ = 8;
 565       // __left371__ <-- d.s
 566       // __left372__ <-- d
 567       int __left372__ = (int) d; //varexpr
 568       // __left372__ = d
 569       int __left371__ = (__left372__ + 0);
 570       int __leftop374__ = 32;
 571       int __leftop376__ = 32;
 572       int __leftop378__ = 32;
 573       int __leftop380__ = 32;
 574       int __leftop382__ = 32;
 575       int __leftop384__ = 32;
 576       int __rightop385__ = 0;
 577       int __rightop383__ = __leftop384__ + __rightop385__;
 578       int __rightop381__ = __leftop382__ + __rightop383__;
 579       int __rightop379__ = __leftop380__ + __rightop381__;
 580       int __rightop377__ = __leftop378__ + __rightop379__;
 581       int __rightop375__ = __leftop376__ + __rightop377__;
 582       int __sizeof373__ = __leftop374__ + __rightop375__;
 583       int __high386__ = __left371__ + __sizeof373__;
 584       assertvalidmemory(__left371__, __high386__);
 585       // __left371__ = d.s
 586       // __offsetinbits387__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 587       int __leftop388__ = 32;
 588       int __leftop390__ = 32;
 589       int __leftop392__ = 32;
 590       int __leftop394__ = 32;
 591       int __leftop396__ = 32;
 592       int __rightop397__ = 0;
 593       int __rightop395__ = __leftop396__ + __rightop397__;
 594       int __rightop393__ = __leftop394__ + __rightop395__;
 595       int __rightop391__ = __leftop392__ + __rightop393__;
 596       int __rightop389__ = __leftop390__ + __rightop391__;
 597       int __offsetinbits387__ = __leftop388__ + __rightop389__;
 598       // __offsetinbits387__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 599       int __offset398__ = __offsetinbits387__ >> 3;
 600       int __shift399__ = __offsetinbits387__ - (__offset398__ << 3);
 601       int __rightop370__ = ((*(int *)(__left371__ + __offset398__))  >> __shift399__) & 0xffffffff;
 602       int __leftop368__ = __leftop369__ * __rightop370__;
 603       int __rightop400__ = 0;
 604       int __sizeof367__ = __leftop368__ + __rightop400__;
 605       int __high401__ = __expr326__ + __sizeof367__;
 606       assertvalidmemory(__expr326__, __high401__);
 607       int __left325__ = (int) __expr326__;
 608       // __left325__ = cast(__InodeBitmap__, d.b[ibb])
 609       // __offsetinbits402__ <-- (0 + (1 * j))
 610       int __leftop403__ = 0;
 611       int __leftop405__ = 1;
 612       int __rightop406__ = (int) __j__; //varexpr
 613       int __rightop404__ = __leftop405__ * __rightop406__;
 614       int __offsetinbits402__ = __leftop403__ + __rightop404__;
 615       // __offsetinbits402__ = (0 + (1 * j))
 616       int __offset407__ = __offsetinbits402__ >> 3;
 617       int __shift408__ = __offsetinbits402__ - (__offset407__ << 3);
 618       int __leftop324__ = ((*(int *)(__left325__ + __offset407__))  >> __shift408__) & 0x1;
 619       int __rightop409__ = 0;
 620       int __tempvar323__ = __leftop324__ == __rightop409__;
 621       if (__tempvar323__)
 622         {
 623         int __leftele410__ = (int) __j__; //varexpr
 624         int __rightele411__ = 101;
 625         __inodestatus___hash->add((int)__leftele410__, (int)__rightele411__);
 626         }
 627       }
 628     }
 629   }
 630
 631
 632 // build rule5
 633   {
 634   //(d.g.BlockBitmapBlock < d.s.NumberofBlocks)
 635   // __left415__ <-- d.g
 636   // __left416__ <-- d
 637   int __left416__ = (int) d; //varexpr
 638   // __left416__ = d
 639   // __offsetinbits417__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 640   int __leftop418__ = 0;
 641   int __leftop422__ = 8;
 642   // __left424__ <-- d.s
 643   // __left425__ <-- d
 644   int __left425__ = (int) d; //varexpr
 645   // __left425__ = d
 646   int __left424__ = (__left425__ + 0);
 647   int __leftop427__ = 32;
 648   int __leftop429__ = 32;
 649   int __leftop431__ = 32;
 650   int __leftop433__ = 32;
 651   int __leftop435__ = 32;
 652   int __leftop437__ = 32;
 653   int __rightop438__ = 0;
 654   int __rightop436__ = __leftop437__ + __rightop438__;
 655   int __rightop434__ = __leftop435__ + __rightop436__;
 656   int __rightop432__ = __leftop433__ + __rightop434__;
 657   int __rightop430__ = __leftop431__ + __rightop432__;
 658   int __rightop428__ = __leftop429__ + __rightop430__;
 659   int __sizeof426__ = __leftop427__ + __rightop428__;
 660   int __high439__ = __left424__ + __sizeof426__;
 661   assertvalidmemory(__left424__, __high439__);
 662   // __left424__ = d.s
 663   // __offsetinbits440__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 664   int __leftop441__ = 32;
 665   int __leftop443__ = 32;
 666   int __leftop445__ = 32;
 667   int __leftop447__ = 32;
 668   int __leftop449__ = 32;
 669   int __rightop450__ = 0;
 670   int __rightop448__ = __leftop449__ + __rightop450__;
 671   int __rightop446__ = __leftop447__ + __rightop448__;
 672   int __rightop444__ = __leftop445__ + __rightop446__;
 673   int __rightop442__ = __leftop443__ + __rightop444__;
 674   int __offsetinbits440__ = __leftop441__ + __rightop442__;
 675   // __offsetinbits440__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 676   int __offset451__ = __offsetinbits440__ >> 3;
 677   int __shift452__ = __offsetinbits440__ - (__offset451__ << 3);
 678   int __rightop423__ = ((*(int *)(__left424__ + __offset451__))  >> __shift452__) & 0xffffffff;
 679   int __leftop421__ = __leftop422__ * __rightop423__;
 680   int __rightop453__ = 0;
 681   int __leftop420__ = __leftop421__ + __rightop453__;
 682   int __rightop454__ = 1;
 683   int __rightop419__ = __leftop420__ * __rightop454__;
 684   int __offsetinbits417__ = __leftop418__ + __rightop419__;
 685   // __offsetinbits417__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 686   int __offset455__ = __offsetinbits417__ >> 3;
 687   int __left415__ = (__left416__ + __offset455__);
 688   int __leftop457__ = 32;
 689   int __leftop459__ = 32;
 690   int __leftop461__ = 32;
 691   int __leftop463__ = 32;
 692   int __leftop465__ = 32;
 693   int __rightop466__ = 0;
 694   int __rightop464__ = __leftop465__ + __rightop466__;
 695   int __rightop462__ = __leftop463__ + __rightop464__;
 696   int __rightop460__ = __leftop461__ + __rightop462__;
 697   int __rightop458__ = __leftop459__ + __rightop460__;
 698   int __sizeof456__ = __leftop457__ + __rightop458__;
 699   int __high467__ = __left415__ + __sizeof456__;
 700   assertvalidmemory(__left415__, __high467__);
 701   // __left415__ = d.g
 702   int __leftop414__ = ((*(int *)(__left415__ + 0))  >> 0) & 0xffffffff;
 703   // __left469__ <-- d.s
 704   // __left470__ <-- d
 705   int __left470__ = (int) d; //varexpr
 706   // __left470__ = d
 707   int __left469__ = (__left470__ + 0);
 708   int __leftop472__ = 32;
 709   int __leftop474__ = 32;
 710   int __leftop476__ = 32;
 711   int __leftop478__ = 32;
 712   int __leftop480__ = 32;
 713   int __leftop482__ = 32;
 714   int __rightop483__ = 0;
 715   int __rightop481__ = __leftop482__ + __rightop483__;
 716   int __rightop479__ = __leftop480__ + __rightop481__;
 717   int __rightop477__ = __leftop478__ + __rightop479__;
 718   int __rightop475__ = __leftop476__ + __rightop477__;
 719   int __rightop473__ = __leftop474__ + __rightop475__;
 720   int __sizeof471__ = __leftop472__ + __rightop473__;
 721   int __high484__ = __left469__ + __sizeof471__;
 722   assertvalidmemory(__left469__, __high484__);
 723   // __left469__ = d.s
 724   // __offsetinbits485__ <-- (32 + (32 + 0))
 725   int __leftop486__ = 32;
 726   int __leftop488__ = 32;
 727   int __rightop489__ = 0;
 728   int __rightop487__ = __leftop488__ + __rightop489__;
 729   int __offsetinbits485__ = __leftop486__ + __rightop487__;
 730   // __offsetinbits485__ = (32 + (32 + 0))
 731   int __offset490__ = __offsetinbits485__ >> 3;
 732   int __shift491__ = __offsetinbits485__ - (__offset490__ << 3);
 733   int __rightop468__ = ((*(int *)(__left469__ + __offset490__))  >> __shift491__) & 0xffffffff;
 734   int __tempvar413__ = __leftop414__ < __rightop468__;
 735   if (__tempvar413__)
 736     {
 737     // __left493__ <-- d.g
 738     // __left494__ <-- d
 739     int __left494__ = (int) d; //varexpr
 740     // __left494__ = d
 741     // __offsetinbits495__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
 742     int __leftop496__ = 0;
 743     int __leftop500__ = 8;
 744     // __left502__ <-- d.s
 745     // __left503__ <-- d
 746     int __left503__ = (int) d; //varexpr
 747     // __left503__ = d
 748     int __left502__ = (__left503__ + 0);
 749     int __leftop505__ = 32;
 750     int __leftop507__ = 32;
 751     int __leftop509__ = 32;
 752     int __leftop511__ = 32;
 753     int __leftop513__ = 32;
 754     int __leftop515__ = 32;
 755     int __rightop516__ = 0;
 756     int __rightop514__ = __leftop515__ + __rightop516__;
 757     int __rightop512__ = __leftop513__ + __rightop514__;
 758     int __rightop510__ = __leftop511__ + __rightop512__;
 759     int __rightop508__ = __leftop509__ + __rightop510__;
 760     int __rightop506__ = __leftop507__ + __rightop508__;
 761     int __sizeof504__ = __leftop505__ + __rightop506__;
 762     int __high517__ = __left502__ + __sizeof504__;
 763     assertvalidmemory(__left502__, __high517__);
 764     // __left502__ = d.s
 765     // __offsetinbits518__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 766     int __leftop519__ = 32;
 767     int __leftop521__ = 32;
 768     int __leftop523__ = 32;
 769     int __leftop525__ = 32;
 770     int __leftop527__ = 32;
 771     int __rightop528__ = 0;
 772     int __rightop526__ = __leftop527__ + __rightop528__;
 773     int __rightop524__ = __leftop525__ + __rightop526__;
 774     int __rightop522__ = __leftop523__ + __rightop524__;
 775     int __rightop520__ = __leftop521__ + __rightop522__;
 776     int __offsetinbits518__ = __leftop519__ + __rightop520__;
 777     // __offsetinbits518__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 778     int __offset529__ = __offsetinbits518__ >> 3;
 779     int __shift530__ = __offsetinbits518__ - (__offset529__ << 3);
 780     int __rightop501__ = ((*(int *)(__left502__ + __offset529__))  >> __shift530__) & 0xffffffff;
 781     int __leftop499__ = __leftop500__ * __rightop501__;
 782     int __rightop531__ = 0;
 783     int __leftop498__ = __leftop499__ + __rightop531__;
 784     int __rightop532__ = 1;
 785     int __rightop497__ = __leftop498__ * __rightop532__;
 786     int __offsetinbits495__ = __leftop496__ + __rightop497__;
 787     // __offsetinbits495__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
 788     int __offset533__ = __offsetinbits495__ >> 3;
 789     int __left493__ = (__left494__ + __offset533__);
 790     int __leftop535__ = 32;
 791     int __leftop537__ = 32;
 792     int __leftop539__ = 32;
 793     int __leftop541__ = 32;
 794     int __leftop543__ = 32;
 795     int __rightop544__ = 0;
 796     int __rightop542__ = __leftop543__ + __rightop544__;
 797     int __rightop540__ = __leftop541__ + __rightop542__;
 798     int __rightop538__ = __leftop539__ + __rightop540__;
 799     int __rightop536__ = __leftop537__ + __rightop538__;
 800     int __sizeof534__ = __leftop535__ + __rightop536__;
 801     int __high545__ = __left493__ + __sizeof534__;
 802     assertvalidmemory(__left493__, __high545__);
 803     // __left493__ = d.g
 804     int __element492__ = ((*(int *)(__left493__ + 0))  >> 0) & 0xffffffff;
 805     __BlockBitmapBlock___hash->add((int)__element492__, (int)__element492__);
 806     }
 807   }
 808
 809
 810 // build rule13
 811   {
 812   int __tempvar546__ = 0;
 813   // __left549__ <-- d.s
 814   // __left550__ <-- d
 815   int __left550__ = (int) d; //varexpr
 816   // __left550__ = d
 817   int __left549__ = (__left550__ + 0);
 818   int __leftop552__ = 32;
 819   int __leftop554__ = 32;
 820   int __leftop556__ = 32;
 821   int __leftop558__ = 32;
 822   int __leftop560__ = 32;
 823   int __leftop562__ = 32;
 824   int __rightop563__ = 0;
 825   int __rightop561__ = __leftop562__ + __rightop563__;
 826   int __rightop559__ = __leftop560__ + __rightop561__;
 827   int __rightop557__ = __leftop558__ + __rightop559__;
 828   int __rightop555__ = __leftop556__ + __rightop557__;
 829   int __rightop553__ = __leftop554__ + __rightop555__;
 830   int __sizeof551__ = __leftop552__ + __rightop553__;
 831   int __high564__ = __left549__ + __sizeof551__;
 832   assertvalidmemory(__left549__, __high564__);
 833   // __left549__ = d.s
 834   // __offsetinbits565__ <-- (32 + (32 + (32 + 0)))
 835   int __leftop566__ = 32;
 836   int __leftop568__ = 32;
 837   int __leftop570__ = 32;
 838   int __rightop571__ = 0;
 839   int __rightop569__ = __leftop570__ + __rightop571__;
 840   int __rightop567__ = __leftop568__ + __rightop569__;
 841   int __offsetinbits565__ = __leftop566__ + __rightop567__;
 842   // __offsetinbits565__ = (32 + (32 + (32 + 0)))
 843   int __offset572__ = __offsetinbits565__ >> 3;
 844   int __shift573__ = __offsetinbits565__ - (__offset572__ << 3);
 845   int __leftop548__ = ((*(int *)(__left549__ + __offset572__))  >> __shift573__) & 0xffffffff;
 846   int __rightop574__ = 1;
 847   int __tempvar547__ = __leftop548__ - __rightop574__;
 848   for (int __j__ = __tempvar546__; __j__ <= __tempvar547__; __j__++)
 849     {
 850     for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); )
 851       {
 852       int __ibb__ = (int) __ibb___iterator->next();
 853       //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == true)
 854       // __left577__ <-- cast(__InodeBitmap__, d.b[ibb])
 855       // __left579__ <-- d
 856       int __left579__ = (int) d; //varexpr
 857       // __left579__ = d
 858       // __offsetinbits580__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
 859       int __leftop581__ = 0;
 860       int __leftop585__ = 8;
 861       // __left587__ <-- d.s
 862       // __left588__ <-- d
 863       int __left588__ = (int) d; //varexpr
 864       // __left588__ = d
 865       int __left587__ = (__left588__ + 0);
 866       int __leftop590__ = 32;
 867       int __leftop592__ = 32;
 868       int __leftop594__ = 32;
 869       int __leftop596__ = 32;
 870       int __leftop598__ = 32;
 871       int __leftop600__ = 32;
 872       int __rightop601__ = 0;
 873       int __rightop599__ = __leftop600__ + __rightop601__;
 874       int __rightop597__ = __leftop598__ + __rightop599__;
 875       int __rightop595__ = __leftop596__ + __rightop597__;
 876       int __rightop593__ = __leftop594__ + __rightop595__;
 877       int __rightop591__ = __leftop592__ + __rightop593__;
 878       int __sizeof589__ = __leftop590__ + __rightop591__;
 879       int __high602__ = __left587__ + __sizeof589__;
 880       assertvalidmemory(__left587__, __high602__);
 881       // __left587__ = d.s
 882       // __offsetinbits603__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 883       int __leftop604__ = 32;
 884       int __leftop606__ = 32;
 885       int __leftop608__ = 32;
 886       int __leftop610__ = 32;
 887       int __leftop612__ = 32;
 888       int __rightop613__ = 0;
 889       int __rightop611__ = __leftop612__ + __rightop613__;
 890       int __rightop609__ = __leftop610__ + __rightop611__;
 891       int __rightop607__ = __leftop608__ + __rightop609__;
 892       int __rightop605__ = __leftop606__ + __rightop607__;
 893       int __offsetinbits603__ = __leftop604__ + __rightop605__;
 894       // __offsetinbits603__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 895       int __offset614__ = __offsetinbits603__ >> 3;
 896       int __shift615__ = __offsetinbits603__ - (__offset614__ << 3);
 897       int __rightop586__ = ((*(int *)(__left587__ + __offset614__))  >> __shift615__) & 0xffffffff;
 898       int __leftop584__ = __leftop585__ * __rightop586__;
 899       int __rightop616__ = 0;
 900       int __leftop583__ = __leftop584__ + __rightop616__;
 901       int __rightop617__ = (int) __ibb__; //varexpr
 902       int __rightop582__ = __leftop583__ * __rightop617__;
 903       int __offsetinbits580__ = __leftop581__ + __rightop582__;
 904       // __offsetinbits580__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
 905       int __offset618__ = __offsetinbits580__ >> 3;
 906       int __expr578__ = (__left579__ + __offset618__);
 907       int __leftop621__ = 8;
 908       // __left623__ <-- d.s
 909       // __left624__ <-- d
 910       int __left624__ = (int) d; //varexpr
 911       // __left624__ = d
 912       int __left623__ = (__left624__ + 0);
 913       int __leftop626__ = 32;
 914       int __leftop628__ = 32;
 915       int __leftop630__ = 32;
 916       int __leftop632__ = 32;
 917       int __leftop634__ = 32;
 918       int __leftop636__ = 32;
 919       int __rightop637__ = 0;
 920       int __rightop635__ = __leftop636__ + __rightop637__;
 921       int __rightop633__ = __leftop634__ + __rightop635__;
 922       int __rightop631__ = __leftop632__ + __rightop633__;
 923       int __rightop629__ = __leftop630__ + __rightop631__;
 924       int __rightop627__ = __leftop628__ + __rightop629__;
 925       int __sizeof625__ = __leftop626__ + __rightop627__;
 926       int __high638__ = __left623__ + __sizeof625__;
 927       assertvalidmemory(__left623__, __high638__);
 928       // __left623__ = d.s
 929       // __offsetinbits639__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
 930       int __leftop640__ = 32;
 931       int __leftop642__ = 32;
 932       int __leftop644__ = 32;
 933       int __leftop646__ = 32;
 934       int __leftop648__ = 32;
 935       int __rightop649__ = 0;
 936       int __rightop647__ = __leftop648__ + __rightop649__;
 937       int __rightop645__ = __leftop646__ + __rightop647__;
 938       int __rightop643__ = __leftop644__ + __rightop645__;
 939       int __rightop641__ = __leftop642__ + __rightop643__;
 940       int __offsetinbits639__ = __leftop640__ + __rightop641__;
 941       // __offsetinbits639__ = (32 + (32 + (32 + (32 + (32 + 0)))))
 942       int __offset650__ = __offsetinbits639__ >> 3;
 943       int __shift651__ = __offsetinbits639__ - (__offset650__ << 3);
 944       int __rightop622__ = ((*(int *)(__left623__ + __offset650__))  >> __shift651__) & 0xffffffff;
 945       int __leftop620__ = __leftop621__ * __rightop622__;
 946       int __rightop652__ = 0;
 947       int __sizeof619__ = __leftop620__ + __rightop652__;
 948       int __high653__ = __expr578__ + __sizeof619__;
 949       assertvalidmemory(__expr578__, __high653__);
 950       int __left577__ = (int) __expr578__;
 951       // __left577__ = cast(__InodeBitmap__, d.b[ibb])
 952       // __offsetinbits654__ <-- (0 + (1 * j))
 953       int __leftop655__ = 0;
 954       int __leftop657__ = 1;
 955       int __rightop658__ = (int) __j__; //varexpr
 956       int __rightop656__ = __leftop657__ * __rightop658__;
 957       int __offsetinbits654__ = __leftop655__ + __rightop656__;
 958       // __offsetinbits654__ = (0 + (1 * j))
 959       int __offset659__ = __offsetinbits654__ >> 3;
 960       int __shift660__ = __offsetinbits654__ - (__offset659__ << 3);
 961       int __leftop576__ = ((*(int *)(__left577__ + __offset659__))  >> __shift660__) & 0x1;
 962       int __rightop661__ = 1;
 963       int __tempvar575__ = __leftop576__ == __rightop661__;
 964       if (__tempvar575__)
 965         {
 966         int __leftele662__ = (int) __j__; //varexpr
 967         int __rightele663__ = 100;
 968         __inodestatus___hash->add((int)__leftele662__, (int)__rightele663__);
 969         }
 970       }
 971     }
 972   }
 973
 974
 975 // build rule6
 976   {
 977   //(d.s.RootDirectoryInode < d.s.NumberofInodes)
 978   // __left667__ <-- d.s
 979   // __left668__ <-- d
 980   int __left668__ = (int) d; //varexpr
 981   // __left668__ = d
 982   int __left667__ = (__left668__ + 0);
 983   int __leftop670__ = 32;
 984   int __leftop672__ = 32;
 985   int __leftop674__ = 32;
 986   int __leftop676__ = 32;
 987   int __leftop678__ = 32;
 988   int __leftop680__ = 32;
 989   int __rightop681__ = 0;
 990   int __rightop679__ = __leftop680__ + __rightop681__;
 991   int __rightop677__ = __leftop678__ + __rightop679__;
 992   int __rightop675__ = __leftop676__ + __rightop677__;
 993   int __rightop673__ = __leftop674__ + __rightop675__;
 994   int __rightop671__ = __leftop672__ + __rightop673__;
 995   int __sizeof669__ = __leftop670__ + __rightop671__;
 996   int __high682__ = __left667__ + __sizeof669__;
 997   assertvalidmemory(__left667__, __high682__);
 998   // __left667__ = d.s
 999   // __offsetinbits683__ <-- (32 + (32 + (32 + (32 + 0))))
1000   int __leftop684__ = 32;
1001   int __leftop686__ = 32;
1002   int __leftop688__ = 32;
1003   int __leftop690__ = 32;
1004   int __rightop691__ = 0;
1005   int __rightop689__ = __leftop690__ + __rightop691__;
1006   int __rightop687__ = __leftop688__ + __rightop689__;
1007   int __rightop685__ = __leftop686__ + __rightop687__;
1008   int __offsetinbits683__ = __leftop684__ + __rightop685__;
1009   // __offsetinbits683__ = (32 + (32 + (32 + (32 + 0))))
1010   int __offset692__ = __offsetinbits683__ >> 3;
1011   int __shift693__ = __offsetinbits683__ - (__offset692__ << 3);
1012   int __leftop666__ = ((*(int *)(__left667__ + __offset692__))  >> __shift693__) & 0xffffffff;
1013   // __left695__ <-- d.s
1014   // __left696__ <-- d
1015   int __left696__ = (int) d; //varexpr
1016   // __left696__ = d
1017   int __left695__ = (__left696__ + 0);
1018   int __leftop698__ = 32;
1019   int __leftop700__ = 32;
1020   int __leftop702__ = 32;
1021   int __leftop704__ = 32;
1022   int __leftop706__ = 32;
1023   int __leftop708__ = 32;
1024   int __rightop709__ = 0;
1025   int __rightop707__ = __leftop708__ + __rightop709__;
1026   int __rightop705__ = __leftop706__ + __rightop707__;
1027   int __rightop703__ = __leftop704__ + __rightop705__;
1028   int __rightop701__ = __leftop702__ + __rightop703__;
1029   int __rightop699__ = __leftop700__ + __rightop701__;
1030   int __sizeof697__ = __leftop698__ + __rightop699__;
1031   int __high710__ = __left695__ + __sizeof697__;
1032   assertvalidmemory(__left695__, __high710__);
1033   // __left695__ = d.s
1034   // __offsetinbits711__ <-- (32 + (32 + (32 + 0)))
1035   int __leftop712__ = 32;
1036   int __leftop714__ = 32;
1037   int __leftop716__ = 32;
1038   int __rightop717__ = 0;
1039   int __rightop715__ = __leftop716__ + __rightop717__;
1040   int __rightop713__ = __leftop714__ + __rightop715__;
1041   int __offsetinbits711__ = __leftop712__ + __rightop713__;
1042   // __offsetinbits711__ = (32 + (32 + (32 + 0)))
1043   int __offset718__ = __offsetinbits711__ >> 3;
1044   int __shift719__ = __offsetinbits711__ - (__offset718__ << 3);
1045   int __rightop694__ = ((*(int *)(__left695__ + __offset718__))  >> __shift719__) & 0xffffffff;
1046   int __tempvar665__ = __leftop666__ < __rightop694__;
1047   if (__tempvar665__)
1048     {
1049     // __left721__ <-- d.s
1050     // __left722__ <-- d
1051     int __left722__ = (int) d; //varexpr
1052     // __left722__ = d
1053     int __left721__ = (__left722__ + 0);
1054     int __leftop724__ = 32;
1055     int __leftop726__ = 32;
1056     int __leftop728__ = 32;
1057     int __leftop730__ = 32;
1058     int __leftop732__ = 32;
1059     int __leftop734__ = 32;
1060     int __rightop735__ = 0;
1061     int __rightop733__ = __leftop734__ + __rightop735__;
1062     int __rightop731__ = __leftop732__ + __rightop733__;
1063     int __rightop729__ = __leftop730__ + __rightop731__;
1064     int __rightop727__ = __leftop728__ + __rightop729__;
1065     int __rightop725__ = __leftop726__ + __rightop727__;
1066     int __sizeof723__ = __leftop724__ + __rightop725__;
1067     int __high736__ = __left721__ + __sizeof723__;
1068     assertvalidmemory(__left721__, __high736__);
1069     // __left721__ = d.s
1070     // __offsetinbits737__ <-- (32 + (32 + (32 + (32 + 0))))
1071     int __leftop738__ = 32;
1072     int __leftop740__ = 32;
1073     int __leftop742__ = 32;
1074     int __leftop744__ = 32;
1075     int __rightop745__ = 0;
1076     int __rightop743__ = __leftop744__ + __rightop745__;
1077     int __rightop741__ = __leftop742__ + __rightop743__;
1078     int __rightop739__ = __leftop740__ + __rightop741__;
1079     int __offsetinbits737__ = __leftop738__ + __rightop739__;
1080     // __offsetinbits737__ = (32 + (32 + (32 + (32 + 0))))
1081     int __offset746__ = __offsetinbits737__ >> 3;
1082     int __shift747__ = __offsetinbits737__ - (__offset746__ << 3);
1083     int __element720__ = ((*(int *)(__left721__ + __offset746__))  >> __shift747__) & 0xffffffff;
1084     __RootDirectoryInode___hash->add((int)__element720__, (int)__element720__);
1085     }
1086   }
1087
1088
1089 // build rule9
1090   {
1091   for (SimpleIterator* __di___iterator = __DirectoryInode___hash->iterator(); __di___iterator->hasNext(); )
1092     {
1093     int __di__ = (int) __di___iterator->next();
1094     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
1095       {
1096       int __itb__ = (int) __itb___iterator->next();
1097       int __tempvar748__ = 0;
1098       // __left752__ <-- d.s
1099       // __left753__ <-- d
1100       int __left753__ = (int) d; //varexpr
1101       // __left753__ = d
1102       int __left752__ = (__left753__ + 0);
1103       int __leftop755__ = 32;
1104       int __leftop757__ = 32;
1105       int __leftop759__ = 32;
1106       int __leftop761__ = 32;
1107       int __leftop763__ = 32;
1108       int __leftop765__ = 32;
1109       int __rightop766__ = 0;
1110       int __rightop764__ = __leftop765__ + __rightop766__;
1111       int __rightop762__ = __leftop763__ + __rightop764__;
1112       int __rightop760__ = __leftop761__ + __rightop762__;
1113       int __rightop758__ = __leftop759__ + __rightop760__;
1114       int __rightop756__ = __leftop757__ + __rightop758__;
1115       int __sizeof754__ = __leftop755__ + __rightop756__;
1116       int __high767__ = __left752__ + __sizeof754__;
1117       assertvalidmemory(__left752__, __high767__);
1118       // __left752__ = d.s
1119       // __offsetinbits768__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1120       int __leftop769__ = 32;
1121       int __leftop771__ = 32;
1122       int __leftop773__ = 32;
1123       int __leftop775__ = 32;
1124       int __leftop777__ = 32;
1125       int __rightop778__ = 0;
1126       int __rightop776__ = __leftop777__ + __rightop778__;
1127       int __rightop774__ = __leftop775__ + __rightop776__;
1128       int __rightop772__ = __leftop773__ + __rightop774__;
1129       int __rightop770__ = __leftop771__ + __rightop772__;
1130       int __offsetinbits768__ = __leftop769__ + __rightop770__;
1131       // __offsetinbits768__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1132       int __offset779__ = __offsetinbits768__ >> 3;
1133       int __shift780__ = __offsetinbits768__ - (__offset779__ << 3);
1134       int __leftop751__ = ((*(int *)(__left752__ + __offset779__))  >> __shift780__) & 0xffffffff;
1135       int __rightop781__ = 128;
1136       int __leftop750__ = __leftop751__ / __rightop781__;
1137       int __rightop782__ = 1;
1138       int __tempvar749__ = __leftop750__ - __rightop782__;
1139       for (int __j__ = __tempvar748__; __j__ <= __tempvar749__; __j__++)
1140         {
1141         int __tempvar783__ = 0;
1142         int __tempvar784__ = 11;
1143         for (int __k__ = __tempvar783__; __k__ <= __tempvar784__; __k__++)
1144           {
1145           //(cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k] < d.s.NumberofBlocks)
1146           // __left787__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
1147           // __left788__ <-- cast(__InodeTable__, d.b[itb])
1148           // __left790__ <-- d
1149           int __left790__ = (int) d; //varexpr
1150           // __left790__ = d
1151           // __offsetinbits791__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1152           int __leftop792__ = 0;
1153           int __leftop796__ = 8;
1154           // __left798__ <-- d.s
1155           // __left799__ <-- d
1156           int __left799__ = (int) d; //varexpr
1157           // __left799__ = d
1158           int __left798__ = (__left799__ + 0);
1159           int __leftop801__ = 32;
1160           int __leftop803__ = 32;
1161           int __leftop805__ = 32;
1162           int __leftop807__ = 32;
1163           int __leftop809__ = 32;
1164           int __leftop811__ = 32;
1165           int __rightop812__ = 0;
1166           int __rightop810__ = __leftop811__ + __rightop812__;
1167           int __rightop808__ = __leftop809__ + __rightop810__;
1168           int __rightop806__ = __leftop807__ + __rightop808__;
1169           int __rightop804__ = __leftop805__ + __rightop806__;
1170           int __rightop802__ = __leftop803__ + __rightop804__;
1171           int __sizeof800__ = __leftop801__ + __rightop802__;
1172           int __high813__ = __left798__ + __sizeof800__;
1173           assertvalidmemory(__left798__, __high813__);
1174           // __left798__ = d.s
1175           // __offsetinbits814__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1176           int __leftop815__ = 32;
1177           int __leftop817__ = 32;
1178           int __leftop819__ = 32;
1179           int __leftop821__ = 32;
1180           int __leftop823__ = 32;
1181           int __rightop824__ = 0;
1182           int __rightop822__ = __leftop823__ + __rightop824__;
1183           int __rightop820__ = __leftop821__ + __rightop822__;
1184           int __rightop818__ = __leftop819__ + __rightop820__;
1185           int __rightop816__ = __leftop817__ + __rightop818__;
1186           int __offsetinbits814__ = __leftop815__ + __rightop816__;
1187           // __offsetinbits814__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1188           int __offset825__ = __offsetinbits814__ >> 3;
1189           int __shift826__ = __offsetinbits814__ - (__offset825__ << 3);
1190           int __rightop797__ = ((*(int *)(__left798__ + __offset825__))  >> __shift826__) & 0xffffffff;
1191           int __leftop795__ = __leftop796__ * __rightop797__;
1192           int __rightop827__ = 0;
1193           int __leftop794__ = __leftop795__ + __rightop827__;
1194           int __rightop828__ = (int) __itb__; //varexpr
1195           int __rightop793__ = __leftop794__ * __rightop828__;
1196           int __offsetinbits791__ = __leftop792__ + __rightop793__;
1197           // __offsetinbits791__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1198           int __offset829__ = __offsetinbits791__ >> 3;
1199           int __expr789__ = (__left790__ + __offset829__);
1200           int __leftop832__ = 8;
1201           // __left834__ <-- d.s
1202           // __left835__ <-- d
1203           int __left835__ = (int) d; //varexpr
1204           // __left835__ = d
1205           int __left834__ = (__left835__ + 0);
1206           int __leftop837__ = 32;
1207           int __leftop839__ = 32;
1208           int __leftop841__ = 32;
1209           int __leftop843__ = 32;
1210           int __leftop845__ = 32;
1211           int __leftop847__ = 32;
1212           int __rightop848__ = 0;
1213           int __rightop846__ = __leftop847__ + __rightop848__;
1214           int __rightop844__ = __leftop845__ + __rightop846__;
1215           int __rightop842__ = __leftop843__ + __rightop844__;
1216           int __rightop840__ = __leftop841__ + __rightop842__;
1217           int __rightop838__ = __leftop839__ + __rightop840__;
1218           int __sizeof836__ = __leftop837__ + __rightop838__;
1219           int __high849__ = __left834__ + __sizeof836__;
1220           assertvalidmemory(__left834__, __high849__);
1221           // __left834__ = d.s
1222           // __offsetinbits850__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1223           int __leftop851__ = 32;
1224           int __leftop853__ = 32;
1225           int __leftop855__ = 32;
1226           int __leftop857__ = 32;
1227           int __leftop859__ = 32;
1228           int __rightop860__ = 0;
1229           int __rightop858__ = __leftop859__ + __rightop860__;
1230           int __rightop856__ = __leftop857__ + __rightop858__;
1231           int __rightop854__ = __leftop855__ + __rightop856__;
1232           int __rightop852__ = __leftop853__ + __rightop854__;
1233           int __offsetinbits850__ = __leftop851__ + __rightop852__;
1234           // __offsetinbits850__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1235           int __offset861__ = __offsetinbits850__ >> 3;
1236           int __shift862__ = __offsetinbits850__ - (__offset861__ << 3);
1237           int __rightop833__ = ((*(int *)(__left834__ + __offset861__))  >> __shift862__) & 0xffffffff;
1238           int __leftop831__ = __leftop832__ * __rightop833__;
1239           int __rightop863__ = 0;
1240           int __sizeof830__ = __leftop831__ + __rightop863__;
1241           int __high864__ = __expr789__ + __sizeof830__;
1242           assertvalidmemory(__expr789__, __high864__);
1243           int __left788__ = (int) __expr789__;
1244           // __left788__ = cast(__InodeTable__, d.b[itb])
1245           // __offsetinbits865__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1246           int __leftop866__ = 0;
1247           int __leftop869__ = 32;
1248           int __leftop872__ = 32;
1249           int __rightop873__ = 12;
1250           int __leftop871__ = __leftop872__ * __rightop873__;
1251           int __leftop875__ = 32;
1252           int __rightop876__ = 0;
1253           int __rightop874__ = __leftop875__ + __rightop876__;
1254           int __rightop870__ = __leftop871__ + __rightop874__;
1255           int __leftop868__ = __leftop869__ + __rightop870__;
1256           int __rightop877__ = (int) __di__; //varexpr
1257           int __rightop867__ = __leftop868__ * __rightop877__;
1258           int __offsetinbits865__ = __leftop866__ + __rightop867__;
1259           // __offsetinbits865__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1260           int __offset878__ = __offsetinbits865__ >> 3;
1261           int __left787__ = (__left788__ + __offset878__);
1262           int __leftop880__ = 32;
1263           int __leftop883__ = 32;
1264           int __rightop884__ = 12;
1265           int __leftop882__ = __leftop883__ * __rightop884__;
1266           int __leftop886__ = 32;
1267           int __rightop887__ = 0;
1268           int __rightop885__ = __leftop886__ + __rightop887__;
1269           int __rightop881__ = __leftop882__ + __rightop885__;
1270           int __sizeof879__ = __leftop880__ + __rightop881__;
1271           int __high888__ = __left787__ + __sizeof879__;
1272           assertvalidmemory(__left787__, __high888__);
1273           // __left787__ = cast(__InodeTable__, d.b[itb]).itable[di]
1274           // __offsetinbits889__ <-- ((32 + 0) + (32 * k))
1275           int __leftop891__ = 32;
1276           int __rightop892__ = 0;
1277           int __leftop890__ = __leftop891__ + __rightop892__;
1278           int __leftop894__ = 32;
1279           int __rightop895__ = (int) __k__; //varexpr
1280           int __rightop893__ = __leftop894__ * __rightop895__;
1281           int __offsetinbits889__ = __leftop890__ + __rightop893__;
1282           // __offsetinbits889__ = ((32 + 0) + (32 * k))
1283           int __offset896__ = __offsetinbits889__ >> 3;
1284           int __shift897__ = __offsetinbits889__ - (__offset896__ << 3);
1285           int __leftop786__ = ((*(int *)(__left787__ + __offset896__))  >> __shift897__) & 0xffffffff;
1286           // __left899__ <-- d.s
1287           // __left900__ <-- d
1288           int __left900__ = (int) d; //varexpr
1289           // __left900__ = d
1290           int __left899__ = (__left900__ + 0);
1291           int __leftop902__ = 32;
1292           int __leftop904__ = 32;
1293           int __leftop906__ = 32;
1294           int __leftop908__ = 32;
1295           int __leftop910__ = 32;
1296           int __leftop912__ = 32;
1297           int __rightop913__ = 0;
1298           int __rightop911__ = __leftop912__ + __rightop913__;
1299           int __rightop909__ = __leftop910__ + __rightop911__;
1300           int __rightop907__ = __leftop908__ + __rightop909__;
1301           int __rightop905__ = __leftop906__ + __rightop907__;
1302           int __rightop903__ = __leftop904__ + __rightop905__;
1303           int __sizeof901__ = __leftop902__ + __rightop903__;
1304           int __high914__ = __left899__ + __sizeof901__;
1305           assertvalidmemory(__left899__, __high914__);
1306           // __left899__ = d.s
1307           // __offsetinbits915__ <-- (32 + (32 + 0))
1308           int __leftop916__ = 32;
1309           int __leftop918__ = 32;
1310           int __rightop919__ = 0;
1311           int __rightop917__ = __leftop918__ + __rightop919__;
1312           int __offsetinbits915__ = __leftop916__ + __rightop917__;
1313           // __offsetinbits915__ = (32 + (32 + 0))
1314           int __offset920__ = __offsetinbits915__ >> 3;
1315           int __shift921__ = __offsetinbits915__ - (__offset920__ << 3);
1316           int __rightop898__ = ((*(int *)(__left899__ + __offset920__))  >> __shift921__) & 0xffffffff;
1317           int __tempvar785__ = __leftop786__ < __rightop898__;
1318           if (__tempvar785__)
1319             {
1320             // __left923__ <-- cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
1321             // __left925__ <-- d
1322             int __left925__ = (int) d; //varexpr
1323             // __left925__ = d
1324             // __offsetinbits926__ <-- (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
1325             int __leftop927__ = 0;
1326             int __leftop931__ = 8;
1327             // __left933__ <-- d.s
1328             // __left934__ <-- d
1329             int __left934__ = (int) d; //varexpr
1330             // __left934__ = d
1331             int __left933__ = (__left934__ + 0);
1332             int __leftop936__ = 32;
1333             int __leftop938__ = 32;
1334             int __leftop940__ = 32;
1335             int __leftop942__ = 32;
1336             int __leftop944__ = 32;
1337             int __leftop946__ = 32;
1338             int __rightop947__ = 0;
1339             int __rightop945__ = __leftop946__ + __rightop947__;
1340             int __rightop943__ = __leftop944__ + __rightop945__;
1341             int __rightop941__ = __leftop942__ + __rightop943__;
1342             int __rightop939__ = __leftop940__ + __rightop941__;
1343             int __rightop937__ = __leftop938__ + __rightop939__;
1344             int __sizeof935__ = __leftop936__ + __rightop937__;
1345             int __high948__ = __left933__ + __sizeof935__;
1346             assertvalidmemory(__left933__, __high948__);
1347             // __left933__ = d.s
1348             // __offsetinbits949__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1349             int __leftop950__ = 32;
1350             int __leftop952__ = 32;
1351             int __leftop954__ = 32;
1352             int __leftop956__ = 32;
1353             int __leftop958__ = 32;
1354             int __rightop959__ = 0;
1355             int __rightop957__ = __leftop958__ + __rightop959__;
1356             int __rightop955__ = __leftop956__ + __rightop957__;
1357             int __rightop953__ = __leftop954__ + __rightop955__;
1358             int __rightop951__ = __leftop952__ + __rightop953__;
1359             int __offsetinbits949__ = __leftop950__ + __rightop951__;
1360             // __offsetinbits949__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1361             int __offset960__ = __offsetinbits949__ >> 3;
1362             int __shift961__ = __offsetinbits949__ - (__offset960__ << 3);
1363             int __rightop932__ = ((*(int *)(__left933__ + __offset960__))  >> __shift961__) & 0xffffffff;
1364             int __leftop930__ = __leftop931__ * __rightop932__;
1365             int __rightop962__ = 0;
1366             int __leftop929__ = __leftop930__ + __rightop962__;
1367             // __left964__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
1368             // __left965__ <-- cast(__InodeTable__, d.b[itb])
1369             // __left967__ <-- d
1370             int __left967__ = (int) d; //varexpr
1371             // __left967__ = d
1372             // __offsetinbits968__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1373             int __leftop969__ = 0;
1374             int __leftop973__ = 8;
1375             // __left975__ <-- d.s
1376             // __left976__ <-- d
1377             int __left976__ = (int) d; //varexpr
1378             // __left976__ = d
1379             int __left975__ = (__left976__ + 0);
1380             int __leftop978__ = 32;
1381             int __leftop980__ = 32;
1382             int __leftop982__ = 32;
1383             int __leftop984__ = 32;
1384             int __leftop986__ = 32;
1385             int __leftop988__ = 32;
1386             int __rightop989__ = 0;
1387             int __rightop987__ = __leftop988__ + __rightop989__;
1388             int __rightop985__ = __leftop986__ + __rightop987__;
1389             int __rightop983__ = __leftop984__ + __rightop985__;
1390             int __rightop981__ = __leftop982__ + __rightop983__;
1391             int __rightop979__ = __leftop980__ + __rightop981__;
1392             int __sizeof977__ = __leftop978__ + __rightop979__;
1393             int __high990__ = __left975__ + __sizeof977__;
1394             assertvalidmemory(__left975__, __high990__);
1395             // __left975__ = d.s
1396             // __offsetinbits991__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1397             int __leftop992__ = 32;
1398             int __leftop994__ = 32;
1399             int __leftop996__ = 32;
1400             int __leftop998__ = 32;
1401             int __leftop1000__ = 32;
1402             int __rightop1001__ = 0;
1403             int __rightop999__ = __leftop1000__ + __rightop1001__;
1404             int __rightop997__ = __leftop998__ + __rightop999__;
1405             int __rightop995__ = __leftop996__ + __rightop997__;
1406             int __rightop993__ = __leftop994__ + __rightop995__;
1407             int __offsetinbits991__ = __leftop992__ + __rightop993__;
1408             // __offsetinbits991__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1409             int __offset1002__ = __offsetinbits991__ >> 3;
1410             int __shift1003__ = __offsetinbits991__ - (__offset1002__ << 3);
1411             int __rightop974__ = ((*(int *)(__left975__ + __offset1002__))  >> __shift1003__) & 0xffffffff;
1412             int __leftop972__ = __leftop973__ * __rightop974__;
1413             int __rightop1004__ = 0;
1414             int __leftop971__ = __leftop972__ + __rightop1004__;
1415             int __rightop1005__ = (int) __itb__; //varexpr
1416             int __rightop970__ = __leftop971__ * __rightop1005__;
1417             int __offsetinbits968__ = __leftop969__ + __rightop970__;
1418             // __offsetinbits968__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1419             int __offset1006__ = __offsetinbits968__ >> 3;
1420             int __expr966__ = (__left967__ + __offset1006__);
1421             int __leftop1009__ = 8;
1422             // __left1011__ <-- d.s
1423             // __left1012__ <-- d
1424             int __left1012__ = (int) d; //varexpr
1425             // __left1012__ = d
1426             int __left1011__ = (__left1012__ + 0);
1427             int __leftop1014__ = 32;
1428             int __leftop1016__ = 32;
1429             int __leftop1018__ = 32;
1430             int __leftop1020__ = 32;
1431             int __leftop1022__ = 32;
1432             int __leftop1024__ = 32;
1433             int __rightop1025__ = 0;
1434             int __rightop1023__ = __leftop1024__ + __rightop1025__;
1435             int __rightop1021__ = __leftop1022__ + __rightop1023__;
1436             int __rightop1019__ = __leftop1020__ + __rightop1021__;
1437             int __rightop1017__ = __leftop1018__ + __rightop1019__;
1438             int __rightop1015__ = __leftop1016__ + __rightop1017__;
1439             int __sizeof1013__ = __leftop1014__ + __rightop1015__;
1440             int __high1026__ = __left1011__ + __sizeof1013__;
1441             assertvalidmemory(__left1011__, __high1026__);
1442             // __left1011__ = d.s
1443             // __offsetinbits1027__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1444             int __leftop1028__ = 32;
1445             int __leftop1030__ = 32;
1446             int __leftop1032__ = 32;
1447             int __leftop1034__ = 32;
1448             int __leftop1036__ = 32;
1449             int __rightop1037__ = 0;
1450             int __rightop1035__ = __leftop1036__ + __rightop1037__;
1451             int __rightop1033__ = __leftop1034__ + __rightop1035__;
1452             int __rightop1031__ = __leftop1032__ + __rightop1033__;
1453             int __rightop1029__ = __leftop1030__ + __rightop1031__;
1454             int __offsetinbits1027__ = __leftop1028__ + __rightop1029__;
1455             // __offsetinbits1027__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1456             int __offset1038__ = __offsetinbits1027__ >> 3;
1457             int __shift1039__ = __offsetinbits1027__ - (__offset1038__ << 3);
1458             int __rightop1010__ = ((*(int *)(__left1011__ + __offset1038__))  >> __shift1039__) & 0xffffffff;
1459             int __leftop1008__ = __leftop1009__ * __rightop1010__;
1460             int __rightop1040__ = 0;
1461             int __sizeof1007__ = __leftop1008__ + __rightop1040__;
1462             int __high1041__ = __expr966__ + __sizeof1007__;
1463             assertvalidmemory(__expr966__, __high1041__);
1464             int __left965__ = (int) __expr966__;
1465             // __left965__ = cast(__InodeTable__, d.b[itb])
1466             // __offsetinbits1042__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1467             int __leftop1043__ = 0;
1468             int __leftop1046__ = 32;
1469             int __leftop1049__ = 32;
1470             int __rightop1050__ = 12;
1471             int __leftop1048__ = __leftop1049__ * __rightop1050__;
1472             int __leftop1052__ = 32;
1473             int __rightop1053__ = 0;
1474             int __rightop1051__ = __leftop1052__ + __rightop1053__;
1475             int __rightop1047__ = __leftop1048__ + __rightop1051__;
1476             int __leftop1045__ = __leftop1046__ + __rightop1047__;
1477             int __rightop1054__ = (int) __di__; //varexpr
1478             int __rightop1044__ = __leftop1045__ * __rightop1054__;
1479             int __offsetinbits1042__ = __leftop1043__ + __rightop1044__;
1480             // __offsetinbits1042__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
1481             int __offset1055__ = __offsetinbits1042__ >> 3;
1482             int __left964__ = (__left965__ + __offset1055__);
1483             int __leftop1057__ = 32;
1484             int __leftop1060__ = 32;
1485             int __rightop1061__ = 12;
1486             int __leftop1059__ = __leftop1060__ * __rightop1061__;
1487             int __leftop1063__ = 32;
1488             int __rightop1064__ = 0;
1489             int __rightop1062__ = __leftop1063__ + __rightop1064__;
1490             int __rightop1058__ = __leftop1059__ + __rightop1062__;
1491             int __sizeof1056__ = __leftop1057__ + __rightop1058__;
1492             int __high1065__ = __left964__ + __sizeof1056__;
1493             assertvalidmemory(__left964__, __high1065__);
1494             // __left964__ = cast(__InodeTable__, d.b[itb]).itable[di]
1495             // __offsetinbits1066__ <-- ((32 + 0) + (32 * k))
1496             int __leftop1068__ = 32;
1497             int __rightop1069__ = 0;
1498             int __leftop1067__ = __leftop1068__ + __rightop1069__;
1499             int __leftop1071__ = 32;
1500             int __rightop1072__ = (int) __k__; //varexpr
1501             int __rightop1070__ = __leftop1071__ * __rightop1072__;
1502             int __offsetinbits1066__ = __leftop1067__ + __rightop1070__;
1503             // __offsetinbits1066__ = ((32 + 0) + (32 * k))
1504             int __offset1073__ = __offsetinbits1066__ >> 3;
1505             int __shift1074__ = __offsetinbits1066__ - (__offset1073__ << 3);
1506             int __rightop963__ = ((*(int *)(__left964__ + __offset1073__))  >> __shift1074__) & 0xffffffff;
1507             int __rightop928__ = __leftop929__ * __rightop963__;
1508             int __offsetinbits926__ = __leftop927__ + __rightop928__;
1509             // __offsetinbits926__ = (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
1510             int __offset1075__ = __offsetinbits926__ >> 3;
1511             int __expr924__ = (__left925__ + __offset1075__);
1512             int __leftop1078__ = 8;
1513             // __left1080__ <-- d.s
1514             // __left1081__ <-- d
1515             int __left1081__ = (int) d; //varexpr
1516             // __left1081__ = d
1517             int __left1080__ = (__left1081__ + 0);
1518             int __leftop1083__ = 32;
1519             int __leftop1085__ = 32;
1520             int __leftop1087__ = 32;
1521             int __leftop1089__ = 32;
1522             int __leftop1091__ = 32;
1523             int __leftop1093__ = 32;
1524             int __rightop1094__ = 0;
1525             int __rightop1092__ = __leftop1093__ + __rightop1094__;
1526             int __rightop1090__ = __leftop1091__ + __rightop1092__;
1527             int __rightop1088__ = __leftop1089__ + __rightop1090__;
1528             int __rightop1086__ = __leftop1087__ + __rightop1088__;
1529             int __rightop1084__ = __leftop1085__ + __rightop1086__;
1530             int __sizeof1082__ = __leftop1083__ + __rightop1084__;
1531             int __high1095__ = __left1080__ + __sizeof1082__;
1532             assertvalidmemory(__left1080__, __high1095__);
1533             // __left1080__ = d.s
1534             // __offsetinbits1096__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1535             int __leftop1097__ = 32;
1536             int __leftop1099__ = 32;
1537             int __leftop1101__ = 32;
1538             int __leftop1103__ = 32;
1539             int __leftop1105__ = 32;
1540             int __rightop1106__ = 0;
1541             int __rightop1104__ = __leftop1105__ + __rightop1106__;
1542             int __rightop1102__ = __leftop1103__ + __rightop1104__;
1543             int __rightop1100__ = __leftop1101__ + __rightop1102__;
1544             int __rightop1098__ = __leftop1099__ + __rightop1100__;
1545             int __offsetinbits1096__ = __leftop1097__ + __rightop1098__;
1546             // __offsetinbits1096__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1547             int __offset1107__ = __offsetinbits1096__ >> 3;
1548             int __shift1108__ = __offsetinbits1096__ - (__offset1107__ << 3);
1549             int __rightop1079__ = ((*(int *)(__left1080__ + __offset1107__))  >> __shift1108__) & 0xffffffff;
1550             int __leftop1077__ = __leftop1078__ * __rightop1079__;
1551             int __rightop1109__ = 0;
1552             int __sizeof1076__ = __leftop1077__ + __rightop1109__;
1553             int __high1110__ = __expr924__ + __sizeof1076__;
1554             assertvalidmemory(__expr924__, __high1110__);
1555             int __left923__ = (int) __expr924__;
1556             // __left923__ = cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
1557             // __offsetinbits1111__ <-- (0 + ((32 + ((8 * 124) + 0)) * j))
1558             int __leftop1112__ = 0;
1559             int __leftop1115__ = 32;
1560             int __leftop1118__ = 8;
1561             int __rightop1119__ = 124;
1562             int __leftop1117__ = __leftop1118__ * __rightop1119__;
1563             int __rightop1120__ = 0;
1564             int __rightop1116__ = __leftop1117__ + __rightop1120__;
1565             int __leftop1114__ = __leftop1115__ + __rightop1116__;
1566             int __rightop1121__ = (int) __j__; //varexpr
1567             int __rightop1113__ = __leftop1114__ * __rightop1121__;
1568             int __offsetinbits1111__ = __leftop1112__ + __rightop1113__;
1569             // __offsetinbits1111__ = (0 + ((32 + ((8 * 124) + 0)) * j))
1570             int __offset1122__ = __offsetinbits1111__ >> 3;
1571             int __element922__ = (__left923__ + __offset1122__);
1572             int __leftop1124__ = 32;
1573             int __leftop1127__ = 8;
1574             int __rightop1128__ = 124;
1575             int __leftop1126__ = __leftop1127__ * __rightop1128__;
1576             int __rightop1129__ = 0;
1577             int __rightop1125__ = __leftop1126__ + __rightop1129__;
1578             int __sizeof1123__ = __leftop1124__ + __rightop1125__;
1579             int __high1130__ = __element922__ + __sizeof1123__;
1580             assertvalidmemory(__element922__, __high1130__);
1581             __DirectoryEntry___hash->add((int)__element922__, (int)__element922__);
1582             }
1583           }
1584         }
1585       }
1586     }
1587   }
1588
1589
1590 // build rule15
1591   {
1592   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); )
1593     {
1594     int __de__ = (int) __de___iterator->next();
1595     //(de.inodenumber < d.s.NumberofInodes)
1596     // __left1133__ <-- de
1597     int __left1133__ = (int) __de__; //varexpr
1598     // __left1133__ = de
1599     // __offsetinbits1134__ <-- ((8 * 124) + 0)
1600     int __leftop1136__ = 8;
1601     int __rightop1137__ = 124;
1602     int __leftop1135__ = __leftop1136__ * __rightop1137__;
1603     int __rightop1138__ = 0;
1604     int __offsetinbits1134__ = __leftop1135__ + __rightop1138__;
1605     // __offsetinbits1134__ = ((8 * 124) + 0)
1606     int __offset1139__ = __offsetinbits1134__ >> 3;
1607     int __shift1140__ = __offsetinbits1134__ - (__offset1139__ << 3);
1608     int __leftop1132__ = ((*(int *)(__left1133__ + __offset1139__))  >> __shift1140__) & 0xffffffff;
1609     // __left1142__ <-- d.s
1610     // __left1143__ <-- d
1611     int __left1143__ = (int) d; //varexpr
1612     // __left1143__ = d
1613     int __left1142__ = (__left1143__ + 0);
1614     int __leftop1145__ = 32;
1615     int __leftop1147__ = 32;
1616     int __leftop1149__ = 32;
1617     int __leftop1151__ = 32;
1618     int __leftop1153__ = 32;
1619     int __leftop1155__ = 32;
1620     int __rightop1156__ = 0;
1621     int __rightop1154__ = __leftop1155__ + __rightop1156__;
1622     int __rightop1152__ = __leftop1153__ + __rightop1154__;
1623     int __rightop1150__ = __leftop1151__ + __rightop1152__;
1624     int __rightop1148__ = __leftop1149__ + __rightop1150__;
1625     int __rightop1146__ = __leftop1147__ + __rightop1148__;
1626     int __sizeof1144__ = __leftop1145__ + __rightop1146__;
1627     int __high1157__ = __left1142__ + __sizeof1144__;
1628     assertvalidmemory(__left1142__, __high1157__);
1629     // __left1142__ = d.s
1630     // __offsetinbits1158__ <-- (32 + (32 + (32 + 0)))
1631     int __leftop1159__ = 32;
1632     int __leftop1161__ = 32;
1633     int __leftop1163__ = 32;
1634     int __rightop1164__ = 0;
1635     int __rightop1162__ = __leftop1163__ + __rightop1164__;
1636     int __rightop1160__ = __leftop1161__ + __rightop1162__;
1637     int __offsetinbits1158__ = __leftop1159__ + __rightop1160__;
1638     // __offsetinbits1158__ = (32 + (32 + (32 + 0)))
1639     int __offset1165__ = __offsetinbits1158__ >> 3;
1640     int __shift1166__ = __offsetinbits1158__ - (__offset1165__ << 3);
1641     int __rightop1141__ = ((*(int *)(__left1142__ + __offset1165__))  >> __shift1166__) & 0xffffffff;
1642     int __tempvar1131__ = __leftop1132__ < __rightop1141__;
1643     if (__tempvar1131__)
1644       {
1645       int __leftele1167__ = (int) __de__; //varexpr
1646       // __left1169__ <-- de
1647       int __left1169__ = (int) __de__; //varexpr
1648       // __left1169__ = de
1649       // __offsetinbits1170__ <-- ((8 * 124) + 0)
1650       int __leftop1172__ = 8;
1651       int __rightop1173__ = 124;
1652       int __leftop1171__ = __leftop1172__ * __rightop1173__;
1653       int __rightop1174__ = 0;
1654       int __offsetinbits1170__ = __leftop1171__ + __rightop1174__;
1655       // __offsetinbits1170__ = ((8 * 124) + 0)
1656       int __offset1175__ = __offsetinbits1170__ >> 3;
1657       int __shift1176__ = __offsetinbits1170__ - (__offset1175__ << 3);
1658       int __rightele1168__ = ((*(int *)(__left1169__ + __offset1175__))  >> __shift1176__) & 0xffffffff;
1659       __inodeof___hashinv->add((int)__rightele1168__, (int)__leftele1167__);
1660       }
1661     }
1662   }
1663
1664
1665 // build rule14
1666   {
1667   for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); )
1668     {
1669     int __de__ = (int) __de___iterator->next();
1670     //((de.inodenumber < d.s.NumberofInodes) && ((de.inodenumber == 0)))
1671     // __left1181__ <-- de
1672     int __left1181__ = (int) __de__; //varexpr
1673     // __left1181__ = de
1674     // __offsetinbits1182__ <-- ((8 * 124) + 0)
1675     int __leftop1184__ = 8;
1676     int __rightop1185__ = 124;
1677     int __leftop1183__ = __leftop1184__ * __rightop1185__;
1678     int __rightop1186__ = 0;
1679     int __offsetinbits1182__ = __leftop1183__ + __rightop1186__;
1680     // __offsetinbits1182__ = ((8 * 124) + 0)
1681     int __offset1187__ = __offsetinbits1182__ >> 3;
1682     int __shift1188__ = __offsetinbits1182__ - (__offset1187__ << 3);
1683     int __leftop1180__ = ((*(int *)(__left1181__ + __offset1187__))  >> __shift1188__) & 0xffffffff;
1684     // __left1190__ <-- d.s
1685     // __left1191__ <-- d
1686     int __left1191__ = (int) d; //varexpr
1687     // __left1191__ = d
1688     int __left1190__ = (__left1191__ + 0);
1689     int __leftop1193__ = 32;
1690     int __leftop1195__ = 32;
1691     int __leftop1197__ = 32;
1692     int __leftop1199__ = 32;
1693     int __leftop1201__ = 32;
1694     int __leftop1203__ = 32;
1695     int __rightop1204__ = 0;
1696     int __rightop1202__ = __leftop1203__ + __rightop1204__;
1697     int __rightop1200__ = __leftop1201__ + __rightop1202__;
1698     int __rightop1198__ = __leftop1199__ + __rightop1200__;
1699     int __rightop1196__ = __leftop1197__ + __rightop1198__;
1700     int __rightop1194__ = __leftop1195__ + __rightop1196__;
1701     int __sizeof1192__ = __leftop1193__ + __rightop1194__;
1702     int __high1205__ = __left1190__ + __sizeof1192__;
1703     assertvalidmemory(__left1190__, __high1205__);
1704     // __left1190__ = d.s
1705     // __offsetinbits1206__ <-- (32 + (32 + (32 + 0)))
1706     int __leftop1207__ = 32;
1707     int __leftop1209__ = 32;
1708     int __leftop1211__ = 32;
1709     int __rightop1212__ = 0;
1710     int __rightop1210__ = __leftop1211__ + __rightop1212__;
1711     int __rightop1208__ = __leftop1209__ + __rightop1210__;
1712     int __offsetinbits1206__ = __leftop1207__ + __rightop1208__;
1713     // __offsetinbits1206__ = (32 + (32 + (32 + 0)))
1714     int __offset1213__ = __offsetinbits1206__ >> 3;
1715     int __shift1214__ = __offsetinbits1206__ - (__offset1213__ << 3);
1716     int __rightop1189__ = ((*(int *)(__left1190__ + __offset1213__))  >> __shift1214__) & 0xffffffff;
1717     int __leftop1179__ = __leftop1180__ < __rightop1189__;
1718     // __left1218__ <-- de
1719     int __left1218__ = (int) __de__; //varexpr
1720     // __left1218__ = de
1721     // __offsetinbits1219__ <-- ((8 * 124) + 0)
1722     int __leftop1221__ = 8;
1723     int __rightop1222__ = 124;
1724     int __leftop1220__ = __leftop1221__ * __rightop1222__;
1725     int __rightop1223__ = 0;
1726     int __offsetinbits1219__ = __leftop1220__ + __rightop1223__;
1727     // __offsetinbits1219__ = ((8 * 124) + 0)
1728     int __offset1224__ = __offsetinbits1219__ >> 3;
1729     int __shift1225__ = __offsetinbits1219__ - (__offset1224__ << 3);
1730     int __leftop1217__ = ((*(int *)(__left1218__ + __offset1224__))  >> __shift1225__) & 0xffffffff;
1731     int __rightop1226__ = 0;
1732     int __leftop1216__ = __leftop1217__ == __rightop1226__;
1733     int __rightop1215__ = !__leftop1216__;
1734     int __tempvar1178__ = __leftop1179__ && __rightop1215__;
1735     if (__tempvar1178__)
1736       {
1737       // __left1228__ <-- de
1738       int __left1228__ = (int) __de__; //varexpr
1739       // __left1228__ = de
1740       // __offsetinbits1229__ <-- ((8 * 124) + 0)
1741       int __leftop1231__ = 8;
1742       int __rightop1232__ = 124;
1743       int __leftop1230__ = __leftop1231__ * __rightop1232__;
1744       int __rightop1233__ = 0;
1745       int __offsetinbits1229__ = __leftop1230__ + __rightop1233__;
1746       // __offsetinbits1229__ = ((8 * 124) + 0)
1747       int __offset1234__ = __offsetinbits1229__ >> 3;
1748       int __shift1235__ = __offsetinbits1229__ - (__offset1234__ << 3);
1749       int __element1227__ = ((*(int *)(__left1228__ + __offset1234__))  >> __shift1235__) & 0xffffffff;
1750       __FileInode___hash->add((int)__element1227__, (int)__element1227__);
1751       }
1752     }
1753   }
1754
1755
1756 // build rule16
1757   {
1758   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); )
1759     {
1760     int __j__ = (int) __j___iterator->next();
1761     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
1762       {
1763       int __itb__ = (int) __itb___iterator->next();
1764       //true
1765       int __tempvar1236__ = 1;
1766       if (__tempvar1236__)
1767         {
1768         int __leftele1237__ = (int) __j__; //varexpr
1769         // __left1239__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1770         // __left1240__ <-- cast(__InodeTable__, d.b[itb])
1771         // __left1242__ <-- d
1772         int __left1242__ = (int) d; //varexpr
1773         // __left1242__ = d
1774         // __offsetinbits1243__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1775         int __leftop1244__ = 0;
1776         int __leftop1248__ = 8;
1777         // __left1250__ <-- d.s
1778         // __left1251__ <-- d
1779         int __left1251__ = (int) d; //varexpr
1780         // __left1251__ = d
1781         int __left1250__ = (__left1251__ + 0);
1782         int __leftop1253__ = 32;
1783         int __leftop1255__ = 32;
1784         int __leftop1257__ = 32;
1785         int __leftop1259__ = 32;
1786         int __leftop1261__ = 32;
1787         int __leftop1263__ = 32;
1788         int __rightop1264__ = 0;
1789         int __rightop1262__ = __leftop1263__ + __rightop1264__;
1790         int __rightop1260__ = __leftop1261__ + __rightop1262__;
1791         int __rightop1258__ = __leftop1259__ + __rightop1260__;
1792         int __rightop1256__ = __leftop1257__ + __rightop1258__;
1793         int __rightop1254__ = __leftop1255__ + __rightop1256__;
1794         int __sizeof1252__ = __leftop1253__ + __rightop1254__;
1795         int __high1265__ = __left1250__ + __sizeof1252__;
1796         assertvalidmemory(__left1250__, __high1265__);
1797         // __left1250__ = d.s
1798         // __offsetinbits1266__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1799         int __leftop1267__ = 32;
1800         int __leftop1269__ = 32;
1801         int __leftop1271__ = 32;
1802         int __leftop1273__ = 32;
1803         int __leftop1275__ = 32;
1804         int __rightop1276__ = 0;
1805         int __rightop1274__ = __leftop1275__ + __rightop1276__;
1806         int __rightop1272__ = __leftop1273__ + __rightop1274__;
1807         int __rightop1270__ = __leftop1271__ + __rightop1272__;
1808         int __rightop1268__ = __leftop1269__ + __rightop1270__;
1809         int __offsetinbits1266__ = __leftop1267__ + __rightop1268__;
1810         // __offsetinbits1266__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1811         int __offset1277__ = __offsetinbits1266__ >> 3;
1812         int __shift1278__ = __offsetinbits1266__ - (__offset1277__ << 3);
1813         int __rightop1249__ = ((*(int *)(__left1250__ + __offset1277__))  >> __shift1278__) & 0xffffffff;
1814         int __leftop1247__ = __leftop1248__ * __rightop1249__;
1815         int __rightop1279__ = 0;
1816         int __leftop1246__ = __leftop1247__ + __rightop1279__;
1817         int __rightop1280__ = (int) __itb__; //varexpr
1818         int __rightop1245__ = __leftop1246__ * __rightop1280__;
1819         int __offsetinbits1243__ = __leftop1244__ + __rightop1245__;
1820         // __offsetinbits1243__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1821         int __offset1281__ = __offsetinbits1243__ >> 3;
1822         int __expr1241__ = (__left1242__ + __offset1281__);
1823         int __leftop1284__ = 8;
1824         // __left1286__ <-- d.s
1825         // __left1287__ <-- d
1826         int __left1287__ = (int) d; //varexpr
1827         // __left1287__ = d
1828         int __left1286__ = (__left1287__ + 0);
1829         int __leftop1289__ = 32;
1830         int __leftop1291__ = 32;
1831         int __leftop1293__ = 32;
1832         int __leftop1295__ = 32;
1833         int __leftop1297__ = 32;
1834         int __leftop1299__ = 32;
1835         int __rightop1300__ = 0;
1836         int __rightop1298__ = __leftop1299__ + __rightop1300__;
1837         int __rightop1296__ = __leftop1297__ + __rightop1298__;
1838         int __rightop1294__ = __leftop1295__ + __rightop1296__;
1839         int __rightop1292__ = __leftop1293__ + __rightop1294__;
1840         int __rightop1290__ = __leftop1291__ + __rightop1292__;
1841         int __sizeof1288__ = __leftop1289__ + __rightop1290__;
1842         int __high1301__ = __left1286__ + __sizeof1288__;
1843         assertvalidmemory(__left1286__, __high1301__);
1844         // __left1286__ = d.s
1845         // __offsetinbits1302__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1846         int __leftop1303__ = 32;
1847         int __leftop1305__ = 32;
1848         int __leftop1307__ = 32;
1849         int __leftop1309__ = 32;
1850         int __leftop1311__ = 32;
1851         int __rightop1312__ = 0;
1852         int __rightop1310__ = __leftop1311__ + __rightop1312__;
1853         int __rightop1308__ = __leftop1309__ + __rightop1310__;
1854         int __rightop1306__ = __leftop1307__ + __rightop1308__;
1855         int __rightop1304__ = __leftop1305__ + __rightop1306__;
1856         int __offsetinbits1302__ = __leftop1303__ + __rightop1304__;
1857         // __offsetinbits1302__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1858         int __offset1313__ = __offsetinbits1302__ >> 3;
1859         int __shift1314__ = __offsetinbits1302__ - (__offset1313__ << 3);
1860         int __rightop1285__ = ((*(int *)(__left1286__ + __offset1313__))  >> __shift1314__) & 0xffffffff;
1861         int __leftop1283__ = __leftop1284__ * __rightop1285__;
1862         int __rightop1315__ = 0;
1863         int __sizeof1282__ = __leftop1283__ + __rightop1315__;
1864         int __high1316__ = __expr1241__ + __sizeof1282__;
1865         assertvalidmemory(__expr1241__, __high1316__);
1866         int __left1240__ = (int) __expr1241__;
1867         // __left1240__ = cast(__InodeTable__, d.b[itb])
1868         // __offsetinbits1317__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1869         int __leftop1318__ = 0;
1870         int __leftop1321__ = 32;
1871         int __leftop1324__ = 32;
1872         int __rightop1325__ = 12;
1873         int __leftop1323__ = __leftop1324__ * __rightop1325__;
1874         int __leftop1327__ = 32;
1875         int __rightop1328__ = 0;
1876         int __rightop1326__ = __leftop1327__ + __rightop1328__;
1877         int __rightop1322__ = __leftop1323__ + __rightop1326__;
1878         int __leftop1320__ = __leftop1321__ + __rightop1322__;
1879         int __rightop1329__ = (int) __j__; //varexpr
1880         int __rightop1319__ = __leftop1320__ * __rightop1329__;
1881         int __offsetinbits1317__ = __leftop1318__ + __rightop1319__;
1882         // __offsetinbits1317__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1883         int __offset1330__ = __offsetinbits1317__ >> 3;
1884         int __left1239__ = (__left1240__ + __offset1330__);
1885         int __leftop1332__ = 32;
1886         int __leftop1335__ = 32;
1887         int __rightop1336__ = 12;
1888         int __leftop1334__ = __leftop1335__ * __rightop1336__;
1889         int __leftop1338__ = 32;
1890         int __rightop1339__ = 0;
1891         int __rightop1337__ = __leftop1338__ + __rightop1339__;
1892         int __rightop1333__ = __leftop1334__ + __rightop1337__;
1893         int __sizeof1331__ = __leftop1332__ + __rightop1333__;
1894         int __high1340__ = __left1239__ + __sizeof1331__;
1895         assertvalidmemory(__left1239__, __high1340__);
1896         // __left1239__ = cast(__InodeTable__, d.b[itb]).itable[j]
1897         // __offsetinbits1341__ <-- ((32 * 12) + (32 + 0))
1898         int __leftop1343__ = 32;
1899         int __rightop1344__ = 12;
1900         int __leftop1342__ = __leftop1343__ * __rightop1344__;
1901         int __leftop1346__ = 32;
1902         int __rightop1347__ = 0;
1903         int __rightop1345__ = __leftop1346__ + __rightop1347__;
1904         int __offsetinbits1341__ = __leftop1342__ + __rightop1345__;
1905         // __offsetinbits1341__ = ((32 * 12) + (32 + 0))
1906         int __offset1348__ = __offsetinbits1341__ >> 3;
1907         int __shift1349__ = __offsetinbits1341__ - (__offset1348__ << 3);
1908         int __rightele1238__ = ((*(int *)(__left1239__ + __offset1348__))  >> __shift1349__) & 0xffffffff;
1909         __referencecount___hash->add((int)__leftele1237__, (int)__rightele1238__);
1910         }
1911       }
1912     }
1913   }
1914
1915
1916 // build rule11
1917   {
1918   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
1919     {
1920     int __i__ = (int) __i___iterator->next();
1921     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
1922       {
1923       int __itb__ = (int) __itb___iterator->next();
1924       int __tempvar1351__ = 0;
1925       int __tempvar1352__ = 11;
1926       for (int __j__ = __tempvar1351__; __j__ <= __tempvar1352__; __j__++)
1927         {
1928         //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks) && ((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0)))
1929         // __left1356__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1930         // __left1357__ <-- cast(__InodeTable__, d.b[itb])
1931         // __left1359__ <-- d
1932         int __left1359__ = (int) d; //varexpr
1933         // __left1359__ = d
1934         // __offsetinbits1360__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1935         int __leftop1361__ = 0;
1936         int __leftop1365__ = 8;
1937         // __left1367__ <-- d.s
1938         // __left1368__ <-- d
1939         int __left1368__ = (int) d; //varexpr
1940         // __left1368__ = d
1941         int __left1367__ = (__left1368__ + 0);
1942         int __leftop1370__ = 32;
1943         int __leftop1372__ = 32;
1944         int __leftop1374__ = 32;
1945         int __leftop1376__ = 32;
1946         int __leftop1378__ = 32;
1947         int __leftop1380__ = 32;
1948         int __rightop1381__ = 0;
1949         int __rightop1379__ = __leftop1380__ + __rightop1381__;
1950         int __rightop1377__ = __leftop1378__ + __rightop1379__;
1951         int __rightop1375__ = __leftop1376__ + __rightop1377__;
1952         int __rightop1373__ = __leftop1374__ + __rightop1375__;
1953         int __rightop1371__ = __leftop1372__ + __rightop1373__;
1954         int __sizeof1369__ = __leftop1370__ + __rightop1371__;
1955         int __high1382__ = __left1367__ + __sizeof1369__;
1956         assertvalidmemory(__left1367__, __high1382__);
1957         // __left1367__ = d.s
1958         // __offsetinbits1383__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1959         int __leftop1384__ = 32;
1960         int __leftop1386__ = 32;
1961         int __leftop1388__ = 32;
1962         int __leftop1390__ = 32;
1963         int __leftop1392__ = 32;
1964         int __rightop1393__ = 0;
1965         int __rightop1391__ = __leftop1392__ + __rightop1393__;
1966         int __rightop1389__ = __leftop1390__ + __rightop1391__;
1967         int __rightop1387__ = __leftop1388__ + __rightop1389__;
1968         int __rightop1385__ = __leftop1386__ + __rightop1387__;
1969         int __offsetinbits1383__ = __leftop1384__ + __rightop1385__;
1970         // __offsetinbits1383__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1971         int __offset1394__ = __offsetinbits1383__ >> 3;
1972         int __shift1395__ = __offsetinbits1383__ - (__offset1394__ << 3);
1973         int __rightop1366__ = ((*(int *)(__left1367__ + __offset1394__))  >> __shift1395__) & 0xffffffff;
1974         int __leftop1364__ = __leftop1365__ * __rightop1366__;
1975         int __rightop1396__ = 0;
1976         int __leftop1363__ = __leftop1364__ + __rightop1396__;
1977         int __rightop1397__ = (int) __itb__; //varexpr
1978         int __rightop1362__ = __leftop1363__ * __rightop1397__;
1979         int __offsetinbits1360__ = __leftop1361__ + __rightop1362__;
1980         // __offsetinbits1360__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1981         int __offset1398__ = __offsetinbits1360__ >> 3;
1982         int __expr1358__ = (__left1359__ + __offset1398__);
1983         int __leftop1401__ = 8;
1984         // __left1403__ <-- d.s
1985         // __left1404__ <-- d
1986         int __left1404__ = (int) d; //varexpr
1987         // __left1404__ = d
1988         int __left1403__ = (__left1404__ + 0);
1989         int __leftop1406__ = 32;
1990         int __leftop1408__ = 32;
1991         int __leftop1410__ = 32;
1992         int __leftop1412__ = 32;
1993         int __leftop1414__ = 32;
1994         int __leftop1416__ = 32;
1995         int __rightop1417__ = 0;
1996         int __rightop1415__ = __leftop1416__ + __rightop1417__;
1997         int __rightop1413__ = __leftop1414__ + __rightop1415__;
1998         int __rightop1411__ = __leftop1412__ + __rightop1413__;
1999         int __rightop1409__ = __leftop1410__ + __rightop1411__;
2000         int __rightop1407__ = __leftop1408__ + __rightop1409__;
2001         int __sizeof1405__ = __leftop1406__ + __rightop1407__;
2002         int __high1418__ = __left1403__ + __sizeof1405__;
2003         assertvalidmemory(__left1403__, __high1418__);
2004         // __left1403__ = d.s
2005         // __offsetinbits1419__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2006         int __leftop1420__ = 32;
2007         int __leftop1422__ = 32;
2008         int __leftop1424__ = 32;
2009         int __leftop1426__ = 32;
2010         int __leftop1428__ = 32;
2011         int __rightop1429__ = 0;
2012         int __rightop1427__ = __leftop1428__ + __rightop1429__;
2013         int __rightop1425__ = __leftop1426__ + __rightop1427__;
2014         int __rightop1423__ = __leftop1424__ + __rightop1425__;
2015         int __rightop1421__ = __leftop1422__ + __rightop1423__;
2016         int __offsetinbits1419__ = __leftop1420__ + __rightop1421__;
2017         // __offsetinbits1419__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2018         int __offset1430__ = __offsetinbits1419__ >> 3;
2019         int __shift1431__ = __offsetinbits1419__ - (__offset1430__ << 3);
2020         int __rightop1402__ = ((*(int *)(__left1403__ + __offset1430__))  >> __shift1431__) & 0xffffffff;
2021         int __leftop1400__ = __leftop1401__ * __rightop1402__;
2022         int __rightop1432__ = 0;
2023         int __sizeof1399__ = __leftop1400__ + __rightop1432__;
2024         int __high1433__ = __expr1358__ + __sizeof1399__;
2025         assertvalidmemory(__expr1358__, __high1433__);
2026         int __left1357__ = (int) __expr1358__;
2027         // __left1357__ = cast(__InodeTable__, d.b[itb])
2028         // __offsetinbits1434__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2029         int __leftop1435__ = 0;
2030         int __leftop1438__ = 32;
2031         int __leftop1441__ = 32;
2032         int __rightop1442__ = 12;
2033         int __leftop1440__ = __leftop1441__ * __rightop1442__;
2034         int __leftop1444__ = 32;
2035         int __rightop1445__ = 0;
2036         int __rightop1443__ = __leftop1444__ + __rightop1445__;
2037         int __rightop1439__ = __leftop1440__ + __rightop1443__;
2038         int __leftop1437__ = __leftop1438__ + __rightop1439__;
2039         int __rightop1446__ = (int) __i__; //varexpr
2040         int __rightop1436__ = __leftop1437__ * __rightop1446__;
2041         int __offsetinbits1434__ = __leftop1435__ + __rightop1436__;
2042         // __offsetinbits1434__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2043         int __offset1447__ = __offsetinbits1434__ >> 3;
2044         int __left1356__ = (__left1357__ + __offset1447__);
2045         int __leftop1449__ = 32;
2046         int __leftop1452__ = 32;
2047         int __rightop1453__ = 12;
2048         int __leftop1451__ = __leftop1452__ * __rightop1453__;
2049         int __leftop1455__ = 32;
2050         int __rightop1456__ = 0;
2051         int __rightop1454__ = __leftop1455__ + __rightop1456__;
2052         int __rightop1450__ = __leftop1451__ + __rightop1454__;
2053         int __sizeof1448__ = __leftop1449__ + __rightop1450__;
2054         int __high1457__ = __left1356__ + __sizeof1448__;
2055         assertvalidmemory(__left1356__, __high1457__);
2056         // __left1356__ = cast(__InodeTable__, d.b[itb]).itable[i]
2057         // __offsetinbits1458__ <-- ((32 + 0) + (32 * j))
2058         int __leftop1460__ = 32;
2059         int __rightop1461__ = 0;
2060         int __leftop1459__ = __leftop1460__ + __rightop1461__;
2061         int __leftop1463__ = 32;
2062         int __rightop1464__ = (int) __j__; //varexpr
2063         int __rightop1462__ = __leftop1463__ * __rightop1464__;
2064         int __offsetinbits1458__ = __leftop1459__ + __rightop1462__;
2065         // __offsetinbits1458__ = ((32 + 0) + (32 * j))
2066         int __offset1465__ = __offsetinbits1458__ >> 3;
2067         int __shift1466__ = __offsetinbits1458__ - (__offset1465__ << 3);
2068         int __leftop1355__ = ((*(int *)(__left1356__ + __offset1465__))  >> __shift1466__) & 0xffffffff;
2069         // __left1468__ <-- d.s
2070         // __left1469__ <-- d
2071         int __left1469__ = (int) d; //varexpr
2072         // __left1469__ = d
2073         int __left1468__ = (__left1469__ + 0);
2074         int __leftop1471__ = 32;
2075         int __leftop1473__ = 32;
2076         int __leftop1475__ = 32;
2077         int __leftop1477__ = 32;
2078         int __leftop1479__ = 32;
2079         int __leftop1481__ = 32;
2080         int __rightop1482__ = 0;
2081         int __rightop1480__ = __leftop1481__ + __rightop1482__;
2082         int __rightop1478__ = __leftop1479__ + __rightop1480__;
2083         int __rightop1476__ = __leftop1477__ + __rightop1478__;
2084         int __rightop1474__ = __leftop1475__ + __rightop1476__;
2085         int __rightop1472__ = __leftop1473__ + __rightop1474__;
2086         int __sizeof1470__ = __leftop1471__ + __rightop1472__;
2087         int __high1483__ = __left1468__ + __sizeof1470__;
2088         assertvalidmemory(__left1468__, __high1483__);
2089         // __left1468__ = d.s
2090         // __offsetinbits1484__ <-- (32 + (32 + 0))
2091         int __leftop1485__ = 32;
2092         int __leftop1487__ = 32;
2093         int __rightop1488__ = 0;
2094         int __rightop1486__ = __leftop1487__ + __rightop1488__;
2095         int __offsetinbits1484__ = __leftop1485__ + __rightop1486__;
2096         // __offsetinbits1484__ = (32 + (32 + 0))
2097         int __offset1489__ = __offsetinbits1484__ >> 3;
2098         int __shift1490__ = __offsetinbits1484__ - (__offset1489__ << 3);
2099         int __rightop1467__ = ((*(int *)(__left1468__ + __offset1489__))  >> __shift1490__) & 0xffffffff;
2100         int __leftop1354__ = __leftop1355__ < __rightop1467__;
2101         // __left1494__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2102         // __left1495__ <-- cast(__InodeTable__, d.b[itb])
2103         // __left1497__ <-- d
2104         int __left1497__ = (int) d; //varexpr
2105         // __left1497__ = d
2106         // __offsetinbits1498__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2107         int __leftop1499__ = 0;
2108         int __leftop1503__ = 8;
2109         // __left1505__ <-- d.s
2110         // __left1506__ <-- d
2111         int __left1506__ = (int) d; //varexpr
2112         // __left1506__ = d
2113         int __left1505__ = (__left1506__ + 0);
2114         int __leftop1508__ = 32;
2115         int __leftop1510__ = 32;
2116         int __leftop1512__ = 32;
2117         int __leftop1514__ = 32;
2118         int __leftop1516__ = 32;
2119         int __leftop1518__ = 32;
2120         int __rightop1519__ = 0;
2121         int __rightop1517__ = __leftop1518__ + __rightop1519__;
2122         int __rightop1515__ = __leftop1516__ + __rightop1517__;
2123         int __rightop1513__ = __leftop1514__ + __rightop1515__;
2124         int __rightop1511__ = __leftop1512__ + __rightop1513__;
2125         int __rightop1509__ = __leftop1510__ + __rightop1511__;
2126         int __sizeof1507__ = __leftop1508__ + __rightop1509__;
2127         int __high1520__ = __left1505__ + __sizeof1507__;
2128         assertvalidmemory(__left1505__, __high1520__);
2129         // __left1505__ = d.s
2130         // __offsetinbits1521__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2131         int __leftop1522__ = 32;
2132         int __leftop1524__ = 32;
2133         int __leftop1526__ = 32;
2134         int __leftop1528__ = 32;
2135         int __leftop1530__ = 32;
2136         int __rightop1531__ = 0;
2137         int __rightop1529__ = __leftop1530__ + __rightop1531__;
2138         int __rightop1527__ = __leftop1528__ + __rightop1529__;
2139         int __rightop1525__ = __leftop1526__ + __rightop1527__;
2140         int __rightop1523__ = __leftop1524__ + __rightop1525__;
2141         int __offsetinbits1521__ = __leftop1522__ + __rightop1523__;
2142         // __offsetinbits1521__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2143         int __offset1532__ = __offsetinbits1521__ >> 3;
2144         int __shift1533__ = __offsetinbits1521__ - (__offset1532__ << 3);
2145         int __rightop1504__ = ((*(int *)(__left1505__ + __offset1532__))  >> __shift1533__) & 0xffffffff;
2146         int __leftop1502__ = __leftop1503__ * __rightop1504__;
2147         int __rightop1534__ = 0;
2148         int __leftop1501__ = __leftop1502__ + __rightop1534__;
2149         int __rightop1535__ = (int) __itb__; //varexpr
2150         int __rightop1500__ = __leftop1501__ * __rightop1535__;
2151         int __offsetinbits1498__ = __leftop1499__ + __rightop1500__;
2152         // __offsetinbits1498__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2153         int __offset1536__ = __offsetinbits1498__ >> 3;
2154         int __expr1496__ = (__left1497__ + __offset1536__);
2155         int __leftop1539__ = 8;
2156         // __left1541__ <-- d.s
2157         // __left1542__ <-- d
2158         int __left1542__ = (int) d; //varexpr
2159         // __left1542__ = d
2160         int __left1541__ = (__left1542__ + 0);
2161         int __leftop1544__ = 32;
2162         int __leftop1546__ = 32;
2163         int __leftop1548__ = 32;
2164         int __leftop1550__ = 32;
2165         int __leftop1552__ = 32;
2166         int __leftop1554__ = 32;
2167         int __rightop1555__ = 0;
2168         int __rightop1553__ = __leftop1554__ + __rightop1555__;
2169         int __rightop1551__ = __leftop1552__ + __rightop1553__;
2170         int __rightop1549__ = __leftop1550__ + __rightop1551__;
2171         int __rightop1547__ = __leftop1548__ + __rightop1549__;
2172         int __rightop1545__ = __leftop1546__ + __rightop1547__;
2173         int __sizeof1543__ = __leftop1544__ + __rightop1545__;
2174         int __high1556__ = __left1541__ + __sizeof1543__;
2175         assertvalidmemory(__left1541__, __high1556__);
2176         // __left1541__ = d.s
2177         // __offsetinbits1557__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2178         int __leftop1558__ = 32;
2179         int __leftop1560__ = 32;
2180         int __leftop1562__ = 32;
2181         int __leftop1564__ = 32;
2182         int __leftop1566__ = 32;
2183         int __rightop1567__ = 0;
2184         int __rightop1565__ = __leftop1566__ + __rightop1567__;
2185         int __rightop1563__ = __leftop1564__ + __rightop1565__;
2186         int __rightop1561__ = __leftop1562__ + __rightop1563__;
2187         int __rightop1559__ = __leftop1560__ + __rightop1561__;
2188         int __offsetinbits1557__ = __leftop1558__ + __rightop1559__;
2189         // __offsetinbits1557__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2190         int __offset1568__ = __offsetinbits1557__ >> 3;
2191         int __shift1569__ = __offsetinbits1557__ - (__offset1568__ << 3);
2192         int __rightop1540__ = ((*(int *)(__left1541__ + __offset1568__))  >> __shift1569__) & 0xffffffff;
2193         int __leftop1538__ = __leftop1539__ * __rightop1540__;
2194         int __rightop1570__ = 0;
2195         int __sizeof1537__ = __leftop1538__ + __rightop1570__;
2196         int __high1571__ = __expr1496__ + __sizeof1537__;
2197         assertvalidmemory(__expr1496__, __high1571__);
2198         int __left1495__ = (int) __expr1496__;
2199         // __left1495__ = cast(__InodeTable__, d.b[itb])
2200         // __offsetinbits1572__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2201         int __leftop1573__ = 0;
2202         int __leftop1576__ = 32;
2203         int __leftop1579__ = 32;
2204         int __rightop1580__ = 12;
2205         int __leftop1578__ = __leftop1579__ * __rightop1580__;
2206         int __leftop1582__ = 32;
2207         int __rightop1583__ = 0;
2208         int __rightop1581__ = __leftop1582__ + __rightop1583__;
2209         int __rightop1577__ = __leftop1578__ + __rightop1581__;
2210         int __leftop1575__ = __leftop1576__ + __rightop1577__;
2211         int __rightop1584__ = (int) __i__; //varexpr
2212         int __rightop1574__ = __leftop1575__ * __rightop1584__;
2213         int __offsetinbits1572__ = __leftop1573__ + __rightop1574__;
2214         // __offsetinbits1572__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2215         int __offset1585__ = __offsetinbits1572__ >> 3;
2216         int __left1494__ = (__left1495__ + __offset1585__);
2217         int __leftop1587__ = 32;
2218         int __leftop1590__ = 32;
2219         int __rightop1591__ = 12;
2220         int __leftop1589__ = __leftop1590__ * __rightop1591__;
2221         int __leftop1593__ = 32;
2222         int __rightop1594__ = 0;
2223         int __rightop1592__ = __leftop1593__ + __rightop1594__;
2224         int __rightop1588__ = __leftop1589__ + __rightop1592__;
2225         int __sizeof1586__ = __leftop1587__ + __rightop1588__;
2226         int __high1595__ = __left1494__ + __sizeof1586__;
2227         assertvalidmemory(__left1494__, __high1595__);
2228         // __left1494__ = cast(__InodeTable__, d.b[itb]).itable[i]
2229         // __offsetinbits1596__ <-- ((32 + 0) + (32 * j))
2230         int __leftop1598__ = 32;
2231         int __rightop1599__ = 0;
2232         int __leftop1597__ = __leftop1598__ + __rightop1599__;
2233         int __leftop1601__ = 32;
2234         int __rightop1602__ = (int) __j__; //varexpr
2235         int __rightop1600__ = __leftop1601__ * __rightop1602__;
2236         int __offsetinbits1596__ = __leftop1597__ + __rightop1600__;
2237         // __offsetinbits1596__ = ((32 + 0) + (32 * j))
2238         int __offset1603__ = __offsetinbits1596__ >> 3;
2239         int __shift1604__ = __offsetinbits1596__ - (__offset1603__ << 3);
2240         int __leftop1493__ = ((*(int *)(__left1494__ + __offset1603__))  >> __shift1604__) & 0xffffffff;
2241         int __rightop1605__ = 0;
2242         int __leftop1492__ = __leftop1493__ == __rightop1605__;
2243         int __rightop1491__ = !__leftop1492__;
2244         int __tempvar1353__ = __leftop1354__ && __rightop1491__;
2245         if (__tempvar1353__)
2246           {
2247           // __left1607__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2248           // __left1608__ <-- cast(__InodeTable__, d.b[itb])
2249           // __left1610__ <-- d
2250           int __left1610__ = (int) d; //varexpr
2251           // __left1610__ = d
2252           // __offsetinbits1611__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2253           int __leftop1612__ = 0;
2254           int __leftop1616__ = 8;
2255           // __left1618__ <-- d.s
2256           // __left1619__ <-- d
2257           int __left1619__ = (int) d; //varexpr
2258           // __left1619__ = d
2259           int __left1618__ = (__left1619__ + 0);
2260           int __leftop1621__ = 32;
2261           int __leftop1623__ = 32;
2262           int __leftop1625__ = 32;
2263           int __leftop1627__ = 32;
2264           int __leftop1629__ = 32;
2265           int __leftop1631__ = 32;
2266           int __rightop1632__ = 0;
2267           int __rightop1630__ = __leftop1631__ + __rightop1632__;
2268           int __rightop1628__ = __leftop1629__ + __rightop1630__;
2269           int __rightop1626__ = __leftop1627__ + __rightop1628__;
2270           int __rightop1624__ = __leftop1625__ + __rightop1626__;
2271           int __rightop1622__ = __leftop1623__ + __rightop1624__;
2272           int __sizeof1620__ = __leftop1621__ + __rightop1622__;
2273           int __high1633__ = __left1618__ + __sizeof1620__;
2274           assertvalidmemory(__left1618__, __high1633__);
2275           // __left1618__ = d.s
2276           // __offsetinbits1634__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2277           int __leftop1635__ = 32;
2278           int __leftop1637__ = 32;
2279           int __leftop1639__ = 32;
2280           int __leftop1641__ = 32;
2281           int __leftop1643__ = 32;
2282           int __rightop1644__ = 0;
2283           int __rightop1642__ = __leftop1643__ + __rightop1644__;
2284           int __rightop1640__ = __leftop1641__ + __rightop1642__;
2285           int __rightop1638__ = __leftop1639__ + __rightop1640__;
2286           int __rightop1636__ = __leftop1637__ + __rightop1638__;
2287           int __offsetinbits1634__ = __leftop1635__ + __rightop1636__;
2288           // __offsetinbits1634__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2289           int __offset1645__ = __offsetinbits1634__ >> 3;
2290           int __shift1646__ = __offsetinbits1634__ - (__offset1645__ << 3);
2291           int __rightop1617__ = ((*(int *)(__left1618__ + __offset1645__))  >> __shift1646__) & 0xffffffff;
2292           int __leftop1615__ = __leftop1616__ * __rightop1617__;
2293           int __rightop1647__ = 0;
2294           int __leftop1614__ = __leftop1615__ + __rightop1647__;
2295           int __rightop1648__ = (int) __itb__; //varexpr
2296           int __rightop1613__ = __leftop1614__ * __rightop1648__;
2297           int __offsetinbits1611__ = __leftop1612__ + __rightop1613__;
2298           // __offsetinbits1611__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2299           int __offset1649__ = __offsetinbits1611__ >> 3;
2300           int __expr1609__ = (__left1610__ + __offset1649__);
2301           int __leftop1652__ = 8;
2302           // __left1654__ <-- d.s
2303           // __left1655__ <-- d
2304           int __left1655__ = (int) d; //varexpr
2305           // __left1655__ = d
2306           int __left1654__ = (__left1655__ + 0);
2307           int __leftop1657__ = 32;
2308           int __leftop1659__ = 32;
2309           int __leftop1661__ = 32;
2310           int __leftop1663__ = 32;
2311           int __leftop1665__ = 32;
2312           int __leftop1667__ = 32;
2313           int __rightop1668__ = 0;
2314           int __rightop1666__ = __leftop1667__ + __rightop1668__;
2315           int __rightop1664__ = __leftop1665__ + __rightop1666__;
2316           int __rightop1662__ = __leftop1663__ + __rightop1664__;
2317           int __rightop1660__ = __leftop1661__ + __rightop1662__;
2318           int __rightop1658__ = __leftop1659__ + __rightop1660__;
2319           int __sizeof1656__ = __leftop1657__ + __rightop1658__;
2320           int __high1669__ = __left1654__ + __sizeof1656__;
2321           assertvalidmemory(__left1654__, __high1669__);
2322           // __left1654__ = d.s
2323           // __offsetinbits1670__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2324           int __leftop1671__ = 32;
2325           int __leftop1673__ = 32;
2326           int __leftop1675__ = 32;
2327           int __leftop1677__ = 32;
2328           int __leftop1679__ = 32;
2329           int __rightop1680__ = 0;
2330           int __rightop1678__ = __leftop1679__ + __rightop1680__;
2331           int __rightop1676__ = __leftop1677__ + __rightop1678__;
2332           int __rightop1674__ = __leftop1675__ + __rightop1676__;
2333           int __rightop1672__ = __leftop1673__ + __rightop1674__;
2334           int __offsetinbits1670__ = __leftop1671__ + __rightop1672__;
2335           // __offsetinbits1670__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2336           int __offset1681__ = __offsetinbits1670__ >> 3;
2337           int __shift1682__ = __offsetinbits1670__ - (__offset1681__ << 3);
2338           int __rightop1653__ = ((*(int *)(__left1654__ + __offset1681__))  >> __shift1682__) & 0xffffffff;
2339           int __leftop1651__ = __leftop1652__ * __rightop1653__;
2340           int __rightop1683__ = 0;
2341           int __sizeof1650__ = __leftop1651__ + __rightop1683__;
2342           int __high1684__ = __expr1609__ + __sizeof1650__;
2343           assertvalidmemory(__expr1609__, __high1684__);
2344           int __left1608__ = (int) __expr1609__;
2345           // __left1608__ = cast(__InodeTable__, d.b[itb])
2346           // __offsetinbits1685__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2347           int __leftop1686__ = 0;
2348           int __leftop1689__ = 32;
2349           int __leftop1692__ = 32;
2350           int __rightop1693__ = 12;
2351           int __leftop1691__ = __leftop1692__ * __rightop1693__;
2352           int __leftop1695__ = 32;
2353           int __rightop1696__ = 0;
2354           int __rightop1694__ = __leftop1695__ + __rightop1696__;
2355           int __rightop1690__ = __leftop1691__ + __rightop1694__;
2356           int __leftop1688__ = __leftop1689__ + __rightop1690__;
2357           int __rightop1697__ = (int) __i__; //varexpr
2358           int __rightop1687__ = __leftop1688__ * __rightop1697__;
2359           int __offsetinbits1685__ = __leftop1686__ + __rightop1687__;
2360           // __offsetinbits1685__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2361           int __offset1698__ = __offsetinbits1685__ >> 3;
2362           int __left1607__ = (__left1608__ + __offset1698__);
2363           int __leftop1700__ = 32;
2364           int __leftop1703__ = 32;
2365           int __rightop1704__ = 12;
2366           int __leftop1702__ = __leftop1703__ * __rightop1704__;
2367           int __leftop1706__ = 32;
2368           int __rightop1707__ = 0;
2369           int __rightop1705__ = __leftop1706__ + __rightop1707__;
2370           int __rightop1701__ = __leftop1702__ + __rightop1705__;
2371           int __sizeof1699__ = __leftop1700__ + __rightop1701__;
2372           int __high1708__ = __left1607__ + __sizeof1699__;
2373           assertvalidmemory(__left1607__, __high1708__);
2374           // __left1607__ = cast(__InodeTable__, d.b[itb]).itable[i]
2375           // __offsetinbits1709__ <-- ((32 + 0) + (32 * j))
2376           int __leftop1711__ = 32;
2377           int __rightop1712__ = 0;
2378           int __leftop1710__ = __leftop1711__ + __rightop1712__;
2379           int __leftop1714__ = 32;
2380           int __rightop1715__ = (int) __j__; //varexpr
2381           int __rightop1713__ = __leftop1714__ * __rightop1715__;
2382           int __offsetinbits1709__ = __leftop1710__ + __rightop1713__;
2383           // __offsetinbits1709__ = ((32 + 0) + (32 * j))
2384           int __offset1716__ = __offsetinbits1709__ >> 3;
2385           int __shift1717__ = __offsetinbits1709__ - (__offset1716__ << 3);
2386           int __element1606__ = ((*(int *)(__left1607__ + __offset1716__))  >> __shift1717__) & 0xffffffff;
2387           __FileBlock___hash->add((int)__element1606__, (int)__element1606__);
2388           }
2389         }
2390       }
2391     }
2392   }
2393
2394
2395 // build rule8
2396   {
2397   int __tempvar1718__ = 0;
2398   // __left1721__ <-- d.s
2399   // __left1722__ <-- d
2400   int __left1722__ = (int) d; //varexpr
2401   // __left1722__ = d
2402   int __left1721__ = (__left1722__ + 0);
2403   int __leftop1724__ = 32;
2404   int __leftop1726__ = 32;
2405   int __leftop1728__ = 32;
2406   int __leftop1730__ = 32;
2407   int __leftop1732__ = 32;
2408   int __leftop1734__ = 32;
2409   int __rightop1735__ = 0;
2410   int __rightop1733__ = __leftop1734__ + __rightop1735__;
2411   int __rightop1731__ = __leftop1732__ + __rightop1733__;
2412   int __rightop1729__ = __leftop1730__ + __rightop1731__;
2413   int __rightop1727__ = __leftop1728__ + __rightop1729__;
2414   int __rightop1725__ = __leftop1726__ + __rightop1727__;
2415   int __sizeof1723__ = __leftop1724__ + __rightop1725__;
2416   int __high1736__ = __left1721__ + __sizeof1723__;
2417   assertvalidmemory(__left1721__, __high1736__);
2418   // __left1721__ = d.s
2419   // __offsetinbits1737__ <-- (32 + (32 + 0))
2420   int __leftop1738__ = 32;
2421   int __leftop1740__ = 32;
2422   int __rightop1741__ = 0;
2423   int __rightop1739__ = __leftop1740__ + __rightop1741__;
2424   int __offsetinbits1737__ = __leftop1738__ + __rightop1739__;
2425   // __offsetinbits1737__ = (32 + (32 + 0))
2426   int __offset1742__ = __offsetinbits1737__ >> 3;
2427   int __shift1743__ = __offsetinbits1737__ - (__offset1742__ << 3);
2428   int __leftop1720__ = ((*(int *)(__left1721__ + __offset1742__))  >> __shift1743__) & 0xffffffff;
2429   int __rightop1744__ = 1;
2430   int __tempvar1719__ = __leftop1720__ - __rightop1744__;
2431   for (int __j__ = __tempvar1718__; __j__ <= __tempvar1719__; __j__++)
2432     {
2433     //(j in? __UsedBlock__)
2434     int __element1747__ = (int) __j__; //varexpr
2435     int __leftop1746__ = __UsedBlock___hash->contains(__element1747__);
2436     int __tempvar1745__ = !__leftop1746__;
2437     if (__tempvar1745__)
2438       {
2439       int __element1748__ = (int) __j__; //varexpr
2440       __FreeBlock___hash->add((int)__element1748__, (int)__element1748__);
2441       }
2442     }
2443   }
2444
2445
2446 // build rule10
2447   {
2448   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
2449     {
2450     int __i__ = (int) __i___iterator->next();
2451     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
2452       {
2453       int __itb__ = (int) __itb___iterator->next();
2454       int __tempvar1749__ = 0;
2455       int __tempvar1750__ = 11;
2456       for (int __j__ = __tempvar1749__; __j__ <= __tempvar1750__; __j__++)
2457         {
2458         //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0))
2459         // __left1754__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2460         // __left1755__ <-- cast(__InodeTable__, d.b[itb])
2461         // __left1757__ <-- d
2462         int __left1757__ = (int) d; //varexpr
2463         // __left1757__ = d
2464         // __offsetinbits1758__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2465         int __leftop1759__ = 0;
2466         int __leftop1763__ = 8;
2467         // __left1765__ <-- d.s
2468         // __left1766__ <-- d
2469         int __left1766__ = (int) d; //varexpr
2470         // __left1766__ = d
2471         int __left1765__ = (__left1766__ + 0);
2472         int __leftop1768__ = 32;
2473         int __leftop1770__ = 32;
2474         int __leftop1772__ = 32;
2475         int __leftop1774__ = 32;
2476         int __leftop1776__ = 32;
2477         int __leftop1778__ = 32;
2478         int __rightop1779__ = 0;
2479         int __rightop1777__ = __leftop1778__ + __rightop1779__;
2480         int __rightop1775__ = __leftop1776__ + __rightop1777__;
2481         int __rightop1773__ = __leftop1774__ + __rightop1775__;
2482         int __rightop1771__ = __leftop1772__ + __rightop1773__;
2483         int __rightop1769__ = __leftop1770__ + __rightop1771__;
2484         int __sizeof1767__ = __leftop1768__ + __rightop1769__;
2485         int __high1780__ = __left1765__ + __sizeof1767__;
2486         assertvalidmemory(__left1765__, __high1780__);
2487         // __left1765__ = d.s
2488         // __offsetinbits1781__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2489         int __leftop1782__ = 32;
2490         int __leftop1784__ = 32;
2491         int __leftop1786__ = 32;
2492         int __leftop1788__ = 32;
2493         int __leftop1790__ = 32;
2494         int __rightop1791__ = 0;
2495         int __rightop1789__ = __leftop1790__ + __rightop1791__;
2496         int __rightop1787__ = __leftop1788__ + __rightop1789__;
2497         int __rightop1785__ = __leftop1786__ + __rightop1787__;
2498         int __rightop1783__ = __leftop1784__ + __rightop1785__;
2499         int __offsetinbits1781__ = __leftop1782__ + __rightop1783__;
2500         // __offsetinbits1781__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2501         int __offset1792__ = __offsetinbits1781__ >> 3;
2502         int __shift1793__ = __offsetinbits1781__ - (__offset1792__ << 3);
2503         int __rightop1764__ = ((*(int *)(__left1765__ + __offset1792__))  >> __shift1793__) & 0xffffffff;
2504         int __leftop1762__ = __leftop1763__ * __rightop1764__;
2505         int __rightop1794__ = 0;
2506         int __leftop1761__ = __leftop1762__ + __rightop1794__;
2507         int __rightop1795__ = (int) __itb__; //varexpr
2508         int __rightop1760__ = __leftop1761__ * __rightop1795__;
2509         int __offsetinbits1758__ = __leftop1759__ + __rightop1760__;
2510         // __offsetinbits1758__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2511         int __offset1796__ = __offsetinbits1758__ >> 3;
2512         int __expr1756__ = (__left1757__ + __offset1796__);
2513         int __leftop1799__ = 8;
2514         // __left1801__ <-- d.s
2515         // __left1802__ <-- d
2516         int __left1802__ = (int) d; //varexpr
2517         // __left1802__ = d
2518         int __left1801__ = (__left1802__ + 0);
2519         int __leftop1804__ = 32;
2520         int __leftop1806__ = 32;
2521         int __leftop1808__ = 32;
2522         int __leftop1810__ = 32;
2523         int __leftop1812__ = 32;
2524         int __leftop1814__ = 32;
2525         int __rightop1815__ = 0;
2526         int __rightop1813__ = __leftop1814__ + __rightop1815__;
2527         int __rightop1811__ = __leftop1812__ + __rightop1813__;
2528         int __rightop1809__ = __leftop1810__ + __rightop1811__;
2529         int __rightop1807__ = __leftop1808__ + __rightop1809__;
2530         int __rightop1805__ = __leftop1806__ + __rightop1807__;
2531         int __sizeof1803__ = __leftop1804__ + __rightop1805__;
2532         int __high1816__ = __left1801__ + __sizeof1803__;
2533         assertvalidmemory(__left1801__, __high1816__);
2534         // __left1801__ = d.s
2535         // __offsetinbits1817__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2536         int __leftop1818__ = 32;
2537         int __leftop1820__ = 32;
2538         int __leftop1822__ = 32;
2539         int __leftop1824__ = 32;
2540         int __leftop1826__ = 32;
2541         int __rightop1827__ = 0;
2542         int __rightop1825__ = __leftop1826__ + __rightop1827__;
2543         int __rightop1823__ = __leftop1824__ + __rightop1825__;
2544         int __rightop1821__ = __leftop1822__ + __rightop1823__;
2545         int __rightop1819__ = __leftop1820__ + __rightop1821__;
2546         int __offsetinbits1817__ = __leftop1818__ + __rightop1819__;
2547         // __offsetinbits1817__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2548         int __offset1828__ = __offsetinbits1817__ >> 3;
2549         int __shift1829__ = __offsetinbits1817__ - (__offset1828__ << 3);
2550         int __rightop1800__ = ((*(int *)(__left1801__ + __offset1828__))  >> __shift1829__) & 0xffffffff;
2551         int __leftop1798__ = __leftop1799__ * __rightop1800__;
2552         int __rightop1830__ = 0;
2553         int __sizeof1797__ = __leftop1798__ + __rightop1830__;
2554         int __high1831__ = __expr1756__ + __sizeof1797__;
2555         assertvalidmemory(__expr1756__, __high1831__);
2556         int __left1755__ = (int) __expr1756__;
2557         // __left1755__ = cast(__InodeTable__, d.b[itb])
2558         // __offsetinbits1832__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2559         int __leftop1833__ = 0;
2560         int __leftop1836__ = 32;
2561         int __leftop1839__ = 32;
2562         int __rightop1840__ = 12;
2563         int __leftop1838__ = __leftop1839__ * __rightop1840__;
2564         int __leftop1842__ = 32;
2565         int __rightop1843__ = 0;
2566         int __rightop1841__ = __leftop1842__ + __rightop1843__;
2567         int __rightop1837__ = __leftop1838__ + __rightop1841__;
2568         int __leftop1835__ = __leftop1836__ + __rightop1837__;
2569         int __rightop1844__ = (int) __i__; //varexpr
2570         int __rightop1834__ = __leftop1835__ * __rightop1844__;
2571         int __offsetinbits1832__ = __leftop1833__ + __rightop1834__;
2572         // __offsetinbits1832__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2573         int __offset1845__ = __offsetinbits1832__ >> 3;
2574         int __left1754__ = (__left1755__ + __offset1845__);
2575         int __leftop1847__ = 32;
2576         int __leftop1850__ = 32;
2577         int __rightop1851__ = 12;
2578         int __leftop1849__ = __leftop1850__ * __rightop1851__;
2579         int __leftop1853__ = 32;
2580         int __rightop1854__ = 0;
2581         int __rightop1852__ = __leftop1853__ + __rightop1854__;
2582         int __rightop1848__ = __leftop1849__ + __rightop1852__;
2583         int __sizeof1846__ = __leftop1847__ + __rightop1848__;
2584         int __high1855__ = __left1754__ + __sizeof1846__;
2585         assertvalidmemory(__left1754__, __high1855__);
2586         // __left1754__ = cast(__InodeTable__, d.b[itb]).itable[i]
2587         // __offsetinbits1856__ <-- ((32 + 0) + (32 * j))
2588         int __leftop1858__ = 32;
2589         int __rightop1859__ = 0;
2590         int __leftop1857__ = __leftop1858__ + __rightop1859__;
2591         int __leftop1861__ = 32;
2592         int __rightop1862__ = (int) __j__; //varexpr
2593         int __rightop1860__ = __leftop1861__ * __rightop1862__;
2594         int __offsetinbits1856__ = __leftop1857__ + __rightop1860__;
2595         // __offsetinbits1856__ = ((32 + 0) + (32 * j))
2596         int __offset1863__ = __offsetinbits1856__ >> 3;
2597         int __shift1864__ = __offsetinbits1856__ - (__offset1863__ << 3);
2598         int __leftop1753__ = ((*(int *)(__left1754__ + __offset1863__))  >> __shift1864__) & 0xffffffff;
2599         int __rightop1865__ = 0;
2600         int __leftop1752__ = __leftop1753__ == __rightop1865__;
2601         int __tempvar1751__ = !__leftop1752__;
2602         if (__tempvar1751__)
2603           {
2604           int __leftele1866__ = (int) __i__; //varexpr
2605           // __left1868__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
2606           // __left1869__ <-- cast(__InodeTable__, d.b[itb])
2607           // __left1871__ <-- d
2608           int __left1871__ = (int) d; //varexpr
2609           // __left1871__ = d
2610           // __offsetinbits1872__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2611           int __leftop1873__ = 0;
2612           int __leftop1877__ = 8;
2613           // __left1879__ <-- d.s
2614           // __left1880__ <-- d
2615           int __left1880__ = (int) d; //varexpr
2616           // __left1880__ = d
2617           int __left1879__ = (__left1880__ + 0);
2618           int __leftop1882__ = 32;
2619           int __leftop1884__ = 32;
2620           int __leftop1886__ = 32;
2621           int __leftop1888__ = 32;
2622           int __leftop1890__ = 32;
2623           int __leftop1892__ = 32;
2624           int __rightop1893__ = 0;
2625           int __rightop1891__ = __leftop1892__ + __rightop1893__;
2626           int __rightop1889__ = __leftop1890__ + __rightop1891__;
2627           int __rightop1887__ = __leftop1888__ + __rightop1889__;
2628           int __rightop1885__ = __leftop1886__ + __rightop1887__;
2629           int __rightop1883__ = __leftop1884__ + __rightop1885__;
2630           int __sizeof1881__ = __leftop1882__ + __rightop1883__;
2631           int __high1894__ = __left1879__ + __sizeof1881__;
2632           assertvalidmemory(__left1879__, __high1894__);
2633           // __left1879__ = d.s
2634           // __offsetinbits1895__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2635           int __leftop1896__ = 32;
2636           int __leftop1898__ = 32;
2637           int __leftop1900__ = 32;
2638           int __leftop1902__ = 32;
2639           int __leftop1904__ = 32;
2640           int __rightop1905__ = 0;
2641           int __rightop1903__ = __leftop1904__ + __rightop1905__;
2642           int __rightop1901__ = __leftop1902__ + __rightop1903__;
2643           int __rightop1899__ = __leftop1900__ + __rightop1901__;
2644           int __rightop1897__ = __leftop1898__ + __rightop1899__;
2645           int __offsetinbits1895__ = __leftop1896__ + __rightop1897__;
2646           // __offsetinbits1895__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2647           int __offset1906__ = __offsetinbits1895__ >> 3;
2648           int __shift1907__ = __offsetinbits1895__ - (__offset1906__ << 3);
2649           int __rightop1878__ = ((*(int *)(__left1879__ + __offset1906__))  >> __shift1907__) & 0xffffffff;
2650           int __leftop1876__ = __leftop1877__ * __rightop1878__;
2651           int __rightop1908__ = 0;
2652           int __leftop1875__ = __leftop1876__ + __rightop1908__;
2653           int __rightop1909__ = (int) __itb__; //varexpr
2654           int __rightop1874__ = __leftop1875__ * __rightop1909__;
2655           int __offsetinbits1872__ = __leftop1873__ + __rightop1874__;
2656           // __offsetinbits1872__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2657           int __offset1910__ = __offsetinbits1872__ >> 3;
2658           int __expr1870__ = (__left1871__ + __offset1910__);
2659           int __leftop1913__ = 8;
2660           // __left1915__ <-- d.s
2661           // __left1916__ <-- d
2662           int __left1916__ = (int) d; //varexpr
2663           // __left1916__ = d
2664           int __left1915__ = (__left1916__ + 0);
2665           int __leftop1918__ = 32;
2666           int __leftop1920__ = 32;
2667           int __leftop1922__ = 32;
2668           int __leftop1924__ = 32;
2669           int __leftop1926__ = 32;
2670           int __leftop1928__ = 32;
2671           int __rightop1929__ = 0;
2672           int __rightop1927__ = __leftop1928__ + __rightop1929__;
2673           int __rightop1925__ = __leftop1926__ + __rightop1927__;
2674           int __rightop1923__ = __leftop1924__ + __rightop1925__;
2675           int __rightop1921__ = __leftop1922__ + __rightop1923__;
2676           int __rightop1919__ = __leftop1920__ + __rightop1921__;
2677           int __sizeof1917__ = __leftop1918__ + __rightop1919__;
2678           int __high1930__ = __left1915__ + __sizeof1917__;
2679           assertvalidmemory(__left1915__, __high1930__);
2680           // __left1915__ = d.s
2681           // __offsetinbits1931__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2682           int __leftop1932__ = 32;
2683           int __leftop1934__ = 32;
2684           int __leftop1936__ = 32;
2685           int __leftop1938__ = 32;
2686           int __leftop1940__ = 32;
2687           int __rightop1941__ = 0;
2688           int __rightop1939__ = __leftop1940__ + __rightop1941__;
2689           int __rightop1937__ = __leftop1938__ + __rightop1939__;
2690           int __rightop1935__ = __leftop1936__ + __rightop1937__;
2691           int __rightop1933__ = __leftop1934__ + __rightop1935__;
2692           int __offsetinbits1931__ = __leftop1932__ + __rightop1933__;
2693           // __offsetinbits1931__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2694           int __offset1942__ = __offsetinbits1931__ >> 3;
2695           int __shift1943__ = __offsetinbits1931__ - (__offset1942__ << 3);
2696           int __rightop1914__ = ((*(int *)(__left1915__ + __offset1942__))  >> __shift1943__) & 0xffffffff;
2697           int __leftop1912__ = __leftop1913__ * __rightop1914__;
2698           int __rightop1944__ = 0;
2699           int __sizeof1911__ = __leftop1912__ + __rightop1944__;
2700           int __high1945__ = __expr1870__ + __sizeof1911__;
2701           assertvalidmemory(__expr1870__, __high1945__);
2702           int __left1869__ = (int) __expr1870__;
2703           // __left1869__ = cast(__InodeTable__, d.b[itb])
2704           // __offsetinbits1946__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2705           int __leftop1947__ = 0;
2706           int __leftop1950__ = 32;
2707           int __leftop1953__ = 32;
2708           int __rightop1954__ = 12;
2709           int __leftop1952__ = __leftop1953__ * __rightop1954__;
2710           int __leftop1956__ = 32;
2711           int __rightop1957__ = 0;
2712           int __rightop1955__ = __leftop1956__ + __rightop1957__;
2713           int __rightop1951__ = __leftop1952__ + __rightop1955__;
2714           int __leftop1949__ = __leftop1950__ + __rightop1951__;
2715           int __rightop1958__ = (int) __i__; //varexpr
2716           int __rightop1948__ = __leftop1949__ * __rightop1958__;
2717           int __offsetinbits1946__ = __leftop1947__ + __rightop1948__;
2718           // __offsetinbits1946__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
2719           int __offset1959__ = __offsetinbits1946__ >> 3;
2720           int __left1868__ = (__left1869__ + __offset1959__);
2721           int __leftop1961__ = 32;
2722           int __leftop1964__ = 32;
2723           int __rightop1965__ = 12;
2724           int __leftop1963__ = __leftop1964__ * __rightop1965__;
2725           int __leftop1967__ = 32;
2726           int __rightop1968__ = 0;
2727           int __rightop1966__ = __leftop1967__ + __rightop1968__;
2728           int __rightop1962__ = __leftop1963__ + __rightop1966__;
2729           int __sizeof1960__ = __leftop1961__ + __rightop1962__;
2730           int __high1969__ = __left1868__ + __sizeof1960__;
2731           assertvalidmemory(__left1868__, __high1969__);
2732           // __left1868__ = cast(__InodeTable__, d.b[itb]).itable[i]
2733           // __offsetinbits1970__ <-- ((32 + 0) + (32 * j))
2734           int __leftop1972__ = 32;
2735           int __rightop1973__ = 0;
2736           int __leftop1971__ = __leftop1972__ + __rightop1973__;
2737           int __leftop1975__ = 32;
2738           int __rightop1976__ = (int) __j__; //varexpr
2739           int __rightop1974__ = __leftop1975__ * __rightop1976__;
2740           int __offsetinbits1970__ = __leftop1971__ + __rightop1974__;
2741           // __offsetinbits1970__ = ((32 + 0) + (32 * j))
2742           int __offset1977__ = __offsetinbits1970__ >> 3;
2743           int __shift1978__ = __offsetinbits1970__ - (__offset1977__ << 3);
2744           int __rightele1867__ = ((*(int *)(__left1868__ + __offset1977__))  >> __shift1978__) & 0xffffffff;
2745           __contents___hash->add((int)__leftele1866__, (int)__rightele1867__);
2746           __contents___hashinv->add((int)__rightele1867__, (int)__leftele1866__);
2747           }
2748         }
2749       }
2750     }
2751   }
2752
2753
2754 // build rule7
2755   {
2756   int __tempvar1980__ = 0;
2757   // __left1983__ <-- d.s
2758   // __left1984__ <-- d
2759   int __left1984__ = (int) d; //varexpr
2760   // __left1984__ = d
2761   int __left1983__ = (__left1984__ + 0);
2762   int __leftop1986__ = 32;
2763   int __leftop1988__ = 32;
2764   int __leftop1990__ = 32;
2765   int __leftop1992__ = 32;
2766   int __leftop1994__ = 32;
2767   int __leftop1996__ = 32;
2768   int __rightop1997__ = 0;
2769   int __rightop1995__ = __leftop1996__ + __rightop1997__;
2770   int __rightop1993__ = __leftop1994__ + __rightop1995__;
2771   int __rightop1991__ = __leftop1992__ + __rightop1993__;
2772   int __rightop1989__ = __leftop1990__ + __rightop1991__;
2773   int __rightop1987__ = __leftop1988__ + __rightop1989__;
2774   int __sizeof1985__ = __leftop1986__ + __rightop1987__;
2775   int __high1998__ = __left1983__ + __sizeof1985__;
2776   assertvalidmemory(__left1983__, __high1998__);
2777   // __left1983__ = d.s
2778   // __offsetinbits1999__ <-- (32 + (32 + (32 + 0)))
2779   int __leftop2000__ = 32;
2780   int __leftop2002__ = 32;
2781   int __leftop2004__ = 32;
2782   int __rightop2005__ = 0;
2783   int __rightop2003__ = __leftop2004__ + __rightop2005__;
2784   int __rightop2001__ = __leftop2002__ + __rightop2003__;
2785   int __offsetinbits1999__ = __leftop2000__ + __rightop2001__;
2786   // __offsetinbits1999__ = (32 + (32 + (32 + 0)))
2787   int __offset2006__ = __offsetinbits1999__ >> 3;
2788   int __shift2007__ = __offsetinbits1999__ - (__offset2006__ << 3);
2789   int __leftop1982__ = ((*(int *)(__left1983__ + __offset2006__))  >> __shift2007__) & 0xffffffff;
2790   int __rightop2008__ = 1;
2791   int __tempvar1981__ = __leftop1982__ - __rightop2008__;
2792   for (int __j__ = __tempvar1980__; __j__ <= __tempvar1981__; __j__++)
2793     {
2794     //(j in? __UsedInode__)
2795     int __element2011__ = (int) __j__; //varexpr
2796     int __leftop2010__ = __UsedInode___hash->contains(__element2011__);
2797     int __tempvar2009__ = !__leftop2010__;
2798     if (__tempvar2009__)
2799       {
2800       int __element2012__ = (int) __j__; //varexpr
2801       __FreeInode___hash->add((int)__element2012__, (int)__element2012__);
2802       }
2803     }
2804   }
2805
2806
2807 // build rule17
2808   {
2809   for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); )
2810     {
2811     int __j__ = (int) __j___iterator->next();
2812     for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
2813       {
2814       int __itb__ = (int) __itb___iterator->next();
2815       //true
2816       int __tempvar2013__ = 1;
2817       if (__tempvar2013__)
2818         {
2819         int __leftele2014__ = (int) __j__; //varexpr
2820         // __left2016__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
2821         // __left2017__ <-- cast(__InodeTable__, d.b[itb])
2822         // __left2019__ <-- d
2823         int __left2019__ = (int) d; //varexpr
2824         // __left2019__ = d
2825         // __offsetinbits2020__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
2826         int __leftop2021__ = 0;
2827         int __leftop2025__ = 8;
2828         // __left2027__ <-- d.s
2829         // __left2028__ <-- d
2830         int __left2028__ = (int) d; //varexpr
2831         // __left2028__ = d
2832         int __left2027__ = (__left2028__ + 0);
2833         int __leftop2030__ = 32;
2834         int __leftop2032__ = 32;
2835         int __leftop2034__ = 32;
2836         int __leftop2036__ = 32;
2837         int __leftop2038__ = 32;
2838         int __leftop2040__ = 32;
2839         int __rightop2041__ = 0;
2840         int __rightop2039__ = __leftop2040__ + __rightop2041__;
2841         int __rightop2037__ = __leftop2038__ + __rightop2039__;
2842         int __rightop2035__ = __leftop2036__ + __rightop2037__;
2843         int __rightop2033__ = __leftop2034__ + __rightop2035__;
2844         int __rightop2031__ = __leftop2032__ + __rightop2033__;
2845         int __sizeof2029__ = __leftop2030__ + __rightop2031__;
2846         int __high2042__ = __left2027__ + __sizeof2029__;
2847         assertvalidmemory(__left2027__, __high2042__);
2848         // __left2027__ = d.s
2849         // __offsetinbits2043__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2850         int __leftop2044__ = 32;
2851         int __leftop2046__ = 32;
2852         int __leftop2048__ = 32;
2853         int __leftop2050__ = 32;
2854         int __leftop2052__ = 32;
2855         int __rightop2053__ = 0;
2856         int __rightop2051__ = __leftop2052__ + __rightop2053__;
2857         int __rightop2049__ = __leftop2050__ + __rightop2051__;
2858         int __rightop2047__ = __leftop2048__ + __rightop2049__;
2859         int __rightop2045__ = __leftop2046__ + __rightop2047__;
2860         int __offsetinbits2043__ = __leftop2044__ + __rightop2045__;
2861         // __offsetinbits2043__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2862         int __offset2054__ = __offsetinbits2043__ >> 3;
2863         int __shift2055__ = __offsetinbits2043__ - (__offset2054__ << 3);
2864         int __rightop2026__ = ((*(int *)(__left2027__ + __offset2054__))  >> __shift2055__) & 0xffffffff;
2865         int __leftop2024__ = __leftop2025__ * __rightop2026__;
2866         int __rightop2056__ = 0;
2867         int __leftop2023__ = __leftop2024__ + __rightop2056__;
2868         int __rightop2057__ = (int) __itb__; //varexpr
2869         int __rightop2022__ = __leftop2023__ * __rightop2057__;
2870         int __offsetinbits2020__ = __leftop2021__ + __rightop2022__;
2871         // __offsetinbits2020__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
2872         int __offset2058__ = __offsetinbits2020__ >> 3;
2873         int __expr2018__ = (__left2019__ + __offset2058__);
2874         int __leftop2061__ = 8;
2875         // __left2063__ <-- d.s
2876         // __left2064__ <-- d
2877         int __left2064__ = (int) d; //varexpr
2878         // __left2064__ = d
2879         int __left2063__ = (__left2064__ + 0);
2880         int __leftop2066__ = 32;
2881         int __leftop2068__ = 32;
2882         int __leftop2070__ = 32;
2883         int __leftop2072__ = 32;
2884         int __leftop2074__ = 32;
2885         int __leftop2076__ = 32;
2886         int __rightop2077__ = 0;
2887         int __rightop2075__ = __leftop2076__ + __rightop2077__;
2888         int __rightop2073__ = __leftop2074__ + __rightop2075__;
2889         int __rightop2071__ = __leftop2072__ + __rightop2073__;
2890         int __rightop2069__ = __leftop2070__ + __rightop2071__;
2891         int __rightop2067__ = __leftop2068__ + __rightop2069__;
2892         int __sizeof2065__ = __leftop2066__ + __rightop2067__;
2893         int __high2078__ = __left2063__ + __sizeof2065__;
2894         assertvalidmemory(__left2063__, __high2078__);
2895         // __left2063__ = d.s
2896         // __offsetinbits2079__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
2897         int __leftop2080__ = 32;
2898         int __leftop2082__ = 32;
2899         int __leftop2084__ = 32;
2900         int __leftop2086__ = 32;
2901         int __leftop2088__ = 32;
2902         int __rightop2089__ = 0;
2903         int __rightop2087__ = __leftop2088__ + __rightop2089__;
2904         int __rightop2085__ = __leftop2086__ + __rightop2087__;
2905         int __rightop2083__ = __leftop2084__ + __rightop2085__;
2906         int __rightop2081__ = __leftop2082__ + __rightop2083__;
2907         int __offsetinbits2079__ = __leftop2080__ + __rightop2081__;
2908         // __offsetinbits2079__ = (32 + (32 + (32 + (32 + (32 + 0)))))
2909         int __offset2090__ = __offsetinbits2079__ >> 3;
2910         int __shift2091__ = __offsetinbits2079__ - (__offset2090__ << 3);
2911         int __rightop2062__ = ((*(int *)(__left2063__ + __offset2090__))  >> __shift2091__) & 0xffffffff;
2912         int __leftop2060__ = __leftop2061__ * __rightop2062__;
2913         int __rightop2092__ = 0;
2914         int __sizeof2059__ = __leftop2060__ + __rightop2092__;
2915         int __high2093__ = __expr2018__ + __sizeof2059__;
2916         assertvalidmemory(__expr2018__, __high2093__);
2917         int __left2017__ = (int) __expr2018__;
2918         // __left2017__ = cast(__InodeTable__, d.b[itb])
2919         // __offsetinbits2094__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
2920         int __leftop2095__ = 0;
2921         int __leftop2098__ = 32;
2922         int __leftop2101__ = 32;
2923         int __rightop2102__ = 12;
2924         int __leftop2100__ = __leftop2101__ * __rightop2102__;
2925         int __leftop2104__ = 32;
2926         int __rightop2105__ = 0;
2927         int __rightop2103__ = __leftop2104__ + __rightop2105__;
2928         int __rightop2099__ = __leftop2100__ + __rightop2103__;
2929         int __leftop2097__ = __leftop2098__ + __rightop2099__;
2930         int __rightop2106__ = (int) __j__; //varexpr
2931         int __rightop2096__ = __leftop2097__ * __rightop2106__;
2932         int __offsetinbits2094__ = __leftop2095__ + __rightop2096__;
2933         // __offsetinbits2094__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
2934         int __offset2107__ = __offsetinbits2094__ >> 3;
2935         int __left2016__ = (__left2017__ + __offset2107__);
2936         int __leftop2109__ = 32;
2937         int __leftop2112__ = 32;
2938         int __rightop2113__ = 12;
2939         int __leftop2111__ = __leftop2112__ * __rightop2113__;
2940         int __leftop2115__ = 32;
2941         int __rightop2116__ = 0;
2942         int __rightop2114__ = __leftop2115__ + __rightop2116__;
2943         int __rightop2110__ = __leftop2111__ + __rightop2114__;
2944         int __sizeof2108__ = __leftop2109__ + __rightop2110__;
2945         int __high2117__ = __left2016__ + __sizeof2108__;
2946         assertvalidmemory(__left2016__, __high2117__);
2947         // __left2016__ = cast(__InodeTable__, d.b[itb]).itable[j]
2948         int __rightele2015__ = ((*(int *)(__left2016__ + 0))  >> 0) & 0xffffffff;
2949         __filesize___hash->add((int)__leftele2014__, (int)__rightele2015__);
2950         }
2951       }
2952     }
2953   }
2954
2955
2956 // build rule18
2957   {
2958   int __tempvar2119__ = 0;
2959   // __left2122__ <-- d.s
2960   // __left2123__ <-- d
2961   int __left2123__ = (int) d; //varexpr
2962   // __left2123__ = d
2963   int __left2122__ = (__left2123__ + 0);
2964   int __leftop2125__ = 32;
2965   int __leftop2127__ = 32;
2966   int __leftop2129__ = 32;
2967   int __leftop2131__ = 32;
2968   int __leftop2133__ = 32;
2969   int __leftop2135__ = 32;
2970   int __rightop2136__ = 0;
2971   int __rightop2134__ = __leftop2135__ + __rightop2136__;
2972   int __rightop2132__ = __leftop2133__ + __rightop2134__;
2973   int __rightop2130__ = __leftop2131__ + __rightop2132__;
2974   int __rightop2128__ = __leftop2129__ + __rightop2130__;
2975   int __rightop2126__ = __leftop2127__ + __rightop2128__;
2976   int __sizeof2124__ = __leftop2125__ + __rightop2126__;
2977   int __high2137__ = __left2122__ + __sizeof2124__;
2978   assertvalidmemory(__left2122__, __high2137__);
2979   // __left2122__ = d.s
2980   // __offsetinbits2138__ <-- (32 + (32 + 0))
2981   int __leftop2139__ = 32;
2982   int __leftop2141__ = 32;
2983   int __rightop2142__ = 0;
2984   int __rightop2140__ = __leftop2141__ + __rightop2142__;
2985   int __offsetinbits2138__ = __leftop2139__ + __rightop2140__;
2986   // __offsetinbits2138__ = (32 + (32 + 0))
2987   int __offset2143__ = __offsetinbits2138__ >> 3;
2988   int __shift2144__ = __offsetinbits2138__ - (__offset2143__ << 3);
2989   int __leftop2121__ = ((*(int *)(__left2122__ + __offset2143__))  >> __shift2144__) & 0xffffffff;
2990   int __rightop2145__ = 1;
2991   int __tempvar2120__ = __leftop2121__ - __rightop2145__;
2992   for (int __j__ = __tempvar2119__; __j__ <= __tempvar2120__; __j__++)
2993     {
2994     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); )
2995       {
2996       int __bbb__ = (int) __bbb___iterator->next();
2997       //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == false)
2998       // __left2148__ <-- cast(__BlockBitmap__, d.b[bbb])
2999       // __left2150__ <-- d
3000       int __left2150__ = (int) d; //varexpr
3001       // __left2150__ = d
3002       // __offsetinbits2151__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
3003       int __leftop2152__ = 0;
3004       int __leftop2156__ = 8;
3005       // __left2158__ <-- d.s
3006       // __left2159__ <-- d
3007       int __left2159__ = (int) d; //varexpr
3008       // __left2159__ = d
3009       int __left2158__ = (__left2159__ + 0);
3010       int __leftop2161__ = 32;
3011       int __leftop2163__ = 32;
3012       int __leftop2165__ = 32;
3013       int __leftop2167__ = 32;
3014       int __leftop2169__ = 32;
3015       int __leftop2171__ = 32;
3016       int __rightop2172__ = 0;
3017       int __rightop2170__ = __leftop2171__ + __rightop2172__;
3018       int __rightop2168__ = __leftop2169__ + __rightop2170__;
3019       int __rightop2166__ = __leftop2167__ + __rightop2168__;
3020       int __rightop2164__ = __leftop2165__ + __rightop2166__;
3021       int __rightop2162__ = __leftop2163__ + __rightop2164__;
3022       int __sizeof2160__ = __leftop2161__ + __rightop2162__;
3023       int __high2173__ = __left2158__ + __sizeof2160__;
3024       assertvalidmemory(__left2158__, __high2173__);
3025       // __left2158__ = d.s
3026       // __offsetinbits2174__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3027       int __leftop2175__ = 32;
3028       int __leftop2177__ = 32;
3029       int __leftop2179__ = 32;
3030       int __leftop2181__ = 32;
3031       int __leftop2183__ = 32;
3032       int __rightop2184__ = 0;
3033       int __rightop2182__ = __leftop2183__ + __rightop2184__;
3034       int __rightop2180__ = __leftop2181__ + __rightop2182__;
3035       int __rightop2178__ = __leftop2179__ + __rightop2180__;
3036       int __rightop2176__ = __leftop2177__ + __rightop2178__;
3037       int __offsetinbits2174__ = __leftop2175__ + __rightop2176__;
3038       // __offsetinbits2174__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3039       int __offset2185__ = __offsetinbits2174__ >> 3;
3040       int __shift2186__ = __offsetinbits2174__ - (__offset2185__ << 3);
3041       int __rightop2157__ = ((*(int *)(__left2158__ + __offset2185__))  >> __shift2186__) & 0xffffffff;
3042       int __leftop2155__ = __leftop2156__ * __rightop2157__;
3043       int __rightop2187__ = 0;
3044       int __leftop2154__ = __leftop2155__ + __rightop2187__;
3045       int __rightop2188__ = (int) __bbb__; //varexpr
3046       int __rightop2153__ = __leftop2154__ * __rightop2188__;
3047       int __offsetinbits2151__ = __leftop2152__ + __rightop2153__;
3048       // __offsetinbits2151__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
3049       int __offset2189__ = __offsetinbits2151__ >> 3;
3050       int __expr2149__ = (__left2150__ + __offset2189__);
3051       int __leftop2192__ = 8;
3052       // __left2194__ <-- d.s
3053       // __left2195__ <-- d
3054       int __left2195__ = (int) d; //varexpr
3055       // __left2195__ = d
3056       int __left2194__ = (__left2195__ + 0);
3057       int __leftop2197__ = 32;
3058       int __leftop2199__ = 32;
3059       int __leftop2201__ = 32;
3060       int __leftop2203__ = 32;
3061       int __leftop2205__ = 32;
3062       int __leftop2207__ = 32;
3063       int __rightop2208__ = 0;
3064       int __rightop2206__ = __leftop2207__ + __rightop2208__;
3065       int __rightop2204__ = __leftop2205__ + __rightop2206__;
3066       int __rightop2202__ = __leftop2203__ + __rightop2204__;
3067       int __rightop2200__ = __leftop2201__ + __rightop2202__;
3068       int __rightop2198__ = __leftop2199__ + __rightop2200__;
3069       int __sizeof2196__ = __leftop2197__ + __rightop2198__;
3070       int __high2209__ = __left2194__ + __sizeof2196__;
3071       assertvalidmemory(__left2194__, __high2209__);
3072       // __left2194__ = d.s
3073       // __offsetinbits2210__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3074       int __leftop2211__ = 32;
3075       int __leftop2213__ = 32;
3076       int __leftop2215__ = 32;
3077       int __leftop2217__ = 32;
3078       int __leftop2219__ = 32;
3079       int __rightop2220__ = 0;
3080       int __rightop2218__ = __leftop2219__ + __rightop2220__;
3081       int __rightop2216__ = __leftop2217__ + __rightop2218__;
3082       int __rightop2214__ = __leftop2215__ + __rightop2216__;
3083       int __rightop2212__ = __leftop2213__ + __rightop2214__;
3084       int __offsetinbits2210__ = __leftop2211__ + __rightop2212__;
3085       // __offsetinbits2210__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3086       int __offset2221__ = __offsetinbits2210__ >> 3;
3087       int __shift2222__ = __offsetinbits2210__ - (__offset2221__ << 3);
3088       int __rightop2193__ = ((*(int *)(__left2194__ + __offset2221__))  >> __shift2222__) & 0xffffffff;
3089       int __leftop2191__ = __leftop2192__ * __rightop2193__;
3090       int __rightop2223__ = 0;
3091       int __sizeof2190__ = __leftop2191__ + __rightop2223__;
3092       int __high2224__ = __expr2149__ + __sizeof2190__;
3093       assertvalidmemory(__expr2149__, __high2224__);
3094       int __left2148__ = (int) __expr2149__;
3095       // __left2148__ = cast(__BlockBitmap__, d.b[bbb])
3096       // __offsetinbits2225__ <-- (0 + (1 * j))
3097       int __leftop2226__ = 0;
3098       int __leftop2228__ = 1;
3099       int __rightop2229__ = (int) __j__; //varexpr
3100       int __rightop2227__ = __leftop2228__ * __rightop2229__;
3101       int __offsetinbits2225__ = __leftop2226__ + __rightop2227__;
3102       // __offsetinbits2225__ = (0 + (1 * j))
3103       int __offset2230__ = __offsetinbits2225__ >> 3;
3104       int __shift2231__ = __offsetinbits2225__ - (__offset2230__ << 3);
3105       int __leftop2147__ = ((*(int *)(__left2148__ + __offset2230__))  >> __shift2231__) & 0x1;
3106       int __rightop2232__ = 0;
3107       int __tempvar2146__ = __leftop2147__ == __rightop2232__;
3108       if (__tempvar2146__)
3109         {
3110         int __leftele2233__ = (int) __j__; //varexpr
3111         int __rightele2234__ = 101;
3112         __blockstatus___hash->add((int)__leftele2233__, (int)__rightele2234__);
3113         }
3114       }
3115     }
3116   }
3117
3118
3119 // build rule19
3120   {
3121   int __tempvar2236__ = 0;
3122   // __left2239__ <-- d.s
3123   // __left2240__ <-- d
3124   int __left2240__ = (int) d; //varexpr
3125   // __left2240__ = d
3126   int __left2239__ = (__left2240__ + 0);
3127   int __leftop2242__ = 32;
3128   int __leftop2244__ = 32;
3129   int __leftop2246__ = 32;
3130   int __leftop2248__ = 32;
3131   int __leftop2250__ = 32;
3132   int __leftop2252__ = 32;
3133   int __rightop2253__ = 0;
3134   int __rightop2251__ = __leftop2252__ + __rightop2253__;
3135   int __rightop2249__ = __leftop2250__ + __rightop2251__;
3136   int __rightop2247__ = __leftop2248__ + __rightop2249__;
3137   int __rightop2245__ = __leftop2246__ + __rightop2247__;
3138   int __rightop2243__ = __leftop2244__ + __rightop2245__;
3139   int __sizeof2241__ = __leftop2242__ + __rightop2243__;
3140   int __high2254__ = __left2239__ + __sizeof2241__;
3141   assertvalidmemory(__left2239__, __high2254__);
3142   // __left2239__ = d.s
3143   // __offsetinbits2255__ <-- (32 + (32 + 0))
3144   int __leftop2256__ = 32;
3145   int __leftop2258__ = 32;
3146   int __rightop2259__ = 0;
3147   int __rightop2257__ = __leftop2258__ + __rightop2259__;
3148   int __offsetinbits2255__ = __leftop2256__ + __rightop2257__;
3149   // __offsetinbits2255__ = (32 + (32 + 0))
3150   int __offset2260__ = __offsetinbits2255__ >> 3;
3151   int __shift2261__ = __offsetinbits2255__ - (__offset2260__ << 3);
3152   int __leftop2238__ = ((*(int *)(__left2239__ + __offset2260__))  >> __shift2261__) & 0xffffffff;
3153   int __rightop2262__ = 1;
3154   int __tempvar2237__ = __leftop2238__ - __rightop2262__;
3155   for (int __j__ = __tempvar2236__; __j__ <= __tempvar2237__; __j__++)
3156     {
3157     for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); )
3158       {
3159       int __bbb__ = (int) __bbb___iterator->next();
3160       //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == true)
3161       // __left2265__ <-- cast(__BlockBitmap__, d.b[bbb])
3162       // __left2267__ <-- d
3163       int __left2267__ = (int) d; //varexpr
3164       // __left2267__ = d
3165       // __offsetinbits2268__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
3166       int __leftop2269__ = 0;
3167       int __leftop2273__ = 8;
3168       // __left2275__ <-- d.s
3169       // __left2276__ <-- d
3170       int __left2276__ = (int) d; //varexpr
3171       // __left2276__ = d
3172       int __left2275__ = (__left2276__ + 0);
3173       int __leftop2278__ = 32;
3174       int __leftop2280__ = 32;
3175       int __leftop2282__ = 32;
3176       int __leftop2284__ = 32;
3177       int __leftop2286__ = 32;
3178       int __leftop2288__ = 32;
3179       int __rightop2289__ = 0;
3180       int __rightop2287__ = __leftop2288__ + __rightop2289__;
3181       int __rightop2285__ = __leftop2286__ + __rightop2287__;
3182       int __rightop2283__ = __leftop2284__ + __rightop2285__;
3183       int __rightop2281__ = __leftop2282__ + __rightop2283__;
3184       int __rightop2279__ = __leftop2280__ + __rightop2281__;
3185       int __sizeof2277__ = __leftop2278__ + __rightop2279__;
3186       int __high2290__ = __left2275__ + __sizeof2277__;
3187       assertvalidmemory(__left2275__, __high2290__);
3188       // __left2275__ = d.s
3189       // __offsetinbits2291__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3190       int __leftop2292__ = 32;
3191       int __leftop2294__ = 32;
3192       int __leftop2296__ = 32;
3193       int __leftop2298__ = 32;
3194       int __leftop2300__ = 32;
3195       int __rightop2301__ = 0;
3196       int __rightop2299__ = __leftop2300__ + __rightop2301__;
3197       int __rightop2297__ = __leftop2298__ + __rightop2299__;
3198       int __rightop2295__ = __leftop2296__ + __rightop2297__;
3199       int __rightop2293__ = __leftop2294__ + __rightop2295__;
3200       int __offsetinbits2291__ = __leftop2292__ + __rightop2293__;
3201       // __offsetinbits2291__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3202       int __offset2302__ = __offsetinbits2291__ >> 3;
3203       int __shift2303__ = __offsetinbits2291__ - (__offset2302__ << 3);
3204       int __rightop2274__ = ((*(int *)(__left2275__ + __offset2302__))  >> __shift2303__) & 0xffffffff;
3205       int __leftop2272__ = __leftop2273__ * __rightop2274__;
3206       int __rightop2304__ = 0;
3207       int __leftop2271__ = __leftop2272__ + __rightop2304__;
3208       int __rightop2305__ = (int) __bbb__; //varexpr
3209       int __rightop2270__ = __leftop2271__ * __rightop2305__;
3210       int __offsetinbits2268__ = __leftop2269__ + __rightop2270__;
3211       // __offsetinbits2268__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
3212       int __offset2306__ = __offsetinbits2268__ >> 3;
3213       int __expr2266__ = (__left2267__ + __offset2306__);
3214       int __leftop2309__ = 8;
3215       // __left2311__ <-- d.s
3216       // __left2312__ <-- d
3217       int __left2312__ = (int) d; //varexpr
3218       // __left2312__ = d
3219       int __left2311__ = (__left2312__ + 0);
3220       int __leftop2314__ = 32;
3221       int __leftop2316__ = 32;
3222       int __leftop2318__ = 32;
3223       int __leftop2320__ = 32;
3224       int __leftop2322__ = 32;
3225       int __leftop2324__ = 32;
3226       int __rightop2325__ = 0;
3227       int __rightop2323__ = __leftop2324__ + __rightop2325__;
3228       int __rightop2321__ = __leftop2322__ + __rightop2323__;
3229       int __rightop2319__ = __leftop2320__ + __rightop2321__;
3230       int __rightop2317__ = __leftop2318__ + __rightop2319__;
3231       int __rightop2315__ = __leftop2316__ + __rightop2317__;
3232       int __sizeof2313__ = __leftop2314__ + __rightop2315__;
3233       int __high2326__ = __left2311__ + __sizeof2313__;
3234       assertvalidmemory(__left2311__, __high2326__);
3235       // __left2311__ = d.s
3236       // __offsetinbits2327__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
3237       int __leftop2328__ = 32;
3238       int __leftop2330__ = 32;
3239       int __leftop2332__ = 32;
3240       int __leftop2334__ = 32;
3241       int __leftop2336__ = 32;
3242       int __rightop2337__ = 0;
3243       int __rightop2335__ = __leftop2336__ + __rightop2337__;
3244       int __rightop2333__ = __leftop2334__ + __rightop2335__;
3245       int __rightop2331__ = __leftop2332__ + __rightop2333__;
3246       int __rightop2329__ = __leftop2330__ + __rightop2331__;
3247       int __offsetinbits2327__ = __leftop2328__ + __rightop2329__;
3248       // __offsetinbits2327__ = (32 + (32 + (32 + (32 + (32 + 0)))))
3249       int __offset2338__ = __offsetinbits2327__ >> 3;
3250       int __shift2339__ = __offsetinbits2327__ - (__offset2338__ << 3);
3251       int __rightop2310__ = ((*(int *)(__left2311__ + __offset2338__))  >> __shift2339__) & 0xffffffff;
3252       int __leftop2308__ = __leftop2309__ * __rightop2310__;
3253       int __rightop2340__ = 0;
3254       int __sizeof2307__ = __leftop2308__ + __rightop2340__;
3255       int __high2341__ = __expr2266__ + __sizeof2307__;
3256       assertvalidmemory(__expr2266__, __high2341__);
3257       int __left2265__ = (int) __expr2266__;
3258       // __left2265__ = cast(__BlockBitmap__, d.b[bbb])
3259       // __offsetinbits2342__ <-- (0 + (1 * j))
3260       int __leftop2343__ = 0;
3261       int __leftop2345__ = 1;
3262       int __rightop2346__ = (int) __j__; //varexpr
3263       int __rightop2344__ = __leftop2345__ * __rightop2346__;
3264       int __offsetinbits2342__ = __leftop2343__ + __rightop2344__;
3265       // __offsetinbits2342__ = (0 + (1 * j))
3266       int __offset2347__ = __offsetinbits2342__ >> 3;
3267       int __shift2348__ = __offsetinbits2342__ - (__offset2347__ << 3);
3268       int __leftop2264__ = ((*(int *)(__left2265__ + __offset2347__))  >> __shift2348__) & 0x1;
3269       int __rightop2349__ = 1;
3270       int __tempvar2263__ = __leftop2264__ == __rightop2349__;
3271       if (__tempvar2263__)
3272         {
3273         int __leftele2350__ = (int) __j__; //varexpr
3274         int __rightele2351__ = 100;
3275         __blockstatus___hash->add((int)__leftele2350__, (int)__rightele2351__);
3276         }
3277       }
3278     }
3279   }
3280
3281
3282 // checking c1
3283   {
3284   for (SimpleIterator* __u___iterator = __UsedInode___hash->iterator(); __u___iterator->hasNext(); )
3285     {
3286     int __u__ = (int) __u___iterator->next();
3287     int maybe = 0;
3288     int __domain2355__ = (int) __u__; //varexpr
3289     int __leftop2354__;
3290     int __found2356__ = __inodestatus___hash->get(__domain2355__, __leftop2354__);
3291     if (!__found2356__) { maybe = 1; }
3292     int __rightop2357__ = 100;
3293     int __constraintboolean2353__ = __leftop2354__ == __rightop2357__;
3294     if (maybe)
3295       {
3296       __Success = 0;
3297       printf("maybe fail 1. ");
3298       }
3299     else if (!__constraintboolean2353__)
3300       {
3301       __Success = 0;
3302       printf("fail 1. ");
3303       }
3304     }
3305   }
3306
3307
3308 // checking c2
3309   {
3310   for (SimpleIterator* __f___iterator = __FreeInode___hash->iterator(); __f___iterator->hasNext(); )
3311     {
3312     int __f__ = (int) __f___iterator->next();
3313     int maybe = 0;
3314     int __domain2360__ = (int) __f__; //varexpr
3315     int __leftop2359__;
3316     int __found2361__ = __inodestatus___hash->get(__domain2360__, __leftop2359__);
3317     if (!__found2361__) { maybe = 1; }
3318     int __rightop2362__ = 101;
3319     int __constraintboolean2358__ = __leftop2359__ == __rightop2362__;
3320     if (maybe)
3321       {
3322       __Success = 0;
3323       printf("maybe fail 2. ");
3324       }
3325     else if (!__constraintboolean2358__)
3326       {
3327       __Success = 0;
3328       printf("fail 2. ");
3329       }
3330     }
3331   }
3332
3333
3334 // checking c3
3335   {
3336   for (SimpleIterator* __u___iterator = __UsedBlock___hash->iterator(); __u___iterator->hasNext(); )
3337     {
3338     int __u__ = (int) __u___iterator->next();
3339     int maybe = 0;
3340     int __domain2365__ = (int) __u__; //varexpr
3341     int __leftop2364__;
3342     int __found2366__ = __blockstatus___hash->get(__domain2365__, __leftop2364__);
3343     if (!__found2366__) { maybe = 1; }
3344     int __rightop2367__ = 100;
3345     int __constraintboolean2363__ = __leftop2364__ == __rightop2367__;
3346     if (maybe)
3347       {
3348       __Success = 0;
3349       printf("maybe fail 3. ");
3350       }
3351     else if (!__constraintboolean2363__)
3352       {
3353       __Success = 0;
3354       printf("fail 3. ");
3355       }
3356     }
3357   }
3358
3359
3360 // checking c4
3361   {
3362   for (SimpleIterator* __f___iterator = __FreeBlock___hash->iterator(); __f___iterator->hasNext(); )
3363     {
3364     int __f__ = (int) __f___iterator->next();
3365     int maybe = 0;
3366     int __domain2370__ = (int) __f__; //varexpr
3367     int __leftop2369__;
3368     int __found2371__ = __blockstatus___hash->get(__domain2370__, __leftop2369__);
3369     if (!__found2371__) { maybe = 1; }
3370     int __rightop2372__ = 101;
3371     int __constraintboolean2368__ = __leftop2369__ == __rightop2372__;
3372     if (maybe)
3373       {
3374       __Success = 0;
3375       printf("maybe fail 4. ");
3376       }
3377     else if (!__constraintboolean2368__)
3378       {
3379       __Success = 0;
3380       printf("fail 4. ");
3381       }
3382     }
3383   }
3384
3385
3386 // checking c5
3387   {
3388   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
3389     {
3390     int __i__ = (int) __i___iterator->next();
3391     int maybe = 0;
3392     int __domain2375__ = (int) __i__; //varexpr
3393     int __leftop2374__;
3394     int __found2376__ = __referencecount___hash->get(__domain2375__, __leftop2374__);
3395     if (!__found2376__) { maybe = 1; }
3396     int __rightop2377__ = __inodeof___hashinv->count(__i__);
3397     int __constraintboolean2373__ = __leftop2374__ == __rightop2377__;
3398     if (maybe)
3399       {
3400       __Success = 0;
3401       printf("maybe fail 5. ");
3402       }
3403     else if (!__constraintboolean2373__)
3404       {
3405       __Success = 0;
3406       printf("fail 5. ");
3407       }
3408     }
3409   }
3410
3411
3412 // checking c6
3413   {
3414   for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
3415     {
3416     int __i__ = (int) __i___iterator->next();
3417     int maybe = 0;
3418     int __domain2380__ = (int) __i__; //varexpr
3419     int __leftop2379__;
3420     int __found2381__ = __filesize___hash->get(__domain2380__, __leftop2379__);
3421     if (!__found2381__) { maybe = 1; }
3422     int __leftop2383__ = __contents___hash->count(__i__);
3423     int __rightop2384__ = 8192;
3424     int __rightop2382__ = __leftop2383__ * __rightop2384__;
3425     int __constraintboolean2378__ = __leftop2379__ <= __rightop2382__;
3426     if (maybe)
3427       {
3428       __Success = 0;
3429       printf("maybe fail 6. ");
3430       }
3431     else if (!__constraintboolean2378__)
3432       {
3433       __Success = 0;
3434       printf("fail 6. ");
3435       }
3436     }
3437   }
3438
3439
3440 // checking c7
3441   {
3442   for (SimpleIterator* __b___iterator = __FileDirectoryBlock___hash->iterator(); __b___iterator->hasNext(); )
3443     {
3444     int __b__ = (int) __b___iterator->next();
3445     int maybe = 0;
3446     int __leftop2386__ = __contents___hashinv->count(__b__);
3447     int __rightop2387__ = 1;
3448     int __constraintboolean2385__ = __leftop2386__ == __rightop2387__;
3449     if (maybe)
3450       {
3451       __Success = 0;
3452       printf("maybe fail 7. ");
3453       }
3454     else if (!__constraintboolean2385__)
3455       {
3456       __Success = 0;
3457       printf("fail 7. ");
3458       }
3459     }
3460   }
3461
3462
3463 // checking c8
3464   {
3465   int maybe = 0;
3466   int __leftop2389__ = __SuperBlock___hash->count();
3467   int __rightop2390__ = 1;
3468   int __constraintboolean2388__ = __leftop2389__ == __rightop2390__;
3469   if (maybe)
3470     {
3471     __Success = 0;
3472     printf("maybe fail 8. ");
3473     }
3474   else if (!__constraintboolean2388__)
3475     {
3476     __Success = 0;
3477     printf("fail 8. ");
3478     }
3479   }
3480
3481
3482 // checking c9
3483   {
3484   int maybe = 0;
3485   int __leftop2392__ = __GroupBlock___hash->count();
3486   int __rightop2393__ = 1;
3487   int __constraintboolean2391__ = __leftop2392__ == __rightop2393__;
3488   if (maybe)
3489     {
3490     __Success = 0;
3491     printf("maybe fail 9. ");
3492     }
3493   else if (!__constraintboolean2391__)
3494     {
3495     __Success = 0;
3496     printf("fail 9. ");
3497     }
3498   }
3499
3500
3501 // checking c10
3502   {
3503   int maybe = 0;
3504   int __leftop2395__ = __InodeTableBlock___hash->count();
3505   int __rightop2396__ = 1;
3506   int __constraintboolean2394__ = __leftop2395__ == __rightop2396__;
3507   if (maybe)
3508     {
3509     __Success = 0;
3510     printf("maybe fail 10. ");
3511     }
3512   else if (!__constraintboolean2394__)
3513     {
3514     __Success = 0;
3515     printf("fail 10. ");
3516     }
3517   }
3518
3519
3520 // checking c11
3521   {
3522   int maybe = 0;
3523   int __leftop2398__ = __InodeBitmapBlock___hash->count();
3524   int __rightop2399__ = 1;
3525   int __constraintboolean2397__ = __leftop2398__ == __rightop2399__;
3526   if (maybe)
3527     {
3528     __Success = 0;
3529     printf("maybe fail 11. ");
3530     }
3531   else if (!__constraintboolean2397__)
3532     {
3533     __Success = 0;
3534     printf("fail 11. ");
3535     }
3536   }
3537
3538
3539 // checking c12
3540   {
3541   int maybe = 0;
3542   int __leftop2401__ = __BlockBitmapBlock___hash->count();
3543   int __rightop2402__ = 1;
3544   int __constraintboolean2400__ = __leftop2401__ == __rightop2402__;
3545   if (maybe)
3546     {
3547     __Success = 0;
3548     printf("maybe fail 12. ");
3549     }
3550   else if (!__constraintboolean2400__)
3551     {
3552     __Success = 0;
3553     printf("fail 12. ");
3554     }
3555   }
3556
3557
3558 // checking c13
3559   {
3560   int maybe = 0;
3561   int __leftop2404__ = __RootDirectoryInode___hash->count();
3562   int __rightop2405__ = 1;
3563   int __constraintboolean2403__ = __leftop2404__ == __rightop2405__;
3564   if (maybe)
3565     {
3566     __Success = 0;
3567     printf("maybe fail 13. ");
3568     }
3569   else if (!__constraintboolean2403__)
3570     {
3571     __Success = 0;
3572     printf("fail 13. ");
3573     }
3574   }
3575
3576
3577 if (__Success) { //printf("all tests passed");
3578 }