10 SimpleHash* __int___hash = new SimpleHash();
11 SimpleHash* __FileBlock___hash = new SimpleHash();
12 SimpleHash* __UsedBlock___hash = new SimpleHash();
13 SimpleHash* __FileInode___hash = new SimpleHash();
14 SimpleHash* __SuperBlock___hash = new SimpleHash();
15 SimpleHash* __UsedInode___hash = new SimpleHash();
16 SimpleHash* __InodeBitmapBlock___hash = new SimpleHash();
17 SimpleHash* __BlockBitmapBlock___hash = new SimpleHash();
18 SimpleHash* __FileDirectoryBlock___hash = new SimpleHash();
19 SimpleHash* __token___hash = new SimpleHash();
20 SimpleHash* __DirectoryEntry___hash = new SimpleHash();
21 SimpleHash* __RootDirectoryInode___hash = new SimpleHash();
22 SimpleHash* __FreeBlock___hash = new SimpleHash();
23 SimpleHash* __GroupBlock___hash = new SimpleHash();
24 SimpleHash* __Block___hash = new SimpleHash();
25 SimpleHash* __DirectoryBlock___hash = new SimpleHash();
26 SimpleHash* __FreeInode___hash = new SimpleHash();
27 SimpleHash* __Inode___hash = new SimpleHash();
28 SimpleHash* __DirectoryInode___hash = new SimpleHash();
29 SimpleHash* __InodeTableBlock___hash = new SimpleHash();
30 __SuperBlock___hash->addParent(__UsedBlock___hash);
31 __GroupBlock___hash->addParent(__UsedBlock___hash);
32 __FileDirectoryBlock___hash->addParent(__UsedBlock___hash);
33 __InodeTableBlock___hash->addParent(__UsedBlock___hash);
34 __InodeBitmapBlock___hash->addParent(__UsedBlock___hash);
35 __BlockBitmapBlock___hash->addParent(__UsedBlock___hash);
36 __FileInode___hash->addParent(__UsedInode___hash);
37 __DirectoryInode___hash->addParent(__UsedInode___hash);
38 __DirectoryBlock___hash->addParent(__FileDirectoryBlock___hash);
39 __FileBlock___hash->addParent(__FileDirectoryBlock___hash);
40 __UsedBlock___hash->addParent(__Block___hash);
41 __FreeBlock___hash->addParent(__Block___hash);
42 __UsedInode___hash->addParent(__Inode___hash);
43 __FreeInode___hash->addParent(__Inode___hash);
44 __RootDirectoryInode___hash->addParent(__DirectoryInode___hash);
45 SimpleHash* __referencecount___hash = new SimpleHash();
46 SimpleHash* __filesize___hash = new SimpleHash();
47 SimpleHash* __inodeof___hashinv = new SimpleHash();
48 SimpleHash* __contents___hash = new SimpleHash();
49 SimpleHash* __contents___hashinv = new SimpleHash();
50 SimpleHash* __inodestatus___hash = new SimpleHash();
51 SimpleHash* __blockstatus___hash = new SimpleHash();
60 __SuperBlock___hash->add((int)__element1__, (int)__element1__);
71 __GroupBlock___hash->add((int)__element3__, (int)__element3__);
78 //(d.g.InodeTableBlock < d.s.NumberofBlocks)
81 int __left7__ = (int) d;
83 // __offsetinbits8__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
88 int __left16__ = (int) d;
90 int __left15__ = (__left16__ + 0);
92 // __offsetinbits17__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
93 int __leftop18__ = 32;
94 int __leftop20__ = 32;
95 int __leftop22__ = 32;
96 int __leftop24__ = 32;
97 int __leftop26__ = 32;
98 int __rightop27__ = 0;
99 int __rightop25__ = __leftop26__ + __rightop27__;
100 int __rightop23__ = __leftop24__ + __rightop25__;
101 int __rightop21__ = __leftop22__ + __rightop23__;
102 int __rightop19__ = __leftop20__ + __rightop21__;
103 int __offsetinbits17__ = __leftop18__ + __rightop19__;
104 // __offsetinbits17__ = (32 + (32 + (32 + (32 + (32 + 0)))))
105 int __offset28__ = __offsetinbits17__ >> 3;
106 int __shift29__ = __offsetinbits17__ - (__offset28__ << 3);
107 int __rightop14__ = ((*(int *)(__left15__ + __offset28__)) >> __shift29__) & 0xffffffff;
108 int __leftop12__ = __leftop13__ * __rightop14__;
109 int __rightop30__ = 0;
110 int __leftop11__ = __leftop12__ + __rightop30__;
111 int __rightop31__ = 1;
112 int __rightop10__ = __leftop11__ * __rightop31__;
113 int __offsetinbits8__ = __leftop9__ + __rightop10__;
114 // __offsetinbits8__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
115 int __offset32__ = __offsetinbits8__ >> 3;
116 int __left6__ = (__left7__ + __offset32__);
118 // __offsetinbits33__ <-- (32 + (32 + 0))
119 int __leftop34__ = 32;
120 int __leftop36__ = 32;
121 int __rightop37__ = 0;
122 int __rightop35__ = __leftop36__ + __rightop37__;
123 int __offsetinbits33__ = __leftop34__ + __rightop35__;
124 // __offsetinbits33__ = (32 + (32 + 0))
125 int __offset38__ = __offsetinbits33__ >> 3;
126 int __shift39__ = __offsetinbits33__ - (__offset38__ << 3);
127 int __leftop5__ = ((*(int *)(__left6__ + __offset38__)) >> __shift39__) & 0xffffffff;
128 // __left41__ <-- d.s
130 int __left42__ = (int) d;
132 int __left41__ = (__left42__ + 0);
134 // __offsetinbits43__ <-- (32 + (32 + 0))
135 int __leftop44__ = 32;
136 int __leftop46__ = 32;
137 int __rightop47__ = 0;
138 int __rightop45__ = __leftop46__ + __rightop47__;
139 int __offsetinbits43__ = __leftop44__ + __rightop45__;
140 // __offsetinbits43__ = (32 + (32 + 0))
141 int __offset48__ = __offsetinbits43__ >> 3;
142 int __shift49__ = __offsetinbits43__ - (__offset48__ << 3);
143 int __rightop40__ = ((*(int *)(__left41__ + __offset48__)) >> __shift49__) & 0xffffffff;
144 int __tempvar4__ = __leftop5__ < __rightop40__;
146 // __left51__ <-- d.g
148 int __left52__ = (int) d;
150 // __offsetinbits53__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
151 int __leftop54__ = 0;
152 int __leftop58__ = 8;
153 // __left60__ <-- d.s
155 int __left61__ = (int) d;
157 int __left60__ = (__left61__ + 0);
159 // __offsetinbits62__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
160 int __leftop63__ = 32;
161 int __leftop65__ = 32;
162 int __leftop67__ = 32;
163 int __leftop69__ = 32;
164 int __leftop71__ = 32;
165 int __rightop72__ = 0;
166 int __rightop70__ = __leftop71__ + __rightop72__;
167 int __rightop68__ = __leftop69__ + __rightop70__;
168 int __rightop66__ = __leftop67__ + __rightop68__;
169 int __rightop64__ = __leftop65__ + __rightop66__;
170 int __offsetinbits62__ = __leftop63__ + __rightop64__;
171 // __offsetinbits62__ = (32 + (32 + (32 + (32 + (32 + 0)))))
172 int __offset73__ = __offsetinbits62__ >> 3;
173 int __shift74__ = __offsetinbits62__ - (__offset73__ << 3);
174 int __rightop59__ = ((*(int *)(__left60__ + __offset73__)) >> __shift74__) & 0xffffffff;
175 int __leftop57__ = __leftop58__ * __rightop59__;
176 int __rightop75__ = 0;
177 int __leftop56__ = __leftop57__ + __rightop75__;
178 int __rightop76__ = 1;
179 int __rightop55__ = __leftop56__ * __rightop76__;
180 int __offsetinbits53__ = __leftop54__ + __rightop55__;
181 // __offsetinbits53__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
182 int __offset77__ = __offsetinbits53__ >> 3;
183 int __left51__ = (__left52__ + __offset77__);
185 // __offsetinbits78__ <-- (32 + (32 + 0))
186 int __leftop79__ = 32;
187 int __leftop81__ = 32;
188 int __rightop82__ = 0;
189 int __rightop80__ = __leftop81__ + __rightop82__;
190 int __offsetinbits78__ = __leftop79__ + __rightop80__;
191 // __offsetinbits78__ = (32 + (32 + 0))
192 int __offset83__ = __offsetinbits78__ >> 3;
193 int __shift84__ = __offsetinbits78__ - (__offset83__ << 3);
194 int __element50__ = ((*(int *)(__left51__ + __offset83__)) >> __shift84__) & 0xffffffff;
195 __InodeTableBlock___hash->add((int)__element50__, (int)__element50__);
202 //(d.g.InodeBitmapBlock < d.s.NumberofBlocks)
203 // __left87__ <-- d.g
205 int __left88__ = (int) d;
207 // __offsetinbits89__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
208 int __leftop90__ = 0;
209 int __leftop94__ = 8;
210 // __left96__ <-- d.s
212 int __left97__ = (int) d;
214 int __left96__ = (__left97__ + 0);
216 // __offsetinbits98__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
217 int __leftop99__ = 32;
218 int __leftop101__ = 32;
219 int __leftop103__ = 32;
220 int __leftop105__ = 32;
221 int __leftop107__ = 32;
222 int __rightop108__ = 0;
223 int __rightop106__ = __leftop107__ + __rightop108__;
224 int __rightop104__ = __leftop105__ + __rightop106__;
225 int __rightop102__ = __leftop103__ + __rightop104__;
226 int __rightop100__ = __leftop101__ + __rightop102__;
227 int __offsetinbits98__ = __leftop99__ + __rightop100__;
228 // __offsetinbits98__ = (32 + (32 + (32 + (32 + (32 + 0)))))
229 int __offset109__ = __offsetinbits98__ >> 3;
230 int __shift110__ = __offsetinbits98__ - (__offset109__ << 3);
231 int __rightop95__ = ((*(int *)(__left96__ + __offset109__)) >> __shift110__) & 0xffffffff;
232 int __leftop93__ = __leftop94__ * __rightop95__;
233 int __rightop111__ = 0;
234 int __leftop92__ = __leftop93__ + __rightop111__;
235 int __rightop112__ = 1;
236 int __rightop91__ = __leftop92__ * __rightop112__;
237 int __offsetinbits89__ = __leftop90__ + __rightop91__;
238 // __offsetinbits89__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
239 int __offset113__ = __offsetinbits89__ >> 3;
240 int __left87__ = (__left88__ + __offset113__);
242 // __offsetinbits114__ <-- (32 + 0)
243 int __leftop115__ = 32;
244 int __rightop116__ = 0;
245 int __offsetinbits114__ = __leftop115__ + __rightop116__;
246 // __offsetinbits114__ = (32 + 0)
247 int __offset117__ = __offsetinbits114__ >> 3;
248 int __shift118__ = __offsetinbits114__ - (__offset117__ << 3);
249 int __leftop86__ = ((*(int *)(__left87__ + __offset117__)) >> __shift118__) & 0xffffffff;
250 // __left120__ <-- d.s
252 int __left121__ = (int) d;
254 int __left120__ = (__left121__ + 0);
256 // __offsetinbits122__ <-- (32 + (32 + 0))
257 int __leftop123__ = 32;
258 int __leftop125__ = 32;
259 int __rightop126__ = 0;
260 int __rightop124__ = __leftop125__ + __rightop126__;
261 int __offsetinbits122__ = __leftop123__ + __rightop124__;
262 // __offsetinbits122__ = (32 + (32 + 0))
263 int __offset127__ = __offsetinbits122__ >> 3;
264 int __shift128__ = __offsetinbits122__ - (__offset127__ << 3);
265 int __rightop119__ = ((*(int *)(__left120__ + __offset127__)) >> __shift128__) & 0xffffffff;
266 int __tempvar85__ = __leftop86__ < __rightop119__;
268 // __left130__ <-- d.g
270 int __left131__ = (int) d;
272 // __offsetinbits132__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
273 int __leftop133__ = 0;
274 int __leftop137__ = 8;
275 // __left139__ <-- d.s
277 int __left140__ = (int) d;
279 int __left139__ = (__left140__ + 0);
281 // __offsetinbits141__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
282 int __leftop142__ = 32;
283 int __leftop144__ = 32;
284 int __leftop146__ = 32;
285 int __leftop148__ = 32;
286 int __leftop150__ = 32;
287 int __rightop151__ = 0;
288 int __rightop149__ = __leftop150__ + __rightop151__;
289 int __rightop147__ = __leftop148__ + __rightop149__;
290 int __rightop145__ = __leftop146__ + __rightop147__;
291 int __rightop143__ = __leftop144__ + __rightop145__;
292 int __offsetinbits141__ = __leftop142__ + __rightop143__;
293 // __offsetinbits141__ = (32 + (32 + (32 + (32 + (32 + 0)))))
294 int __offset152__ = __offsetinbits141__ >> 3;
295 int __shift153__ = __offsetinbits141__ - (__offset152__ << 3);
296 int __rightop138__ = ((*(int *)(__left139__ + __offset152__)) >> __shift153__) & 0xffffffff;
297 int __leftop136__ = __leftop137__ * __rightop138__;
298 int __rightop154__ = 0;
299 int __leftop135__ = __leftop136__ + __rightop154__;
300 int __rightop155__ = 1;
301 int __rightop134__ = __leftop135__ * __rightop155__;
302 int __offsetinbits132__ = __leftop133__ + __rightop134__;
303 // __offsetinbits132__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
304 int __offset156__ = __offsetinbits132__ >> 3;
305 int __left130__ = (__left131__ + __offset156__);
307 // __offsetinbits157__ <-- (32 + 0)
308 int __leftop158__ = 32;
309 int __rightop159__ = 0;
310 int __offsetinbits157__ = __leftop158__ + __rightop159__;
311 // __offsetinbits157__ = (32 + 0)
312 int __offset160__ = __offsetinbits157__ >> 3;
313 int __shift161__ = __offsetinbits157__ - (__offset160__ << 3);
314 int __element129__ = ((*(int *)(__left130__ + __offset160__)) >> __shift161__) & 0xffffffff;
315 __InodeBitmapBlock___hash->add((int)__element129__, (int)__element129__);
322 int __tempvar162__ = 0;
323 // __left165__ <-- d.s
325 int __left166__ = (int) d;
327 int __left165__ = (__left166__ + 0);
329 // __offsetinbits167__ <-- (32 + (32 + (32 + 0)))
330 int __leftop168__ = 32;
331 int __leftop170__ = 32;
332 int __leftop172__ = 32;
333 int __rightop173__ = 0;
334 int __rightop171__ = __leftop172__ + __rightop173__;
335 int __rightop169__ = __leftop170__ + __rightop171__;
336 int __offsetinbits167__ = __leftop168__ + __rightop169__;
337 // __offsetinbits167__ = (32 + (32 + (32 + 0)))
338 int __offset174__ = __offsetinbits167__ >> 3;
339 int __shift175__ = __offsetinbits167__ - (__offset174__ << 3);
340 int __leftop164__ = ((*(int *)(__left165__ + __offset174__)) >> __shift175__) & 0xffffffff;
341 int __rightop176__ = 1;
342 int __tempvar163__ = __leftop164__ - __rightop176__;
343 for (int __j__ = __tempvar162__; __j__ <= __tempvar163__; __j__++) {
344 for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); ) {
345 int __ibb__ = (int) __ibb___iterator->next();
346 //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == false)
347 // __left179__ <-- cast(__InodeBitmap__, d.b[ibb])
349 int __left181__ = (int) d;
351 // __offsetinbits182__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
352 int __leftop183__ = 0;
353 int __leftop187__ = 8;
354 // __left189__ <-- d.s
356 int __left190__ = (int) d;
358 int __left189__ = (__left190__ + 0);
360 // __offsetinbits191__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
361 int __leftop192__ = 32;
362 int __leftop194__ = 32;
363 int __leftop196__ = 32;
364 int __leftop198__ = 32;
365 int __leftop200__ = 32;
366 int __rightop201__ = 0;
367 int __rightop199__ = __leftop200__ + __rightop201__;
368 int __rightop197__ = __leftop198__ + __rightop199__;
369 int __rightop195__ = __leftop196__ + __rightop197__;
370 int __rightop193__ = __leftop194__ + __rightop195__;
371 int __offsetinbits191__ = __leftop192__ + __rightop193__;
372 // __offsetinbits191__ = (32 + (32 + (32 + (32 + (32 + 0)))))
373 int __offset202__ = __offsetinbits191__ >> 3;
374 int __shift203__ = __offsetinbits191__ - (__offset202__ << 3);
375 int __rightop188__ = ((*(int *)(__left189__ + __offset202__)) >> __shift203__) & 0xffffffff;
376 int __leftop186__ = __leftop187__ * __rightop188__;
377 int __rightop204__ = 0;
378 int __leftop185__ = __leftop186__ + __rightop204__;
379 int __rightop205__ = (int) __ibb__;
380 int __rightop184__ = __leftop185__ * __rightop205__;
381 int __offsetinbits182__ = __leftop183__ + __rightop184__;
382 // __offsetinbits182__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
383 int __offset206__ = __offsetinbits182__ >> 3;
384 int __expr180__ = (__left181__ + __offset206__);
385 int __left179__ = (int) __expr180__;
386 // __left179__ = cast(__InodeBitmap__, d.b[ibb])
387 // __offsetinbits207__ <-- (0 + (1 * j))
388 int __leftop208__ = 0;
389 int __leftop210__ = 1;
390 int __rightop211__ = (int) __j__;
391 int __rightop209__ = __leftop210__ * __rightop211__;
392 int __offsetinbits207__ = __leftop208__ + __rightop209__;
393 // __offsetinbits207__ = (0 + (1 * j))
394 int __offset212__ = __offsetinbits207__ >> 3;
395 int __shift213__ = __offsetinbits207__ - (__offset212__ << 3);
396 int __leftop178__ = ((*(int *)(__left179__ + __offset212__)) >> __shift213__) & 0x1;
397 int __rightop214__ = 0;
398 int __tempvar177__ = __leftop178__ == __rightop214__;
399 if (__tempvar177__) {
400 int __leftele215__ = (int) __j__;
401 int __rightele216__ = 101;
402 __inodestatus___hash->add((int)__leftele215__, (int)__rightele216__);
411 //(d.g.BlockBitmapBlock < d.s.NumberofBlocks)
412 // __left220__ <-- d.g
414 int __left221__ = (int) d;
416 // __offsetinbits222__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
417 int __leftop223__ = 0;
418 int __leftop227__ = 8;
419 // __left229__ <-- d.s
421 int __left230__ = (int) d;
423 int __left229__ = (__left230__ + 0);
425 // __offsetinbits231__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
426 int __leftop232__ = 32;
427 int __leftop234__ = 32;
428 int __leftop236__ = 32;
429 int __leftop238__ = 32;
430 int __leftop240__ = 32;
431 int __rightop241__ = 0;
432 int __rightop239__ = __leftop240__ + __rightop241__;
433 int __rightop237__ = __leftop238__ + __rightop239__;
434 int __rightop235__ = __leftop236__ + __rightop237__;
435 int __rightop233__ = __leftop234__ + __rightop235__;
436 int __offsetinbits231__ = __leftop232__ + __rightop233__;
437 // __offsetinbits231__ = (32 + (32 + (32 + (32 + (32 + 0)))))
438 int __offset242__ = __offsetinbits231__ >> 3;
439 int __shift243__ = __offsetinbits231__ - (__offset242__ << 3);
440 int __rightop228__ = ((*(int *)(__left229__ + __offset242__)) >> __shift243__) & 0xffffffff;
441 int __leftop226__ = __leftop227__ * __rightop228__;
442 int __rightop244__ = 0;
443 int __leftop225__ = __leftop226__ + __rightop244__;
444 int __rightop245__ = 1;
445 int __rightop224__ = __leftop225__ * __rightop245__;
446 int __offsetinbits222__ = __leftop223__ + __rightop224__;
447 // __offsetinbits222__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
448 int __offset246__ = __offsetinbits222__ >> 3;
449 int __left220__ = (__left221__ + __offset246__);
451 int __leftop219__ = ((*(int *)(__left220__ + 0)) >> 0) & 0xffffffff;
452 // __left248__ <-- d.s
454 int __left249__ = (int) d;
456 int __left248__ = (__left249__ + 0);
458 // __offsetinbits250__ <-- (32 + (32 + 0))
459 int __leftop251__ = 32;
460 int __leftop253__ = 32;
461 int __rightop254__ = 0;
462 int __rightop252__ = __leftop253__ + __rightop254__;
463 int __offsetinbits250__ = __leftop251__ + __rightop252__;
464 // __offsetinbits250__ = (32 + (32 + 0))
465 int __offset255__ = __offsetinbits250__ >> 3;
466 int __shift256__ = __offsetinbits250__ - (__offset255__ << 3);
467 int __rightop247__ = ((*(int *)(__left248__ + __offset255__)) >> __shift256__) & 0xffffffff;
468 int __tempvar218__ = __leftop219__ < __rightop247__;
469 if (__tempvar218__) {
470 // __left258__ <-- d.g
472 int __left259__ = (int) d;
474 // __offsetinbits260__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
475 int __leftop261__ = 0;
476 int __leftop265__ = 8;
477 // __left267__ <-- d.s
479 int __left268__ = (int) d;
481 int __left267__ = (__left268__ + 0);
483 // __offsetinbits269__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
484 int __leftop270__ = 32;
485 int __leftop272__ = 32;
486 int __leftop274__ = 32;
487 int __leftop276__ = 32;
488 int __leftop278__ = 32;
489 int __rightop279__ = 0;
490 int __rightop277__ = __leftop278__ + __rightop279__;
491 int __rightop275__ = __leftop276__ + __rightop277__;
492 int __rightop273__ = __leftop274__ + __rightop275__;
493 int __rightop271__ = __leftop272__ + __rightop273__;
494 int __offsetinbits269__ = __leftop270__ + __rightop271__;
495 // __offsetinbits269__ = (32 + (32 + (32 + (32 + (32 + 0)))))
496 int __offset280__ = __offsetinbits269__ >> 3;
497 int __shift281__ = __offsetinbits269__ - (__offset280__ << 3);
498 int __rightop266__ = ((*(int *)(__left267__ + __offset280__)) >> __shift281__) & 0xffffffff;
499 int __leftop264__ = __leftop265__ * __rightop266__;
500 int __rightop282__ = 0;
501 int __leftop263__ = __leftop264__ + __rightop282__;
502 int __rightop283__ = 1;
503 int __rightop262__ = __leftop263__ * __rightop283__;
504 int __offsetinbits260__ = __leftop261__ + __rightop262__;
505 // __offsetinbits260__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
506 int __offset284__ = __offsetinbits260__ >> 3;
507 int __left258__ = (__left259__ + __offset284__);
509 int __element257__ = ((*(int *)(__left258__ + 0)) >> 0) & 0xffffffff;
510 __BlockBitmapBlock___hash->add((int)__element257__, (int)__element257__);
517 int __tempvar285__ = 0;
518 // __left288__ <-- d.s
520 int __left289__ = (int) d;
522 int __left288__ = (__left289__ + 0);
524 // __offsetinbits290__ <-- (32 + (32 + (32 + 0)))
525 int __leftop291__ = 32;
526 int __leftop293__ = 32;
527 int __leftop295__ = 32;
528 int __rightop296__ = 0;
529 int __rightop294__ = __leftop295__ + __rightop296__;
530 int __rightop292__ = __leftop293__ + __rightop294__;
531 int __offsetinbits290__ = __leftop291__ + __rightop292__;
532 // __offsetinbits290__ = (32 + (32 + (32 + 0)))
533 int __offset297__ = __offsetinbits290__ >> 3;
534 int __shift298__ = __offsetinbits290__ - (__offset297__ << 3);
535 int __leftop287__ = ((*(int *)(__left288__ + __offset297__)) >> __shift298__) & 0xffffffff;
536 int __rightop299__ = 1;
537 int __tempvar286__ = __leftop287__ - __rightop299__;
538 for (int __j__ = __tempvar285__; __j__ <= __tempvar286__; __j__++) {
539 for (SimpleIterator* __ibb___iterator = __InodeBitmapBlock___hash->iterator(); __ibb___iterator->hasNext(); ) {
540 int __ibb__ = (int) __ibb___iterator->next();
541 //(cast(__InodeBitmap__, d.b[ibb]).inodebitmap[j] == true)
542 // __left302__ <-- cast(__InodeBitmap__, d.b[ibb])
544 int __left304__ = (int) d;
546 // __offsetinbits305__ <-- (0 + (((8 * d.s.blocksize) + 0) * ibb))
547 int __leftop306__ = 0;
548 int __leftop310__ = 8;
549 // __left312__ <-- d.s
551 int __left313__ = (int) d;
553 int __left312__ = (__left313__ + 0);
555 // __offsetinbits314__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
556 int __leftop315__ = 32;
557 int __leftop317__ = 32;
558 int __leftop319__ = 32;
559 int __leftop321__ = 32;
560 int __leftop323__ = 32;
561 int __rightop324__ = 0;
562 int __rightop322__ = __leftop323__ + __rightop324__;
563 int __rightop320__ = __leftop321__ + __rightop322__;
564 int __rightop318__ = __leftop319__ + __rightop320__;
565 int __rightop316__ = __leftop317__ + __rightop318__;
566 int __offsetinbits314__ = __leftop315__ + __rightop316__;
567 // __offsetinbits314__ = (32 + (32 + (32 + (32 + (32 + 0)))))
568 int __offset325__ = __offsetinbits314__ >> 3;
569 int __shift326__ = __offsetinbits314__ - (__offset325__ << 3);
570 int __rightop311__ = ((*(int *)(__left312__ + __offset325__)) >> __shift326__) & 0xffffffff;
571 int __leftop309__ = __leftop310__ * __rightop311__;
572 int __rightop327__ = 0;
573 int __leftop308__ = __leftop309__ + __rightop327__;
574 int __rightop328__ = (int) __ibb__;
575 int __rightop307__ = __leftop308__ * __rightop328__;
576 int __offsetinbits305__ = __leftop306__ + __rightop307__;
577 // __offsetinbits305__ = (0 + (((8 * d.s.blocksize) + 0) * ibb))
578 int __offset329__ = __offsetinbits305__ >> 3;
579 int __expr303__ = (__left304__ + __offset329__);
580 int __left302__ = (int) __expr303__;
581 // __left302__ = cast(__InodeBitmap__, d.b[ibb])
582 // __offsetinbits330__ <-- (0 + (1 * j))
583 int __leftop331__ = 0;
584 int __leftop333__ = 1;
585 int __rightop334__ = (int) __j__;
586 int __rightop332__ = __leftop333__ * __rightop334__;
587 int __offsetinbits330__ = __leftop331__ + __rightop332__;
588 // __offsetinbits330__ = (0 + (1 * j))
589 int __offset335__ = __offsetinbits330__ >> 3;
590 int __shift336__ = __offsetinbits330__ - (__offset335__ << 3);
591 int __leftop301__ = ((*(int *)(__left302__ + __offset335__)) >> __shift336__) & 0x1;
592 int __rightop337__ = 1;
593 int __tempvar300__ = __leftop301__ == __rightop337__;
594 if (__tempvar300__) {
595 int __leftele338__ = (int) __j__;
596 int __rightele339__ = 100;
597 __inodestatus___hash->add((int)__leftele338__, (int)__rightele339__);
606 //(d.s.RootDirectoryInode < d.s.NumberofInodes)
607 // __left343__ <-- d.s
609 int __left344__ = (int) d;
611 int __left343__ = (__left344__ + 0);
613 // __offsetinbits345__ <-- (32 + (32 + (32 + (32 + 0))))
614 int __leftop346__ = 32;
615 int __leftop348__ = 32;
616 int __leftop350__ = 32;
617 int __leftop352__ = 32;
618 int __rightop353__ = 0;
619 int __rightop351__ = __leftop352__ + __rightop353__;
620 int __rightop349__ = __leftop350__ + __rightop351__;
621 int __rightop347__ = __leftop348__ + __rightop349__;
622 int __offsetinbits345__ = __leftop346__ + __rightop347__;
623 // __offsetinbits345__ = (32 + (32 + (32 + (32 + 0))))
624 int __offset354__ = __offsetinbits345__ >> 3;
625 int __shift355__ = __offsetinbits345__ - (__offset354__ << 3);
626 int __leftop342__ = ((*(int *)(__left343__ + __offset354__)) >> __shift355__) & 0xffffffff;
627 // __left357__ <-- d.s
629 int __left358__ = (int) d;
631 int __left357__ = (__left358__ + 0);
633 // __offsetinbits359__ <-- (32 + (32 + (32 + 0)))
634 int __leftop360__ = 32;
635 int __leftop362__ = 32;
636 int __leftop364__ = 32;
637 int __rightop365__ = 0;
638 int __rightop363__ = __leftop364__ + __rightop365__;
639 int __rightop361__ = __leftop362__ + __rightop363__;
640 int __offsetinbits359__ = __leftop360__ + __rightop361__;
641 // __offsetinbits359__ = (32 + (32 + (32 + 0)))
642 int __offset366__ = __offsetinbits359__ >> 3;
643 int __shift367__ = __offsetinbits359__ - (__offset366__ << 3);
644 int __rightop356__ = ((*(int *)(__left357__ + __offset366__)) >> __shift367__) & 0xffffffff;
645 int __tempvar341__ = __leftop342__ < __rightop356__;
646 if (__tempvar341__) {
647 // __left369__ <-- d.s
649 int __left370__ = (int) d;
651 int __left369__ = (__left370__ + 0);
653 // __offsetinbits371__ <-- (32 + (32 + (32 + (32 + 0))))
654 int __leftop372__ = 32;
655 int __leftop374__ = 32;
656 int __leftop376__ = 32;
657 int __leftop378__ = 32;
658 int __rightop379__ = 0;
659 int __rightop377__ = __leftop378__ + __rightop379__;
660 int __rightop375__ = __leftop376__ + __rightop377__;
661 int __rightop373__ = __leftop374__ + __rightop375__;
662 int __offsetinbits371__ = __leftop372__ + __rightop373__;
663 // __offsetinbits371__ = (32 + (32 + (32 + (32 + 0))))
664 int __offset380__ = __offsetinbits371__ >> 3;
665 int __shift381__ = __offsetinbits371__ - (__offset380__ << 3);
666 int __element368__ = ((*(int *)(__left369__ + __offset380__)) >> __shift381__) & 0xffffffff;
667 __RootDirectoryInode___hash->add((int)__element368__, (int)__element368__);
674 for (SimpleIterator* __di___iterator = __DirectoryInode___hash->iterator(); __di___iterator->hasNext(); ) {
675 int __di__ = (int) __di___iterator->next();
676 for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
677 int __itb__ = (int) __itb___iterator->next();
678 int __tempvar382__ = 0;
679 // __left386__ <-- d.s
681 int __left387__ = (int) d;
683 int __left386__ = (__left387__ + 0);
685 // __offsetinbits388__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
686 int __leftop389__ = 32;
687 int __leftop391__ = 32;
688 int __leftop393__ = 32;
689 int __leftop395__ = 32;
690 int __leftop397__ = 32;
691 int __rightop398__ = 0;
692 int __rightop396__ = __leftop397__ + __rightop398__;
693 int __rightop394__ = __leftop395__ + __rightop396__;
694 int __rightop392__ = __leftop393__ + __rightop394__;
695 int __rightop390__ = __leftop391__ + __rightop392__;
696 int __offsetinbits388__ = __leftop389__ + __rightop390__;
697 // __offsetinbits388__ = (32 + (32 + (32 + (32 + (32 + 0)))))
698 int __offset399__ = __offsetinbits388__ >> 3;
699 int __shift400__ = __offsetinbits388__ - (__offset399__ << 3);
700 int __leftop385__ = ((*(int *)(__left386__ + __offset399__)) >> __shift400__) & 0xffffffff;
701 int __rightop401__ = 128;
702 int __leftop384__ = __leftop385__ / __rightop401__;
703 int __rightop402__ = 1;
704 int __tempvar383__ = __leftop384__ - __rightop402__;
705 for (int __j__ = __tempvar382__; __j__ <= __tempvar383__; __j__++) {
706 int __tempvar403__ = 0;
707 int __tempvar404__ = 11;
708 for (int __k__ = __tempvar403__; __k__ <= __tempvar404__; __k__++) {
709 //(cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k] < d.s.NumberofBlocks)
710 // __left407__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
711 // __left408__ <-- cast(__InodeTable__, d.b[itb])
713 int __left410__ = (int) d;
715 // __offsetinbits411__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
716 int __leftop412__ = 0;
717 int __leftop416__ = 8;
718 // __left418__ <-- d.s
720 int __left419__ = (int) d;
722 int __left418__ = (__left419__ + 0);
724 // __offsetinbits420__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
725 int __leftop421__ = 32;
726 int __leftop423__ = 32;
727 int __leftop425__ = 32;
728 int __leftop427__ = 32;
729 int __leftop429__ = 32;
730 int __rightop430__ = 0;
731 int __rightop428__ = __leftop429__ + __rightop430__;
732 int __rightop426__ = __leftop427__ + __rightop428__;
733 int __rightop424__ = __leftop425__ + __rightop426__;
734 int __rightop422__ = __leftop423__ + __rightop424__;
735 int __offsetinbits420__ = __leftop421__ + __rightop422__;
736 // __offsetinbits420__ = (32 + (32 + (32 + (32 + (32 + 0)))))
737 int __offset431__ = __offsetinbits420__ >> 3;
738 int __shift432__ = __offsetinbits420__ - (__offset431__ << 3);
739 int __rightop417__ = ((*(int *)(__left418__ + __offset431__)) >> __shift432__) & 0xffffffff;
740 int __leftop415__ = __leftop416__ * __rightop417__;
741 int __rightop433__ = 0;
742 int __leftop414__ = __leftop415__ + __rightop433__;
743 int __rightop434__ = (int) __itb__;
744 int __rightop413__ = __leftop414__ * __rightop434__;
745 int __offsetinbits411__ = __leftop412__ + __rightop413__;
746 // __offsetinbits411__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
747 int __offset435__ = __offsetinbits411__ >> 3;
748 int __expr409__ = (__left410__ + __offset435__);
749 int __left408__ = (int) __expr409__;
750 // __left408__ = cast(__InodeTable__, d.b[itb])
751 // __offsetinbits436__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
752 int __leftop437__ = 0;
753 int __leftop440__ = 32;
754 int __leftop443__ = 32;
755 int __rightop444__ = 12;
756 int __leftop442__ = __leftop443__ * __rightop444__;
757 int __leftop446__ = 32;
758 int __rightop447__ = 0;
759 int __rightop445__ = __leftop446__ + __rightop447__;
760 int __rightop441__ = __leftop442__ + __rightop445__;
761 int __leftop439__ = __leftop440__ + __rightop441__;
762 int __rightop448__ = (int) __di__;
763 int __rightop438__ = __leftop439__ * __rightop448__;
764 int __offsetinbits436__ = __leftop437__ + __rightop438__;
765 // __offsetinbits436__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
766 int __offset449__ = __offsetinbits436__ >> 3;
767 int __left407__ = (__left408__ + __offset449__);
768 // __left407__ = cast(__InodeTable__, d.b[itb]).itable[di]
769 // __offsetinbits450__ <-- ((32 + 0) + (32 * k))
770 int __leftop452__ = 32;
771 int __rightop453__ = 0;
772 int __leftop451__ = __leftop452__ + __rightop453__;
773 int __leftop455__ = 32;
774 int __rightop456__ = (int) __k__;
775 int __rightop454__ = __leftop455__ * __rightop456__;
776 int __offsetinbits450__ = __leftop451__ + __rightop454__;
777 // __offsetinbits450__ = ((32 + 0) + (32 * k))
778 int __offset457__ = __offsetinbits450__ >> 3;
779 int __shift458__ = __offsetinbits450__ - (__offset457__ << 3);
780 int __leftop406__ = ((*(int *)(__left407__ + __offset457__)) >> __shift458__) & 0xffffffff;
781 // __left460__ <-- d.s
783 int __left461__ = (int) d;
785 int __left460__ = (__left461__ + 0);
787 // __offsetinbits462__ <-- (32 + (32 + 0))
788 int __leftop463__ = 32;
789 int __leftop465__ = 32;
790 int __rightop466__ = 0;
791 int __rightop464__ = __leftop465__ + __rightop466__;
792 int __offsetinbits462__ = __leftop463__ + __rightop464__;
793 // __offsetinbits462__ = (32 + (32 + 0))
794 int __offset467__ = __offsetinbits462__ >> 3;
795 int __shift468__ = __offsetinbits462__ - (__offset467__ << 3);
796 int __rightop459__ = ((*(int *)(__left460__ + __offset467__)) >> __shift468__) & 0xffffffff;
797 int __tempvar405__ = __leftop406__ < __rightop459__;
798 if (__tempvar405__) {
799 // __left470__ <-- cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
801 int __left472__ = (int) d;
803 // __offsetinbits473__ <-- (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
804 int __leftop474__ = 0;
805 int __leftop478__ = 8;
806 // __left480__ <-- d.s
808 int __left481__ = (int) d;
810 int __left480__ = (__left481__ + 0);
812 // __offsetinbits482__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
813 int __leftop483__ = 32;
814 int __leftop485__ = 32;
815 int __leftop487__ = 32;
816 int __leftop489__ = 32;
817 int __leftop491__ = 32;
818 int __rightop492__ = 0;
819 int __rightop490__ = __leftop491__ + __rightop492__;
820 int __rightop488__ = __leftop489__ + __rightop490__;
821 int __rightop486__ = __leftop487__ + __rightop488__;
822 int __rightop484__ = __leftop485__ + __rightop486__;
823 int __offsetinbits482__ = __leftop483__ + __rightop484__;
824 // __offsetinbits482__ = (32 + (32 + (32 + (32 + (32 + 0)))))
825 int __offset493__ = __offsetinbits482__ >> 3;
826 int __shift494__ = __offsetinbits482__ - (__offset493__ << 3);
827 int __rightop479__ = ((*(int *)(__left480__ + __offset493__)) >> __shift494__) & 0xffffffff;
828 int __leftop477__ = __leftop478__ * __rightop479__;
829 int __rightop495__ = 0;
830 int __leftop476__ = __leftop477__ + __rightop495__;
831 // __left497__ <-- cast(__InodeTable__, d.b[itb]).itable[di]
832 // __left498__ <-- cast(__InodeTable__, d.b[itb])
834 int __left500__ = (int) d;
836 // __offsetinbits501__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
837 int __leftop502__ = 0;
838 int __leftop506__ = 8;
839 // __left508__ <-- d.s
841 int __left509__ = (int) d;
843 int __left508__ = (__left509__ + 0);
845 // __offsetinbits510__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
846 int __leftop511__ = 32;
847 int __leftop513__ = 32;
848 int __leftop515__ = 32;
849 int __leftop517__ = 32;
850 int __leftop519__ = 32;
851 int __rightop520__ = 0;
852 int __rightop518__ = __leftop519__ + __rightop520__;
853 int __rightop516__ = __leftop517__ + __rightop518__;
854 int __rightop514__ = __leftop515__ + __rightop516__;
855 int __rightop512__ = __leftop513__ + __rightop514__;
856 int __offsetinbits510__ = __leftop511__ + __rightop512__;
857 // __offsetinbits510__ = (32 + (32 + (32 + (32 + (32 + 0)))))
858 int __offset521__ = __offsetinbits510__ >> 3;
859 int __shift522__ = __offsetinbits510__ - (__offset521__ << 3);
860 int __rightop507__ = ((*(int *)(__left508__ + __offset521__)) >> __shift522__) & 0xffffffff;
861 int __leftop505__ = __leftop506__ * __rightop507__;
862 int __rightop523__ = 0;
863 int __leftop504__ = __leftop505__ + __rightop523__;
864 int __rightop524__ = (int) __itb__;
865 int __rightop503__ = __leftop504__ * __rightop524__;
866 int __offsetinbits501__ = __leftop502__ + __rightop503__;
867 // __offsetinbits501__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
868 int __offset525__ = __offsetinbits501__ >> 3;
869 int __expr499__ = (__left500__ + __offset525__);
870 int __left498__ = (int) __expr499__;
871 // __left498__ = cast(__InodeTable__, d.b[itb])
872 // __offsetinbits526__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
873 int __leftop527__ = 0;
874 int __leftop530__ = 32;
875 int __leftop533__ = 32;
876 int __rightop534__ = 12;
877 int __leftop532__ = __leftop533__ * __rightop534__;
878 int __leftop536__ = 32;
879 int __rightop537__ = 0;
880 int __rightop535__ = __leftop536__ + __rightop537__;
881 int __rightop531__ = __leftop532__ + __rightop535__;
882 int __leftop529__ = __leftop530__ + __rightop531__;
883 int __rightop538__ = (int) __di__;
884 int __rightop528__ = __leftop529__ * __rightop538__;
885 int __offsetinbits526__ = __leftop527__ + __rightop528__;
886 // __offsetinbits526__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * di))
887 int __offset539__ = __offsetinbits526__ >> 3;
888 int __left497__ = (__left498__ + __offset539__);
889 // __left497__ = cast(__InodeTable__, d.b[itb]).itable[di]
890 // __offsetinbits540__ <-- ((32 + 0) + (32 * k))
891 int __leftop542__ = 32;
892 int __rightop543__ = 0;
893 int __leftop541__ = __leftop542__ + __rightop543__;
894 int __leftop545__ = 32;
895 int __rightop546__ = (int) __k__;
896 int __rightop544__ = __leftop545__ * __rightop546__;
897 int __offsetinbits540__ = __leftop541__ + __rightop544__;
898 // __offsetinbits540__ = ((32 + 0) + (32 * k))
899 int __offset547__ = __offsetinbits540__ >> 3;
900 int __shift548__ = __offsetinbits540__ - (__offset547__ << 3);
901 int __rightop496__ = ((*(int *)(__left497__ + __offset547__)) >> __shift548__) & 0xffffffff;
902 int __rightop475__ = __leftop476__ * __rightop496__;
903 int __offsetinbits473__ = __leftop474__ + __rightop475__;
904 // __offsetinbits473__ = (0 + (((8 * d.s.blocksize) + 0) * cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]))
905 int __offset549__ = __offsetinbits473__ >> 3;
906 int __expr471__ = (__left472__ + __offset549__);
907 int __left470__ = (int) __expr471__;
908 // __left470__ = cast(__DirectoryBlock__, d.b[cast(__InodeTable__, d.b[itb]).itable[di].Blockptr[k]])
909 // __offsetinbits550__ <-- (0 + ((32 + ((8 * 124) + 0)) * j))
910 int __leftop551__ = 0;
911 int __leftop554__ = 32;
912 int __leftop557__ = 8;
913 int __rightop558__ = 124;
914 int __leftop556__ = __leftop557__ * __rightop558__;
915 int __rightop559__ = 0;
916 int __rightop555__ = __leftop556__ + __rightop559__;
917 int __leftop553__ = __leftop554__ + __rightop555__;
918 int __rightop560__ = (int) __j__;
919 int __rightop552__ = __leftop553__ * __rightop560__;
920 int __offsetinbits550__ = __leftop551__ + __rightop552__;
921 // __offsetinbits550__ = (0 + ((32 + ((8 * 124) + 0)) * j))
922 int __offset561__ = __offsetinbits550__ >> 3;
923 int __element469__ = (__left470__ + __offset561__);
924 __DirectoryEntry___hash->add((int)__element469__, (int)__element469__);
935 for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); ) {
936 int __de__ = (int) __de___iterator->next();
937 //(de.inodenumber < d.s.NumberofInodes)
938 // __left564__ <-- de
939 int __left564__ = (int) __de__;
941 // __offsetinbits565__ <-- ((8 * 124) + 0)
942 int __leftop567__ = 8;
943 int __rightop568__ = 124;
944 int __leftop566__ = __leftop567__ * __rightop568__;
945 int __rightop569__ = 0;
946 int __offsetinbits565__ = __leftop566__ + __rightop569__;
947 // __offsetinbits565__ = ((8 * 124) + 0)
948 int __offset570__ = __offsetinbits565__ >> 3;
949 int __shift571__ = __offsetinbits565__ - (__offset570__ << 3);
950 int __leftop563__ = ((*(int *)(__left564__ + __offset570__)) >> __shift571__) & 0xffffffff;
951 // __left573__ <-- d.s
953 int __left574__ = (int) d;
955 int __left573__ = (__left574__ + 0);
957 // __offsetinbits575__ <-- (32 + (32 + (32 + 0)))
958 int __leftop576__ = 32;
959 int __leftop578__ = 32;
960 int __leftop580__ = 32;
961 int __rightop581__ = 0;
962 int __rightop579__ = __leftop580__ + __rightop581__;
963 int __rightop577__ = __leftop578__ + __rightop579__;
964 int __offsetinbits575__ = __leftop576__ + __rightop577__;
965 // __offsetinbits575__ = (32 + (32 + (32 + 0)))
966 int __offset582__ = __offsetinbits575__ >> 3;
967 int __shift583__ = __offsetinbits575__ - (__offset582__ << 3);
968 int __rightop572__ = ((*(int *)(__left573__ + __offset582__)) >> __shift583__) & 0xffffffff;
969 int __tempvar562__ = __leftop563__ < __rightop572__;
970 if (__tempvar562__) {
971 int __leftele584__ = (int) __de__;
972 // __left586__ <-- de
973 int __left586__ = (int) __de__;
975 // __offsetinbits587__ <-- ((8 * 124) + 0)
976 int __leftop589__ = 8;
977 int __rightop590__ = 124;
978 int __leftop588__ = __leftop589__ * __rightop590__;
979 int __rightop591__ = 0;
980 int __offsetinbits587__ = __leftop588__ + __rightop591__;
981 // __offsetinbits587__ = ((8 * 124) + 0)
982 int __offset592__ = __offsetinbits587__ >> 3;
983 int __shift593__ = __offsetinbits587__ - (__offset592__ << 3);
984 int __rightele585__ = ((*(int *)(__left586__ + __offset592__)) >> __shift593__) & 0xffffffff;
985 __inodeof___hashinv->add((int)__rightele585__, (int)__leftele584__);
993 for (SimpleIterator* __de___iterator = __DirectoryEntry___hash->iterator(); __de___iterator->hasNext(); ) {
994 int __de__ = (int) __de___iterator->next();
995 //((de.inodenumber < d.s.NumberofInodes) && ((de.inodenumber == 0)))
996 // __left598__ <-- de
997 int __left598__ = (int) __de__;
999 // __offsetinbits599__ <-- ((8 * 124) + 0)
1000 int __leftop601__ = 8;
1001 int __rightop602__ = 124;
1002 int __leftop600__ = __leftop601__ * __rightop602__;
1003 int __rightop603__ = 0;
1004 int __offsetinbits599__ = __leftop600__ + __rightop603__;
1005 // __offsetinbits599__ = ((8 * 124) + 0)
1006 int __offset604__ = __offsetinbits599__ >> 3;
1007 int __shift605__ = __offsetinbits599__ - (__offset604__ << 3);
1008 int __leftop597__ = ((*(int *)(__left598__ + __offset604__)) >> __shift605__) & 0xffffffff;
1009 // __left607__ <-- d.s
1010 // __left608__ <-- d
1011 int __left608__ = (int) d;
1013 int __left607__ = (__left608__ + 0);
1014 // __left607__ = d.s
1015 // __offsetinbits609__ <-- (32 + (32 + (32 + 0)))
1016 int __leftop610__ = 32;
1017 int __leftop612__ = 32;
1018 int __leftop614__ = 32;
1019 int __rightop615__ = 0;
1020 int __rightop613__ = __leftop614__ + __rightop615__;
1021 int __rightop611__ = __leftop612__ + __rightop613__;
1022 int __offsetinbits609__ = __leftop610__ + __rightop611__;
1023 // __offsetinbits609__ = (32 + (32 + (32 + 0)))
1024 int __offset616__ = __offsetinbits609__ >> 3;
1025 int __shift617__ = __offsetinbits609__ - (__offset616__ << 3);
1026 int __rightop606__ = ((*(int *)(__left607__ + __offset616__)) >> __shift617__) & 0xffffffff;
1027 int __leftop596__ = __leftop597__ < __rightop606__;
1028 // __left621__ <-- de
1029 int __left621__ = (int) __de__;
1031 // __offsetinbits622__ <-- ((8 * 124) + 0)
1032 int __leftop624__ = 8;
1033 int __rightop625__ = 124;
1034 int __leftop623__ = __leftop624__ * __rightop625__;
1035 int __rightop626__ = 0;
1036 int __offsetinbits622__ = __leftop623__ + __rightop626__;
1037 // __offsetinbits622__ = ((8 * 124) + 0)
1038 int __offset627__ = __offsetinbits622__ >> 3;
1039 int __shift628__ = __offsetinbits622__ - (__offset627__ << 3);
1040 int __leftop620__ = ((*(int *)(__left621__ + __offset627__)) >> __shift628__) & 0xffffffff;
1041 int __rightop629__ = 0;
1042 int __leftop619__ = __leftop620__ == __rightop629__;
1043 int __rightop618__ = !__leftop619__;
1044 int __tempvar595__ = __leftop596__ && __rightop618__;
1045 if (__tempvar595__) {
1046 // __left631__ <-- de
1047 int __left631__ = (int) __de__;
1049 // __offsetinbits632__ <-- ((8 * 124) + 0)
1050 int __leftop634__ = 8;
1051 int __rightop635__ = 124;
1052 int __leftop633__ = __leftop634__ * __rightop635__;
1053 int __rightop636__ = 0;
1054 int __offsetinbits632__ = __leftop633__ + __rightop636__;
1055 // __offsetinbits632__ = ((8 * 124) + 0)
1056 int __offset637__ = __offsetinbits632__ >> 3;
1057 int __shift638__ = __offsetinbits632__ - (__offset637__ << 3);
1058 int __element630__ = ((*(int *)(__left631__ + __offset637__)) >> __shift638__) & 0xffffffff;
1059 __FileInode___hash->add((int)__element630__, (int)__element630__);
1067 for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); ) {
1068 int __j__ = (int) __j___iterator->next();
1069 for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1070 int __itb__ = (int) __itb___iterator->next();
1072 int __tempvar639__ = 1;
1073 if (__tempvar639__) {
1074 int __leftele640__ = (int) __j__;
1075 // __left642__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1076 // __left643__ <-- cast(__InodeTable__, d.b[itb])
1077 // __left645__ <-- d
1078 int __left645__ = (int) d;
1080 // __offsetinbits646__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1081 int __leftop647__ = 0;
1082 int __leftop651__ = 8;
1083 // __left653__ <-- d.s
1084 // __left654__ <-- d
1085 int __left654__ = (int) d;
1087 int __left653__ = (__left654__ + 0);
1088 // __left653__ = d.s
1089 // __offsetinbits655__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1090 int __leftop656__ = 32;
1091 int __leftop658__ = 32;
1092 int __leftop660__ = 32;
1093 int __leftop662__ = 32;
1094 int __leftop664__ = 32;
1095 int __rightop665__ = 0;
1096 int __rightop663__ = __leftop664__ + __rightop665__;
1097 int __rightop661__ = __leftop662__ + __rightop663__;
1098 int __rightop659__ = __leftop660__ + __rightop661__;
1099 int __rightop657__ = __leftop658__ + __rightop659__;
1100 int __offsetinbits655__ = __leftop656__ + __rightop657__;
1101 // __offsetinbits655__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1102 int __offset666__ = __offsetinbits655__ >> 3;
1103 int __shift667__ = __offsetinbits655__ - (__offset666__ << 3);
1104 int __rightop652__ = ((*(int *)(__left653__ + __offset666__)) >> __shift667__) & 0xffffffff;
1105 int __leftop650__ = __leftop651__ * __rightop652__;
1106 int __rightop668__ = 0;
1107 int __leftop649__ = __leftop650__ + __rightop668__;
1108 int __rightop669__ = (int) __itb__;
1109 int __rightop648__ = __leftop649__ * __rightop669__;
1110 int __offsetinbits646__ = __leftop647__ + __rightop648__;
1111 // __offsetinbits646__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1112 int __offset670__ = __offsetinbits646__ >> 3;
1113 int __expr644__ = (__left645__ + __offset670__);
1114 int __left643__ = (int) __expr644__;
1115 // __left643__ = cast(__InodeTable__, d.b[itb])
1116 // __offsetinbits671__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1117 int __leftop672__ = 0;
1118 int __leftop675__ = 32;
1119 int __leftop678__ = 32;
1120 int __rightop679__ = 12;
1121 int __leftop677__ = __leftop678__ * __rightop679__;
1122 int __leftop681__ = 32;
1123 int __rightop682__ = 0;
1124 int __rightop680__ = __leftop681__ + __rightop682__;
1125 int __rightop676__ = __leftop677__ + __rightop680__;
1126 int __leftop674__ = __leftop675__ + __rightop676__;
1127 int __rightop683__ = (int) __j__;
1128 int __rightop673__ = __leftop674__ * __rightop683__;
1129 int __offsetinbits671__ = __leftop672__ + __rightop673__;
1130 // __offsetinbits671__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1131 int __offset684__ = __offsetinbits671__ >> 3;
1132 int __left642__ = (__left643__ + __offset684__);
1133 // __left642__ = cast(__InodeTable__, d.b[itb]).itable[j]
1134 // __offsetinbits685__ <-- ((32 * 12) + (32 + 0))
1135 int __leftop687__ = 32;
1136 int __rightop688__ = 12;
1137 int __leftop686__ = __leftop687__ * __rightop688__;
1138 int __leftop690__ = 32;
1139 int __rightop691__ = 0;
1140 int __rightop689__ = __leftop690__ + __rightop691__;
1141 int __offsetinbits685__ = __leftop686__ + __rightop689__;
1142 // __offsetinbits685__ = ((32 * 12) + (32 + 0))
1143 int __offset692__ = __offsetinbits685__ >> 3;
1144 int __shift693__ = __offsetinbits685__ - (__offset692__ << 3);
1145 int __rightele641__ = ((*(int *)(__left642__ + __offset692__)) >> __shift693__) & 0xffffffff;
1146 __referencecount___hash->add((int)__leftele640__, (int)__rightele641__);
1155 for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1156 int __i__ = (int) __i___iterator->next();
1157 for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1158 int __itb__ = (int) __itb___iterator->next();
1159 int __tempvar695__ = 0;
1160 int __tempvar696__ = 11;
1161 for (int __j__ = __tempvar695__; __j__ <= __tempvar696__; __j__++) {
1162 //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks) && ((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0)))
1163 // __left700__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1164 // __left701__ <-- cast(__InodeTable__, d.b[itb])
1165 // __left703__ <-- d
1166 int __left703__ = (int) d;
1168 // __offsetinbits704__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1169 int __leftop705__ = 0;
1170 int __leftop709__ = 8;
1171 // __left711__ <-- d.s
1172 // __left712__ <-- d
1173 int __left712__ = (int) d;
1175 int __left711__ = (__left712__ + 0);
1176 // __left711__ = d.s
1177 // __offsetinbits713__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1178 int __leftop714__ = 32;
1179 int __leftop716__ = 32;
1180 int __leftop718__ = 32;
1181 int __leftop720__ = 32;
1182 int __leftop722__ = 32;
1183 int __rightop723__ = 0;
1184 int __rightop721__ = __leftop722__ + __rightop723__;
1185 int __rightop719__ = __leftop720__ + __rightop721__;
1186 int __rightop717__ = __leftop718__ + __rightop719__;
1187 int __rightop715__ = __leftop716__ + __rightop717__;
1188 int __offsetinbits713__ = __leftop714__ + __rightop715__;
1189 // __offsetinbits713__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1190 int __offset724__ = __offsetinbits713__ >> 3;
1191 int __shift725__ = __offsetinbits713__ - (__offset724__ << 3);
1192 int __rightop710__ = ((*(int *)(__left711__ + __offset724__)) >> __shift725__) & 0xffffffff;
1193 int __leftop708__ = __leftop709__ * __rightop710__;
1194 int __rightop726__ = 0;
1195 int __leftop707__ = __leftop708__ + __rightop726__;
1196 int __rightop727__ = (int) __itb__;
1197 int __rightop706__ = __leftop707__ * __rightop727__;
1198 int __offsetinbits704__ = __leftop705__ + __rightop706__;
1199 // __offsetinbits704__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1200 int __offset728__ = __offsetinbits704__ >> 3;
1201 int __expr702__ = (__left703__ + __offset728__);
1202 int __left701__ = (int) __expr702__;
1203 // __left701__ = cast(__InodeTable__, d.b[itb])
1204 // __offsetinbits729__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1205 int __leftop730__ = 0;
1206 int __leftop733__ = 32;
1207 int __leftop736__ = 32;
1208 int __rightop737__ = 12;
1209 int __leftop735__ = __leftop736__ * __rightop737__;
1210 int __leftop739__ = 32;
1211 int __rightop740__ = 0;
1212 int __rightop738__ = __leftop739__ + __rightop740__;
1213 int __rightop734__ = __leftop735__ + __rightop738__;
1214 int __leftop732__ = __leftop733__ + __rightop734__;
1215 int __rightop741__ = (int) __i__;
1216 int __rightop731__ = __leftop732__ * __rightop741__;
1217 int __offsetinbits729__ = __leftop730__ + __rightop731__;
1218 // __offsetinbits729__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1219 int __offset742__ = __offsetinbits729__ >> 3;
1220 int __left700__ = (__left701__ + __offset742__);
1221 // __left700__ = cast(__InodeTable__, d.b[itb]).itable[i]
1222 // __offsetinbits743__ <-- ((32 + 0) + (32 * j))
1223 int __leftop745__ = 32;
1224 int __rightop746__ = 0;
1225 int __leftop744__ = __leftop745__ + __rightop746__;
1226 int __leftop748__ = 32;
1227 int __rightop749__ = (int) __j__;
1228 int __rightop747__ = __leftop748__ * __rightop749__;
1229 int __offsetinbits743__ = __leftop744__ + __rightop747__;
1230 // __offsetinbits743__ = ((32 + 0) + (32 * j))
1231 int __offset750__ = __offsetinbits743__ >> 3;
1232 int __shift751__ = __offsetinbits743__ - (__offset750__ << 3);
1233 int __leftop699__ = ((*(int *)(__left700__ + __offset750__)) >> __shift751__) & 0xffffffff;
1234 // __left753__ <-- d.s
1235 // __left754__ <-- d
1236 int __left754__ = (int) d;
1238 int __left753__ = (__left754__ + 0);
1239 // __left753__ = d.s
1240 // __offsetinbits755__ <-- (32 + (32 + 0))
1241 int __leftop756__ = 32;
1242 int __leftop758__ = 32;
1243 int __rightop759__ = 0;
1244 int __rightop757__ = __leftop758__ + __rightop759__;
1245 int __offsetinbits755__ = __leftop756__ + __rightop757__;
1246 // __offsetinbits755__ = (32 + (32 + 0))
1247 int __offset760__ = __offsetinbits755__ >> 3;
1248 int __shift761__ = __offsetinbits755__ - (__offset760__ << 3);
1249 int __rightop752__ = ((*(int *)(__left753__ + __offset760__)) >> __shift761__) & 0xffffffff;
1250 int __leftop698__ = __leftop699__ < __rightop752__;
1251 // __left765__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1252 // __left766__ <-- cast(__InodeTable__, d.b[itb])
1253 // __left768__ <-- d
1254 int __left768__ = (int) d;
1256 // __offsetinbits769__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1257 int __leftop770__ = 0;
1258 int __leftop774__ = 8;
1259 // __left776__ <-- d.s
1260 // __left777__ <-- d
1261 int __left777__ = (int) d;
1263 int __left776__ = (__left777__ + 0);
1264 // __left776__ = d.s
1265 // __offsetinbits778__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1266 int __leftop779__ = 32;
1267 int __leftop781__ = 32;
1268 int __leftop783__ = 32;
1269 int __leftop785__ = 32;
1270 int __leftop787__ = 32;
1271 int __rightop788__ = 0;
1272 int __rightop786__ = __leftop787__ + __rightop788__;
1273 int __rightop784__ = __leftop785__ + __rightop786__;
1274 int __rightop782__ = __leftop783__ + __rightop784__;
1275 int __rightop780__ = __leftop781__ + __rightop782__;
1276 int __offsetinbits778__ = __leftop779__ + __rightop780__;
1277 // __offsetinbits778__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1278 int __offset789__ = __offsetinbits778__ >> 3;
1279 int __shift790__ = __offsetinbits778__ - (__offset789__ << 3);
1280 int __rightop775__ = ((*(int *)(__left776__ + __offset789__)) >> __shift790__) & 0xffffffff;
1281 int __leftop773__ = __leftop774__ * __rightop775__;
1282 int __rightop791__ = 0;
1283 int __leftop772__ = __leftop773__ + __rightop791__;
1284 int __rightop792__ = (int) __itb__;
1285 int __rightop771__ = __leftop772__ * __rightop792__;
1286 int __offsetinbits769__ = __leftop770__ + __rightop771__;
1287 // __offsetinbits769__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1288 int __offset793__ = __offsetinbits769__ >> 3;
1289 int __expr767__ = (__left768__ + __offset793__);
1290 int __left766__ = (int) __expr767__;
1291 // __left766__ = cast(__InodeTable__, d.b[itb])
1292 // __offsetinbits794__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1293 int __leftop795__ = 0;
1294 int __leftop798__ = 32;
1295 int __leftop801__ = 32;
1296 int __rightop802__ = 12;
1297 int __leftop800__ = __leftop801__ * __rightop802__;
1298 int __leftop804__ = 32;
1299 int __rightop805__ = 0;
1300 int __rightop803__ = __leftop804__ + __rightop805__;
1301 int __rightop799__ = __leftop800__ + __rightop803__;
1302 int __leftop797__ = __leftop798__ + __rightop799__;
1303 int __rightop806__ = (int) __i__;
1304 int __rightop796__ = __leftop797__ * __rightop806__;
1305 int __offsetinbits794__ = __leftop795__ + __rightop796__;
1306 // __offsetinbits794__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1307 int __offset807__ = __offsetinbits794__ >> 3;
1308 int __left765__ = (__left766__ + __offset807__);
1309 // __left765__ = cast(__InodeTable__, d.b[itb]).itable[i]
1310 // __offsetinbits808__ <-- ((32 + 0) + (32 * j))
1311 int __leftop810__ = 32;
1312 int __rightop811__ = 0;
1313 int __leftop809__ = __leftop810__ + __rightop811__;
1314 int __leftop813__ = 32;
1315 int __rightop814__ = (int) __j__;
1316 int __rightop812__ = __leftop813__ * __rightop814__;
1317 int __offsetinbits808__ = __leftop809__ + __rightop812__;
1318 // __offsetinbits808__ = ((32 + 0) + (32 * j))
1319 int __offset815__ = __offsetinbits808__ >> 3;
1320 int __shift816__ = __offsetinbits808__ - (__offset815__ << 3);
1321 int __leftop764__ = ((*(int *)(__left765__ + __offset815__)) >> __shift816__) & 0xffffffff;
1322 int __rightop817__ = 0;
1323 int __leftop763__ = __leftop764__ == __rightop817__;
1324 int __rightop762__ = !__leftop763__;
1325 int __tempvar697__ = __leftop698__ && __rightop762__;
1326 if (__tempvar697__) {
1327 // __left819__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1328 // __left820__ <-- cast(__InodeTable__, d.b[itb])
1329 // __left822__ <-- d
1330 int __left822__ = (int) d;
1332 // __offsetinbits823__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1333 int __leftop824__ = 0;
1334 int __leftop828__ = 8;
1335 // __left830__ <-- d.s
1336 // __left831__ <-- d
1337 int __left831__ = (int) d;
1339 int __left830__ = (__left831__ + 0);
1340 // __left830__ = d.s
1341 // __offsetinbits832__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1342 int __leftop833__ = 32;
1343 int __leftop835__ = 32;
1344 int __leftop837__ = 32;
1345 int __leftop839__ = 32;
1346 int __leftop841__ = 32;
1347 int __rightop842__ = 0;
1348 int __rightop840__ = __leftop841__ + __rightop842__;
1349 int __rightop838__ = __leftop839__ + __rightop840__;
1350 int __rightop836__ = __leftop837__ + __rightop838__;
1351 int __rightop834__ = __leftop835__ + __rightop836__;
1352 int __offsetinbits832__ = __leftop833__ + __rightop834__;
1353 // __offsetinbits832__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1354 int __offset843__ = __offsetinbits832__ >> 3;
1355 int __shift844__ = __offsetinbits832__ - (__offset843__ << 3);
1356 int __rightop829__ = ((*(int *)(__left830__ + __offset843__)) >> __shift844__) & 0xffffffff;
1357 int __leftop827__ = __leftop828__ * __rightop829__;
1358 int __rightop845__ = 0;
1359 int __leftop826__ = __leftop827__ + __rightop845__;
1360 int __rightop846__ = (int) __itb__;
1361 int __rightop825__ = __leftop826__ * __rightop846__;
1362 int __offsetinbits823__ = __leftop824__ + __rightop825__;
1363 // __offsetinbits823__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1364 int __offset847__ = __offsetinbits823__ >> 3;
1365 int __expr821__ = (__left822__ + __offset847__);
1366 int __left820__ = (int) __expr821__;
1367 // __left820__ = cast(__InodeTable__, d.b[itb])
1368 // __offsetinbits848__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1369 int __leftop849__ = 0;
1370 int __leftop852__ = 32;
1371 int __leftop855__ = 32;
1372 int __rightop856__ = 12;
1373 int __leftop854__ = __leftop855__ * __rightop856__;
1374 int __leftop858__ = 32;
1375 int __rightop859__ = 0;
1376 int __rightop857__ = __leftop858__ + __rightop859__;
1377 int __rightop853__ = __leftop854__ + __rightop857__;
1378 int __leftop851__ = __leftop852__ + __rightop853__;
1379 int __rightop860__ = (int) __i__;
1380 int __rightop850__ = __leftop851__ * __rightop860__;
1381 int __offsetinbits848__ = __leftop849__ + __rightop850__;
1382 // __offsetinbits848__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1383 int __offset861__ = __offsetinbits848__ >> 3;
1384 int __left819__ = (__left820__ + __offset861__);
1385 // __left819__ = cast(__InodeTable__, d.b[itb]).itable[i]
1386 // __offsetinbits862__ <-- ((32 + 0) + (32 * j))
1387 int __leftop864__ = 32;
1388 int __rightop865__ = 0;
1389 int __leftop863__ = __leftop864__ + __rightop865__;
1390 int __leftop867__ = 32;
1391 int __rightop868__ = (int) __j__;
1392 int __rightop866__ = __leftop867__ * __rightop868__;
1393 int __offsetinbits862__ = __leftop863__ + __rightop866__;
1394 // __offsetinbits862__ = ((32 + 0) + (32 * j))
1395 int __offset869__ = __offsetinbits862__ >> 3;
1396 int __shift870__ = __offsetinbits862__ - (__offset869__ << 3);
1397 int __element818__ = ((*(int *)(__left819__ + __offset869__)) >> __shift870__) & 0xffffffff;
1398 __FileBlock___hash->add((int)__element818__, (int)__element818__);
1408 int __tempvar871__ = 0;
1409 // __left874__ <-- d.s
1410 // __left875__ <-- d
1411 int __left875__ = (int) d;
1413 int __left874__ = (__left875__ + 0);
1414 // __left874__ = d.s
1415 // __offsetinbits876__ <-- (32 + (32 + 0))
1416 int __leftop877__ = 32;
1417 int __leftop879__ = 32;
1418 int __rightop880__ = 0;
1419 int __rightop878__ = __leftop879__ + __rightop880__;
1420 int __offsetinbits876__ = __leftop877__ + __rightop878__;
1421 // __offsetinbits876__ = (32 + (32 + 0))
1422 int __offset881__ = __offsetinbits876__ >> 3;
1423 int __shift882__ = __offsetinbits876__ - (__offset881__ << 3);
1424 int __leftop873__ = ((*(int *)(__left874__ + __offset881__)) >> __shift882__) & 0xffffffff;
1425 int __rightop883__ = 1;
1426 int __tempvar872__ = __leftop873__ - __rightop883__;
1427 for (int __j__ = __tempvar871__; __j__ <= __tempvar872__; __j__++) {
1428 //(j in? __UsedBlock__)
1429 int __element886__ = (int) __j__;
1430 int __leftop885__ = __UsedBlock___hash->contains(__element886__);
1431 int __tempvar884__ = !__leftop885__;
1432 if (__tempvar884__) {
1433 int __element887__ = (int) __j__;
1434 __FreeBlock___hash->add((int)__element887__, (int)__element887__);
1442 for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1443 int __i__ = (int) __i___iterator->next();
1444 for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1445 int __itb__ = (int) __itb___iterator->next();
1446 int __tempvar888__ = 0;
1447 int __tempvar889__ = 11;
1448 for (int __j__ = __tempvar888__; __j__ <= __tempvar889__; __j__++) {
1449 //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0))
1450 // __left893__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1451 // __left894__ <-- cast(__InodeTable__, d.b[itb])
1452 // __left896__ <-- d
1453 int __left896__ = (int) d;
1455 // __offsetinbits897__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1456 int __leftop898__ = 0;
1457 int __leftop902__ = 8;
1458 // __left904__ <-- d.s
1459 // __left905__ <-- d
1460 int __left905__ = (int) d;
1462 int __left904__ = (__left905__ + 0);
1463 // __left904__ = d.s
1464 // __offsetinbits906__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1465 int __leftop907__ = 32;
1466 int __leftop909__ = 32;
1467 int __leftop911__ = 32;
1468 int __leftop913__ = 32;
1469 int __leftop915__ = 32;
1470 int __rightop916__ = 0;
1471 int __rightop914__ = __leftop915__ + __rightop916__;
1472 int __rightop912__ = __leftop913__ + __rightop914__;
1473 int __rightop910__ = __leftop911__ + __rightop912__;
1474 int __rightop908__ = __leftop909__ + __rightop910__;
1475 int __offsetinbits906__ = __leftop907__ + __rightop908__;
1476 // __offsetinbits906__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1477 int __offset917__ = __offsetinbits906__ >> 3;
1478 int __shift918__ = __offsetinbits906__ - (__offset917__ << 3);
1479 int __rightop903__ = ((*(int *)(__left904__ + __offset917__)) >> __shift918__) & 0xffffffff;
1480 int __leftop901__ = __leftop902__ * __rightop903__;
1481 int __rightop919__ = 0;
1482 int __leftop900__ = __leftop901__ + __rightop919__;
1483 int __rightop920__ = (int) __itb__;
1484 int __rightop899__ = __leftop900__ * __rightop920__;
1485 int __offsetinbits897__ = __leftop898__ + __rightop899__;
1486 // __offsetinbits897__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1487 int __offset921__ = __offsetinbits897__ >> 3;
1488 int __expr895__ = (__left896__ + __offset921__);
1489 int __left894__ = (int) __expr895__;
1490 // __left894__ = cast(__InodeTable__, d.b[itb])
1491 // __offsetinbits922__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1492 int __leftop923__ = 0;
1493 int __leftop926__ = 32;
1494 int __leftop929__ = 32;
1495 int __rightop930__ = 12;
1496 int __leftop928__ = __leftop929__ * __rightop930__;
1497 int __leftop932__ = 32;
1498 int __rightop933__ = 0;
1499 int __rightop931__ = __leftop932__ + __rightop933__;
1500 int __rightop927__ = __leftop928__ + __rightop931__;
1501 int __leftop925__ = __leftop926__ + __rightop927__;
1502 int __rightop934__ = (int) __i__;
1503 int __rightop924__ = __leftop925__ * __rightop934__;
1504 int __offsetinbits922__ = __leftop923__ + __rightop924__;
1505 // __offsetinbits922__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1506 int __offset935__ = __offsetinbits922__ >> 3;
1507 int __left893__ = (__left894__ + __offset935__);
1508 // __left893__ = cast(__InodeTable__, d.b[itb]).itable[i]
1509 // __offsetinbits936__ <-- ((32 + 0) + (32 * j))
1510 int __leftop938__ = 32;
1511 int __rightop939__ = 0;
1512 int __leftop937__ = __leftop938__ + __rightop939__;
1513 int __leftop941__ = 32;
1514 int __rightop942__ = (int) __j__;
1515 int __rightop940__ = __leftop941__ * __rightop942__;
1516 int __offsetinbits936__ = __leftop937__ + __rightop940__;
1517 // __offsetinbits936__ = ((32 + 0) + (32 * j))
1518 int __offset943__ = __offsetinbits936__ >> 3;
1519 int __shift944__ = __offsetinbits936__ - (__offset943__ << 3);
1520 int __leftop892__ = ((*(int *)(__left893__ + __offset943__)) >> __shift944__) & 0xffffffff;
1521 int __rightop945__ = 0;
1522 int __leftop891__ = __leftop892__ == __rightop945__;
1523 int __tempvar890__ = !__leftop891__;
1524 if (__tempvar890__) {
1525 int __leftele946__ = (int) __i__;
1526 // __left948__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
1527 // __left949__ <-- cast(__InodeTable__, d.b[itb])
1528 // __left951__ <-- d
1529 int __left951__ = (int) d;
1531 // __offsetinbits952__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1532 int __leftop953__ = 0;
1533 int __leftop957__ = 8;
1534 // __left959__ <-- d.s
1535 // __left960__ <-- d
1536 int __left960__ = (int) d;
1538 int __left959__ = (__left960__ + 0);
1539 // __left959__ = d.s
1540 // __offsetinbits961__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1541 int __leftop962__ = 32;
1542 int __leftop964__ = 32;
1543 int __leftop966__ = 32;
1544 int __leftop968__ = 32;
1545 int __leftop970__ = 32;
1546 int __rightop971__ = 0;
1547 int __rightop969__ = __leftop970__ + __rightop971__;
1548 int __rightop967__ = __leftop968__ + __rightop969__;
1549 int __rightop965__ = __leftop966__ + __rightop967__;
1550 int __rightop963__ = __leftop964__ + __rightop965__;
1551 int __offsetinbits961__ = __leftop962__ + __rightop963__;
1552 // __offsetinbits961__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1553 int __offset972__ = __offsetinbits961__ >> 3;
1554 int __shift973__ = __offsetinbits961__ - (__offset972__ << 3);
1555 int __rightop958__ = ((*(int *)(__left959__ + __offset972__)) >> __shift973__) & 0xffffffff;
1556 int __leftop956__ = __leftop957__ * __rightop958__;
1557 int __rightop974__ = 0;
1558 int __leftop955__ = __leftop956__ + __rightop974__;
1559 int __rightop975__ = (int) __itb__;
1560 int __rightop954__ = __leftop955__ * __rightop975__;
1561 int __offsetinbits952__ = __leftop953__ + __rightop954__;
1562 // __offsetinbits952__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1563 int __offset976__ = __offsetinbits952__ >> 3;
1564 int __expr950__ = (__left951__ + __offset976__);
1565 int __left949__ = (int) __expr950__;
1566 // __left949__ = cast(__InodeTable__, d.b[itb])
1567 // __offsetinbits977__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1568 int __leftop978__ = 0;
1569 int __leftop981__ = 32;
1570 int __leftop984__ = 32;
1571 int __rightop985__ = 12;
1572 int __leftop983__ = __leftop984__ * __rightop985__;
1573 int __leftop987__ = 32;
1574 int __rightop988__ = 0;
1575 int __rightop986__ = __leftop987__ + __rightop988__;
1576 int __rightop982__ = __leftop983__ + __rightop986__;
1577 int __leftop980__ = __leftop981__ + __rightop982__;
1578 int __rightop989__ = (int) __i__;
1579 int __rightop979__ = __leftop980__ * __rightop989__;
1580 int __offsetinbits977__ = __leftop978__ + __rightop979__;
1581 // __offsetinbits977__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
1582 int __offset990__ = __offsetinbits977__ >> 3;
1583 int __left948__ = (__left949__ + __offset990__);
1584 // __left948__ = cast(__InodeTable__, d.b[itb]).itable[i]
1585 // __offsetinbits991__ <-- ((32 + 0) + (32 * j))
1586 int __leftop993__ = 32;
1587 int __rightop994__ = 0;
1588 int __leftop992__ = __leftop993__ + __rightop994__;
1589 int __leftop996__ = 32;
1590 int __rightop997__ = (int) __j__;
1591 int __rightop995__ = __leftop996__ * __rightop997__;
1592 int __offsetinbits991__ = __leftop992__ + __rightop995__;
1593 // __offsetinbits991__ = ((32 + 0) + (32 * j))
1594 int __offset998__ = __offsetinbits991__ >> 3;
1595 int __shift999__ = __offsetinbits991__ - (__offset998__ << 3);
1596 int __rightele947__ = ((*(int *)(__left948__ + __offset998__)) >> __shift999__) & 0xffffffff;
1597 __contents___hash->add((int)__leftele946__, (int)__rightele947__);
1598 __contents___hashinv->add((int)__rightele947__, (int)__leftele946__);
1608 int __tempvar1001__ = 0;
1609 // __left1004__ <-- d.s
1610 // __left1005__ <-- d
1611 int __left1005__ = (int) d;
1613 int __left1004__ = (__left1005__ + 0);
1614 // __left1004__ = d.s
1615 // __offsetinbits1006__ <-- (32 + (32 + (32 + 0)))
1616 int __leftop1007__ = 32;
1617 int __leftop1009__ = 32;
1618 int __leftop1011__ = 32;
1619 int __rightop1012__ = 0;
1620 int __rightop1010__ = __leftop1011__ + __rightop1012__;
1621 int __rightop1008__ = __leftop1009__ + __rightop1010__;
1622 int __offsetinbits1006__ = __leftop1007__ + __rightop1008__;
1623 // __offsetinbits1006__ = (32 + (32 + (32 + 0)))
1624 int __offset1013__ = __offsetinbits1006__ >> 3;
1625 int __shift1014__ = __offsetinbits1006__ - (__offset1013__ << 3);
1626 int __leftop1003__ = ((*(int *)(__left1004__ + __offset1013__)) >> __shift1014__) & 0xffffffff;
1627 int __rightop1015__ = 1;
1628 int __tempvar1002__ = __leftop1003__ - __rightop1015__;
1629 for (int __j__ = __tempvar1001__; __j__ <= __tempvar1002__; __j__++) {
1630 //(j in? __UsedInode__)
1631 int __element1018__ = (int) __j__;
1632 int __leftop1017__ = __UsedInode___hash->contains(__element1018__);
1633 int __tempvar1016__ = !__leftop1017__;
1634 if (__tempvar1016__) {
1635 int __element1019__ = (int) __j__;
1636 __FreeInode___hash->add((int)__element1019__, (int)__element1019__);
1644 for (SimpleIterator* __j___iterator = __UsedInode___hash->iterator(); __j___iterator->hasNext(); ) {
1645 int __j__ = (int) __j___iterator->next();
1646 for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); ) {
1647 int __itb__ = (int) __itb___iterator->next();
1649 int __tempvar1020__ = 1;
1650 if (__tempvar1020__) {
1651 int __leftele1021__ = (int) __j__;
1652 // __left1023__ <-- cast(__InodeTable__, d.b[itb]).itable[j]
1653 // __left1024__ <-- cast(__InodeTable__, d.b[itb])
1654 // __left1026__ <-- d
1655 int __left1026__ = (int) d;
1657 // __offsetinbits1027__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
1658 int __leftop1028__ = 0;
1659 int __leftop1032__ = 8;
1660 // __left1034__ <-- d.s
1661 // __left1035__ <-- d
1662 int __left1035__ = (int) d;
1664 int __left1034__ = (__left1035__ + 0);
1665 // __left1034__ = d.s
1666 // __offsetinbits1036__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1667 int __leftop1037__ = 32;
1668 int __leftop1039__ = 32;
1669 int __leftop1041__ = 32;
1670 int __leftop1043__ = 32;
1671 int __leftop1045__ = 32;
1672 int __rightop1046__ = 0;
1673 int __rightop1044__ = __leftop1045__ + __rightop1046__;
1674 int __rightop1042__ = __leftop1043__ + __rightop1044__;
1675 int __rightop1040__ = __leftop1041__ + __rightop1042__;
1676 int __rightop1038__ = __leftop1039__ + __rightop1040__;
1677 int __offsetinbits1036__ = __leftop1037__ + __rightop1038__;
1678 // __offsetinbits1036__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1679 int __offset1047__ = __offsetinbits1036__ >> 3;
1680 int __shift1048__ = __offsetinbits1036__ - (__offset1047__ << 3);
1681 int __rightop1033__ = ((*(int *)(__left1034__ + __offset1047__)) >> __shift1048__) & 0xffffffff;
1682 int __leftop1031__ = __leftop1032__ * __rightop1033__;
1683 int __rightop1049__ = 0;
1684 int __leftop1030__ = __leftop1031__ + __rightop1049__;
1685 int __rightop1050__ = (int) __itb__;
1686 int __rightop1029__ = __leftop1030__ * __rightop1050__;
1687 int __offsetinbits1027__ = __leftop1028__ + __rightop1029__;
1688 // __offsetinbits1027__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
1689 int __offset1051__ = __offsetinbits1027__ >> 3;
1690 int __expr1025__ = (__left1026__ + __offset1051__);
1691 int __left1024__ = (int) __expr1025__;
1692 // __left1024__ = cast(__InodeTable__, d.b[itb])
1693 // __offsetinbits1052__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1694 int __leftop1053__ = 0;
1695 int __leftop1056__ = 32;
1696 int __leftop1059__ = 32;
1697 int __rightop1060__ = 12;
1698 int __leftop1058__ = __leftop1059__ * __rightop1060__;
1699 int __leftop1062__ = 32;
1700 int __rightop1063__ = 0;
1701 int __rightop1061__ = __leftop1062__ + __rightop1063__;
1702 int __rightop1057__ = __leftop1058__ + __rightop1061__;
1703 int __leftop1055__ = __leftop1056__ + __rightop1057__;
1704 int __rightop1064__ = (int) __j__;
1705 int __rightop1054__ = __leftop1055__ * __rightop1064__;
1706 int __offsetinbits1052__ = __leftop1053__ + __rightop1054__;
1707 // __offsetinbits1052__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * j))
1708 int __offset1065__ = __offsetinbits1052__ >> 3;
1709 int __left1023__ = (__left1024__ + __offset1065__);
1710 // __left1023__ = cast(__InodeTable__, d.b[itb]).itable[j]
1711 int __rightele1022__ = ((*(int *)(__left1023__ + 0)) >> 0) & 0xffffffff;
1712 __filesize___hash->add((int)__leftele1021__, (int)__rightele1022__);
1721 int __tempvar1067__ = 0;
1722 // __left1070__ <-- d.s
1723 // __left1071__ <-- d
1724 int __left1071__ = (int) d;
1726 int __left1070__ = (__left1071__ + 0);
1727 // __left1070__ = d.s
1728 // __offsetinbits1072__ <-- (32 + (32 + 0))
1729 int __leftop1073__ = 32;
1730 int __leftop1075__ = 32;
1731 int __rightop1076__ = 0;
1732 int __rightop1074__ = __leftop1075__ + __rightop1076__;
1733 int __offsetinbits1072__ = __leftop1073__ + __rightop1074__;
1734 // __offsetinbits1072__ = (32 + (32 + 0))
1735 int __offset1077__ = __offsetinbits1072__ >> 3;
1736 int __shift1078__ = __offsetinbits1072__ - (__offset1077__ << 3);
1737 int __leftop1069__ = ((*(int *)(__left1070__ + __offset1077__)) >> __shift1078__) & 0xffffffff;
1738 int __rightop1079__ = 1;
1739 int __tempvar1068__ = __leftop1069__ - __rightop1079__;
1740 for (int __j__ = __tempvar1067__; __j__ <= __tempvar1068__; __j__++) {
1741 for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); ) {
1742 int __bbb__ = (int) __bbb___iterator->next();
1743 //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == false)
1744 // __left1082__ <-- cast(__BlockBitmap__, d.b[bbb])
1745 // __left1084__ <-- d
1746 int __left1084__ = (int) d;
1748 // __offsetinbits1085__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
1749 int __leftop1086__ = 0;
1750 int __leftop1090__ = 8;
1751 // __left1092__ <-- d.s
1752 // __left1093__ <-- d
1753 int __left1093__ = (int) d;
1755 int __left1092__ = (__left1093__ + 0);
1756 // __left1092__ = d.s
1757 // __offsetinbits1094__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1758 int __leftop1095__ = 32;
1759 int __leftop1097__ = 32;
1760 int __leftop1099__ = 32;
1761 int __leftop1101__ = 32;
1762 int __leftop1103__ = 32;
1763 int __rightop1104__ = 0;
1764 int __rightop1102__ = __leftop1103__ + __rightop1104__;
1765 int __rightop1100__ = __leftop1101__ + __rightop1102__;
1766 int __rightop1098__ = __leftop1099__ + __rightop1100__;
1767 int __rightop1096__ = __leftop1097__ + __rightop1098__;
1768 int __offsetinbits1094__ = __leftop1095__ + __rightop1096__;
1769 // __offsetinbits1094__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1770 int __offset1105__ = __offsetinbits1094__ >> 3;
1771 int __shift1106__ = __offsetinbits1094__ - (__offset1105__ << 3);
1772 int __rightop1091__ = ((*(int *)(__left1092__ + __offset1105__)) >> __shift1106__) & 0xffffffff;
1773 int __leftop1089__ = __leftop1090__ * __rightop1091__;
1774 int __rightop1107__ = 0;
1775 int __leftop1088__ = __leftop1089__ + __rightop1107__;
1776 int __rightop1108__ = (int) __bbb__;
1777 int __rightop1087__ = __leftop1088__ * __rightop1108__;
1778 int __offsetinbits1085__ = __leftop1086__ + __rightop1087__;
1779 // __offsetinbits1085__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
1780 int __offset1109__ = __offsetinbits1085__ >> 3;
1781 int __expr1083__ = (__left1084__ + __offset1109__);
1782 int __left1082__ = (int) __expr1083__;
1783 // __left1082__ = cast(__BlockBitmap__, d.b[bbb])
1784 // __offsetinbits1110__ <-- (0 + (1 * j))
1785 int __leftop1111__ = 0;
1786 int __leftop1113__ = 1;
1787 int __rightop1114__ = (int) __j__;
1788 int __rightop1112__ = __leftop1113__ * __rightop1114__;
1789 int __offsetinbits1110__ = __leftop1111__ + __rightop1112__;
1790 // __offsetinbits1110__ = (0 + (1 * j))
1791 int __offset1115__ = __offsetinbits1110__ >> 3;
1792 int __shift1116__ = __offsetinbits1110__ - (__offset1115__ << 3);
1793 int __leftop1081__ = ((*(int *)(__left1082__ + __offset1115__)) >> __shift1116__) & 0x1;
1794 int __rightop1117__ = 0;
1795 int __tempvar1080__ = __leftop1081__ == __rightop1117__;
1796 if (__tempvar1080__) {
1797 int __leftele1118__ = (int) __j__;
1798 int __rightele1119__ = 101;
1799 __blockstatus___hash->add((int)__leftele1118__, (int)__rightele1119__);
1808 int __tempvar1121__ = 0;
1809 // __left1124__ <-- d.s
1810 // __left1125__ <-- d
1811 int __left1125__ = (int) d;
1813 int __left1124__ = (__left1125__ + 0);
1814 // __left1124__ = d.s
1815 // __offsetinbits1126__ <-- (32 + (32 + 0))
1816 int __leftop1127__ = 32;
1817 int __leftop1129__ = 32;
1818 int __rightop1130__ = 0;
1819 int __rightop1128__ = __leftop1129__ + __rightop1130__;
1820 int __offsetinbits1126__ = __leftop1127__ + __rightop1128__;
1821 // __offsetinbits1126__ = (32 + (32 + 0))
1822 int __offset1131__ = __offsetinbits1126__ >> 3;
1823 int __shift1132__ = __offsetinbits1126__ - (__offset1131__ << 3);
1824 int __leftop1123__ = ((*(int *)(__left1124__ + __offset1131__)) >> __shift1132__) & 0xffffffff;
1825 int __rightop1133__ = 1;
1826 int __tempvar1122__ = __leftop1123__ - __rightop1133__;
1827 for (int __j__ = __tempvar1121__; __j__ <= __tempvar1122__; __j__++) {
1828 for (SimpleIterator* __bbb___iterator = __BlockBitmapBlock___hash->iterator(); __bbb___iterator->hasNext(); ) {
1829 int __bbb__ = (int) __bbb___iterator->next();
1830 //(cast(__BlockBitmap__, d.b[bbb]).blockbitmap[j] == true)
1831 // __left1136__ <-- cast(__BlockBitmap__, d.b[bbb])
1832 // __left1138__ <-- d
1833 int __left1138__ = (int) d;
1835 // __offsetinbits1139__ <-- (0 + (((8 * d.s.blocksize) + 0) * bbb))
1836 int __leftop1140__ = 0;
1837 int __leftop1144__ = 8;
1838 // __left1146__ <-- d.s
1839 // __left1147__ <-- d
1840 int __left1147__ = (int) d;
1842 int __left1146__ = (__left1147__ + 0);
1843 // __left1146__ = d.s
1844 // __offsetinbits1148__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
1845 int __leftop1149__ = 32;
1846 int __leftop1151__ = 32;
1847 int __leftop1153__ = 32;
1848 int __leftop1155__ = 32;
1849 int __leftop1157__ = 32;
1850 int __rightop1158__ = 0;
1851 int __rightop1156__ = __leftop1157__ + __rightop1158__;
1852 int __rightop1154__ = __leftop1155__ + __rightop1156__;
1853 int __rightop1152__ = __leftop1153__ + __rightop1154__;
1854 int __rightop1150__ = __leftop1151__ + __rightop1152__;
1855 int __offsetinbits1148__ = __leftop1149__ + __rightop1150__;
1856 // __offsetinbits1148__ = (32 + (32 + (32 + (32 + (32 + 0)))))
1857 int __offset1159__ = __offsetinbits1148__ >> 3;
1858 int __shift1160__ = __offsetinbits1148__ - (__offset1159__ << 3);
1859 int __rightop1145__ = ((*(int *)(__left1146__ + __offset1159__)) >> __shift1160__) & 0xffffffff;
1860 int __leftop1143__ = __leftop1144__ * __rightop1145__;
1861 int __rightop1161__ = 0;
1862 int __leftop1142__ = __leftop1143__ + __rightop1161__;
1863 int __rightop1162__ = (int) __bbb__;
1864 int __rightop1141__ = __leftop1142__ * __rightop1162__;
1865 int __offsetinbits1139__ = __leftop1140__ + __rightop1141__;
1866 // __offsetinbits1139__ = (0 + (((8 * d.s.blocksize) + 0) * bbb))
1867 int __offset1163__ = __offsetinbits1139__ >> 3;
1868 int __expr1137__ = (__left1138__ + __offset1163__);
1869 int __left1136__ = (int) __expr1137__;
1870 // __left1136__ = cast(__BlockBitmap__, d.b[bbb])
1871 // __offsetinbits1164__ <-- (0 + (1 * j))
1872 int __leftop1165__ = 0;
1873 int __leftop1167__ = 1;
1874 int __rightop1168__ = (int) __j__;
1875 int __rightop1166__ = __leftop1167__ * __rightop1168__;
1876 int __offsetinbits1164__ = __leftop1165__ + __rightop1166__;
1877 // __offsetinbits1164__ = (0 + (1 * j))
1878 int __offset1169__ = __offsetinbits1164__ >> 3;
1879 int __shift1170__ = __offsetinbits1164__ - (__offset1169__ << 3);
1880 int __leftop1135__ = ((*(int *)(__left1136__ + __offset1169__)) >> __shift1170__) & 0x1;
1881 int __rightop1171__ = 1;
1882 int __tempvar1134__ = __leftop1135__ == __rightop1171__;
1883 if (__tempvar1134__) {
1884 int __leftele1172__ = (int) __j__;
1885 int __rightele1173__ = 100;
1886 __blockstatus___hash->add((int)__leftele1172__, (int)__rightele1173__);
1895 for (SimpleIterator* __u___iterator = __UsedInode___hash->iterator(); __u___iterator->hasNext(); ) {
1896 int __u__ = (int) __u___iterator->next();
1897 int __relval1176__ = __inodestatus___hash->get(__u__);
1898 int __exprval1177__ = 100;
1899 int __constraintboolean1175__ = __relval1176__==__exprval1177__;
1900 if (!__constraintboolean1175__) {
1910 for (SimpleIterator* __f___iterator = __FreeInode___hash->iterator(); __f___iterator->hasNext(); ) {
1911 int __f__ = (int) __f___iterator->next();
1912 int __relval1179__ = __inodestatus___hash->get(__f__);
1913 int __exprval1180__ = 101;
1914 int __constraintboolean1178__ = __relval1179__==__exprval1180__;
1915 if (!__constraintboolean1178__) {
1925 for (SimpleIterator* __u___iterator = __UsedBlock___hash->iterator(); __u___iterator->hasNext(); ) {
1926 int __u__ = (int) __u___iterator->next();
1927 int __relval1182__ = __blockstatus___hash->get(__u__);
1928 int __exprval1183__ = 100;
1929 int __constraintboolean1181__ = __relval1182__==__exprval1183__;
1930 if (!__constraintboolean1181__) {
1940 for (SimpleIterator* __f___iterator = __FreeBlock___hash->iterator(); __f___iterator->hasNext(); ) {
1941 int __f__ = (int) __f___iterator->next();
1942 int __relval1185__ = __blockstatus___hash->get(__f__);
1943 int __exprval1186__ = 101;
1944 int __constraintboolean1184__ = __relval1185__==__exprval1186__;
1945 if (!__constraintboolean1184__) {
1955 for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1956 int __i__ = (int) __i___iterator->next();
1957 int __relval1188__ = __referencecount___hash->get(__i__);
1958 int __exprval1189__ = __inodeof___hashinv->count(__i__);
1959 int __constraintboolean1187__ = __relval1188__==__exprval1189__;
1960 if (!__constraintboolean1187__) {
1970 for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); ) {
1971 int __i__ = (int) __i___iterator->next();
1972 int __relval1191__ = __filesize___hash->get(__i__);
1973 int __leftop1193__ = __contents___hash->count(__i__);
1974 int __rightop1194__ = 8192;
1975 int __exprval1192__ = __leftop1193__ * __rightop1194__;
1976 int __constraintboolean1190__ = __relval1191__<=__exprval1192__;
1977 if (!__constraintboolean1190__) {
1987 for (SimpleIterator* __b___iterator = __FileDirectoryBlock___hash->iterator(); __b___iterator->hasNext(); ) {
1988 int __b__ = (int) __b___iterator->next();
1989 int __size1196__ = __contents___hashinv->count(__b__);
1990 int __constraintboolean1195__ = __size1196__==1;
1991 if (!__constraintboolean1195__) {
2001 int __size1198__ = __SuperBlock___hash->count();
2002 int __constraintboolean1197__ = __size1198__==1;
2003 if (!__constraintboolean1197__) {
2012 int __size1200__ = __GroupBlock___hash->count();
2013 int __constraintboolean1199__ = __size1200__==1;
2014 if (!__constraintboolean1199__) {
2023 int __size1202__ = __InodeTableBlock___hash->count();
2024 int __constraintboolean1201__ = __size1202__==1;
2025 if (!__constraintboolean1201__) {
2034 int __size1204__ = __InodeBitmapBlock___hash->count();
2035 int __constraintboolean1203__ = __size1204__==1;
2036 if (!__constraintboolean1203__) {
2045 int __size1206__ = __BlockBitmapBlock___hash->count();
2046 int __constraintboolean1205__ = __size1206__==1;
2047 if (!__constraintboolean1205__) {
2056 int __size1208__ = __RootDirectoryInode___hash->count();
2057 int __constraintboolean1207__ = __size1208__==1;
2058 if (!__constraintboolean1207__) {
2065 if (__Success) { printf("all tests passed"); }
projects / repair.git / blob