+ int __leftele2427__ = (int) __j__; //varexpr
+ int __rightele2428__ = 100;
+ int __addeditem2430__;
+ __addeditem2430__ = __blockstatus___hash->add((int)__leftele2427__, (int)__rightele2428__);
+ }
+ }
+ }
+ }
+
+
+// build rule20
+ {
+ //true
+ int __tempvar2431__ = 1;
+ if (__tempvar2431__)
+ {
+ int __element2432__ = 0;
+ int __addeditem2433__ = 1;
+ __addeditem2433__ = __Block___hash->add((int)__element2432__, (int)__element2432__);
+ }
+ }
+
+
+// build rule21
+ {
+ //true
+ int __tempvar2434__ = 1;
+ if (__tempvar2434__)
+ {
+ int __element2435__ = 1;
+ int __addeditem2436__ = 1;
+ __addeditem2436__ = __Block___hash->add((int)__element2435__, (int)__element2435__);
+ }
+ }
+
+
+// build rule22
+ {
+ //(d.g.InodeTableBlock < d.s.NumberofBlocks)
+ // __left2439__ <-- d.g
+ // __left2440__ <-- d
+ int __left2440__ = (int) d; //varexpr
+ // __left2440__ = d
+ // __offsetinbits2441__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2442__ = 0;
+ int __leftop2446__ = 8;
+ // __left2448__ <-- d.s
+ // __left2449__ <-- d
+ int __left2449__ = (int) d; //varexpr
+ // __left2449__ = d
+ int __left2448__ = (__left2449__ + 0);
+ int __leftop2451__ = 32;
+ int __leftop2453__ = 32;
+ int __leftop2455__ = 32;
+ int __leftop2457__ = 32;
+ int __leftop2459__ = 32;
+ int __leftop2461__ = 32;
+ int __rightop2462__ = 0;
+ int __rightop2460__ = __leftop2461__ + __rightop2462__;
+ int __rightop2458__ = __leftop2459__ + __rightop2460__;
+ int __rightop2456__ = __leftop2457__ + __rightop2458__;
+ int __rightop2454__ = __leftop2455__ + __rightop2456__;
+ int __rightop2452__ = __leftop2453__ + __rightop2454__;
+ int __sizeof2450__ = __leftop2451__ + __rightop2452__;
+ int __high2463__ = __left2448__ + __sizeof2450__;
+ assertvalidmemory(__left2448__, __high2463__);
+ // __left2448__ = d.s
+ // __offsetinbits2464__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2465__ = 32;
+ int __leftop2467__ = 32;
+ int __leftop2469__ = 32;
+ int __leftop2471__ = 32;
+ int __leftop2473__ = 32;
+ int __rightop2474__ = 0;
+ int __rightop2472__ = __leftop2473__ + __rightop2474__;
+ int __rightop2470__ = __leftop2471__ + __rightop2472__;
+ int __rightop2468__ = __leftop2469__ + __rightop2470__;
+ int __rightop2466__ = __leftop2467__ + __rightop2468__;
+ int __offsetinbits2464__ = __leftop2465__ + __rightop2466__;
+ // __offsetinbits2464__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2475__ = __offsetinbits2464__ >> 3;
+ int __shift2476__ = __offsetinbits2464__ - (__offset2475__ << 3);
+ int __rightop2447__ = ((*(int *)(__left2448__ + __offset2475__)) >> __shift2476__) & 0xffffffff;
+ int __leftop2445__ = __leftop2446__ * __rightop2447__;
+ int __rightop2477__ = 0;
+ int __leftop2444__ = __leftop2445__ + __rightop2477__;
+ int __rightop2478__ = 1;
+ int __rightop2443__ = __leftop2444__ * __rightop2478__;
+ int __offsetinbits2441__ = __leftop2442__ + __rightop2443__;
+ // __offsetinbits2441__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2479__ = __offsetinbits2441__ >> 3;
+ int __left2439__ = (__left2440__ + __offset2479__);
+ int __leftop2481__ = 32;
+ int __leftop2483__ = 32;
+ int __leftop2485__ = 32;
+ int __leftop2487__ = 32;
+ int __leftop2489__ = 32;
+ int __rightop2490__ = 0;
+ int __rightop2488__ = __leftop2489__ + __rightop2490__;
+ int __rightop2486__ = __leftop2487__ + __rightop2488__;
+ int __rightop2484__ = __leftop2485__ + __rightop2486__;
+ int __rightop2482__ = __leftop2483__ + __rightop2484__;
+ int __sizeof2480__ = __leftop2481__ + __rightop2482__;
+ int __high2491__ = __left2439__ + __sizeof2480__;
+ assertvalidmemory(__left2439__, __high2491__);
+ // __left2439__ = d.g
+ // __offsetinbits2492__ <-- (32 + (32 + 0))
+ int __leftop2493__ = 32;
+ int __leftop2495__ = 32;
+ int __rightop2496__ = 0;
+ int __rightop2494__ = __leftop2495__ + __rightop2496__;
+ int __offsetinbits2492__ = __leftop2493__ + __rightop2494__;
+ // __offsetinbits2492__ = (32 + (32 + 0))
+ int __offset2497__ = __offsetinbits2492__ >> 3;
+ int __shift2498__ = __offsetinbits2492__ - (__offset2497__ << 3);
+ int __leftop2438__ = ((*(int *)(__left2439__ + __offset2497__)) >> __shift2498__) & 0xffffffff;
+ // __left2500__ <-- d.s
+ // __left2501__ <-- d
+ int __left2501__ = (int) d; //varexpr
+ // __left2501__ = d
+ int __left2500__ = (__left2501__ + 0);
+ int __leftop2503__ = 32;
+ int __leftop2505__ = 32;
+ int __leftop2507__ = 32;
+ int __leftop2509__ = 32;
+ int __leftop2511__ = 32;
+ int __leftop2513__ = 32;
+ int __rightop2514__ = 0;
+ int __rightop2512__ = __leftop2513__ + __rightop2514__;
+ int __rightop2510__ = __leftop2511__ + __rightop2512__;
+ int __rightop2508__ = __leftop2509__ + __rightop2510__;
+ int __rightop2506__ = __leftop2507__ + __rightop2508__;
+ int __rightop2504__ = __leftop2505__ + __rightop2506__;
+ int __sizeof2502__ = __leftop2503__ + __rightop2504__;
+ int __high2515__ = __left2500__ + __sizeof2502__;
+ assertvalidmemory(__left2500__, __high2515__);
+ // __left2500__ = d.s
+ // __offsetinbits2516__ <-- (32 + (32 + 0))
+ int __leftop2517__ = 32;
+ int __leftop2519__ = 32;
+ int __rightop2520__ = 0;
+ int __rightop2518__ = __leftop2519__ + __rightop2520__;
+ int __offsetinbits2516__ = __leftop2517__ + __rightop2518__;
+ // __offsetinbits2516__ = (32 + (32 + 0))
+ int __offset2521__ = __offsetinbits2516__ >> 3;
+ int __shift2522__ = __offsetinbits2516__ - (__offset2521__ << 3);
+ int __rightop2499__ = ((*(int *)(__left2500__ + __offset2521__)) >> __shift2522__) & 0xffffffff;
+ int __tempvar2437__ = __leftop2438__ < __rightop2499__;
+ if (__tempvar2437__)
+ {
+ // __left2524__ <-- d.g
+ // __left2525__ <-- d
+ int __left2525__ = (int) d; //varexpr
+ // __left2525__ = d
+ // __offsetinbits2526__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2527__ = 0;
+ int __leftop2531__ = 8;
+ // __left2533__ <-- d.s
+ // __left2534__ <-- d
+ int __left2534__ = (int) d; //varexpr
+ // __left2534__ = d
+ int __left2533__ = (__left2534__ + 0);
+ int __leftop2536__ = 32;
+ int __leftop2538__ = 32;
+ int __leftop2540__ = 32;
+ int __leftop2542__ = 32;
+ int __leftop2544__ = 32;
+ int __leftop2546__ = 32;
+ int __rightop2547__ = 0;
+ int __rightop2545__ = __leftop2546__ + __rightop2547__;
+ int __rightop2543__ = __leftop2544__ + __rightop2545__;
+ int __rightop2541__ = __leftop2542__ + __rightop2543__;
+ int __rightop2539__ = __leftop2540__ + __rightop2541__;
+ int __rightop2537__ = __leftop2538__ + __rightop2539__;
+ int __sizeof2535__ = __leftop2536__ + __rightop2537__;
+ int __high2548__ = __left2533__ + __sizeof2535__;
+ assertvalidmemory(__left2533__, __high2548__);
+ // __left2533__ = d.s
+ // __offsetinbits2549__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2550__ = 32;
+ int __leftop2552__ = 32;
+ int __leftop2554__ = 32;
+ int __leftop2556__ = 32;
+ int __leftop2558__ = 32;
+ int __rightop2559__ = 0;
+ int __rightop2557__ = __leftop2558__ + __rightop2559__;
+ int __rightop2555__ = __leftop2556__ + __rightop2557__;
+ int __rightop2553__ = __leftop2554__ + __rightop2555__;
+ int __rightop2551__ = __leftop2552__ + __rightop2553__;
+ int __offsetinbits2549__ = __leftop2550__ + __rightop2551__;
+ // __offsetinbits2549__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2560__ = __offsetinbits2549__ >> 3;
+ int __shift2561__ = __offsetinbits2549__ - (__offset2560__ << 3);
+ int __rightop2532__ = ((*(int *)(__left2533__ + __offset2560__)) >> __shift2561__) & 0xffffffff;
+ int __leftop2530__ = __leftop2531__ * __rightop2532__;
+ int __rightop2562__ = 0;
+ int __leftop2529__ = __leftop2530__ + __rightop2562__;
+ int __rightop2563__ = 1;
+ int __rightop2528__ = __leftop2529__ * __rightop2563__;
+ int __offsetinbits2526__ = __leftop2527__ + __rightop2528__;
+ // __offsetinbits2526__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2564__ = __offsetinbits2526__ >> 3;
+ int __left2524__ = (__left2525__ + __offset2564__);
+ int __leftop2566__ = 32;
+ int __leftop2568__ = 32;
+ int __leftop2570__ = 32;
+ int __leftop2572__ = 32;
+ int __leftop2574__ = 32;
+ int __rightop2575__ = 0;
+ int __rightop2573__ = __leftop2574__ + __rightop2575__;
+ int __rightop2571__ = __leftop2572__ + __rightop2573__;
+ int __rightop2569__ = __leftop2570__ + __rightop2571__;
+ int __rightop2567__ = __leftop2568__ + __rightop2569__;
+ int __sizeof2565__ = __leftop2566__ + __rightop2567__;
+ int __high2576__ = __left2524__ + __sizeof2565__;
+ assertvalidmemory(__left2524__, __high2576__);
+ // __left2524__ = d.g
+ // __offsetinbits2577__ <-- (32 + (32 + 0))
+ int __leftop2578__ = 32;
+ int __leftop2580__ = 32;
+ int __rightop2581__ = 0;
+ int __rightop2579__ = __leftop2580__ + __rightop2581__;
+ int __offsetinbits2577__ = __leftop2578__ + __rightop2579__;
+ // __offsetinbits2577__ = (32 + (32 + 0))
+ int __offset2582__ = __offsetinbits2577__ >> 3;
+ int __shift2583__ = __offsetinbits2577__ - (__offset2582__ << 3);
+ int __element2523__ = ((*(int *)(__left2524__ + __offset2582__)) >> __shift2583__) & 0xffffffff;
+ int __addeditem2584__ = 1;
+ __addeditem2584__ = __Block___hash->add((int)__element2523__, (int)__element2523__);
+ }
+ }
+
+
+// build rule23
+ {
+ //(d.g.InodeBitmapBlock < d.s.NumberofBlocks)
+ // __left2587__ <-- d.g
+ // __left2588__ <-- d
+ int __left2588__ = (int) d; //varexpr
+ // __left2588__ = d
+ // __offsetinbits2589__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2590__ = 0;
+ int __leftop2594__ = 8;
+ // __left2596__ <-- d.s
+ // __left2597__ <-- d
+ int __left2597__ = (int) d; //varexpr
+ // __left2597__ = d
+ int __left2596__ = (__left2597__ + 0);
+ int __leftop2599__ = 32;
+ int __leftop2601__ = 32;
+ int __leftop2603__ = 32;
+ int __leftop2605__ = 32;
+ int __leftop2607__ = 32;
+ int __leftop2609__ = 32;
+ int __rightop2610__ = 0;
+ int __rightop2608__ = __leftop2609__ + __rightop2610__;
+ int __rightop2606__ = __leftop2607__ + __rightop2608__;
+ int __rightop2604__ = __leftop2605__ + __rightop2606__;
+ int __rightop2602__ = __leftop2603__ + __rightop2604__;
+ int __rightop2600__ = __leftop2601__ + __rightop2602__;
+ int __sizeof2598__ = __leftop2599__ + __rightop2600__;
+ int __high2611__ = __left2596__ + __sizeof2598__;
+ assertvalidmemory(__left2596__, __high2611__);
+ // __left2596__ = d.s
+ // __offsetinbits2612__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2613__ = 32;
+ int __leftop2615__ = 32;
+ int __leftop2617__ = 32;
+ int __leftop2619__ = 32;
+ int __leftop2621__ = 32;
+ int __rightop2622__ = 0;
+ int __rightop2620__ = __leftop2621__ + __rightop2622__;
+ int __rightop2618__ = __leftop2619__ + __rightop2620__;
+ int __rightop2616__ = __leftop2617__ + __rightop2618__;
+ int __rightop2614__ = __leftop2615__ + __rightop2616__;
+ int __offsetinbits2612__ = __leftop2613__ + __rightop2614__;
+ // __offsetinbits2612__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2623__ = __offsetinbits2612__ >> 3;
+ int __shift2624__ = __offsetinbits2612__ - (__offset2623__ << 3);
+ int __rightop2595__ = ((*(int *)(__left2596__ + __offset2623__)) >> __shift2624__) & 0xffffffff;
+ int __leftop2593__ = __leftop2594__ * __rightop2595__;
+ int __rightop2625__ = 0;
+ int __leftop2592__ = __leftop2593__ + __rightop2625__;
+ int __rightop2626__ = 1;
+ int __rightop2591__ = __leftop2592__ * __rightop2626__;
+ int __offsetinbits2589__ = __leftop2590__ + __rightop2591__;
+ // __offsetinbits2589__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2627__ = __offsetinbits2589__ >> 3;
+ int __left2587__ = (__left2588__ + __offset2627__);
+ int __leftop2629__ = 32;
+ int __leftop2631__ = 32;
+ int __leftop2633__ = 32;
+ int __leftop2635__ = 32;
+ int __leftop2637__ = 32;
+ int __rightop2638__ = 0;
+ int __rightop2636__ = __leftop2637__ + __rightop2638__;
+ int __rightop2634__ = __leftop2635__ + __rightop2636__;
+ int __rightop2632__ = __leftop2633__ + __rightop2634__;
+ int __rightop2630__ = __leftop2631__ + __rightop2632__;
+ int __sizeof2628__ = __leftop2629__ + __rightop2630__;
+ int __high2639__ = __left2587__ + __sizeof2628__;
+ assertvalidmemory(__left2587__, __high2639__);
+ // __left2587__ = d.g
+ // __offsetinbits2640__ <-- (32 + 0)
+ int __leftop2641__ = 32;
+ int __rightop2642__ = 0;
+ int __offsetinbits2640__ = __leftop2641__ + __rightop2642__;
+ // __offsetinbits2640__ = (32 + 0)
+ int __offset2643__ = __offsetinbits2640__ >> 3;
+ int __shift2644__ = __offsetinbits2640__ - (__offset2643__ << 3);
+ int __leftop2586__ = ((*(int *)(__left2587__ + __offset2643__)) >> __shift2644__) & 0xffffffff;
+ // __left2646__ <-- d.s
+ // __left2647__ <-- d
+ int __left2647__ = (int) d; //varexpr
+ // __left2647__ = d
+ int __left2646__ = (__left2647__ + 0);
+ int __leftop2649__ = 32;
+ int __leftop2651__ = 32;
+ int __leftop2653__ = 32;
+ int __leftop2655__ = 32;
+ int __leftop2657__ = 32;
+ int __leftop2659__ = 32;
+ int __rightop2660__ = 0;
+ int __rightop2658__ = __leftop2659__ + __rightop2660__;
+ int __rightop2656__ = __leftop2657__ + __rightop2658__;
+ int __rightop2654__ = __leftop2655__ + __rightop2656__;
+ int __rightop2652__ = __leftop2653__ + __rightop2654__;
+ int __rightop2650__ = __leftop2651__ + __rightop2652__;
+ int __sizeof2648__ = __leftop2649__ + __rightop2650__;
+ int __high2661__ = __left2646__ + __sizeof2648__;
+ assertvalidmemory(__left2646__, __high2661__);
+ // __left2646__ = d.s
+ // __offsetinbits2662__ <-- (32 + (32 + 0))
+ int __leftop2663__ = 32;
+ int __leftop2665__ = 32;
+ int __rightop2666__ = 0;
+ int __rightop2664__ = __leftop2665__ + __rightop2666__;
+ int __offsetinbits2662__ = __leftop2663__ + __rightop2664__;
+ // __offsetinbits2662__ = (32 + (32 + 0))
+ int __offset2667__ = __offsetinbits2662__ >> 3;
+ int __shift2668__ = __offsetinbits2662__ - (__offset2667__ << 3);
+ int __rightop2645__ = ((*(int *)(__left2646__ + __offset2667__)) >> __shift2668__) & 0xffffffff;
+ int __tempvar2585__ = __leftop2586__ < __rightop2645__;
+ if (__tempvar2585__)
+ {
+ // __left2670__ <-- d.g
+ // __left2671__ <-- d
+ int __left2671__ = (int) d; //varexpr
+ // __left2671__ = d
+ // __offsetinbits2672__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2673__ = 0;
+ int __leftop2677__ = 8;
+ // __left2679__ <-- d.s
+ // __left2680__ <-- d
+ int __left2680__ = (int) d; //varexpr
+ // __left2680__ = d
+ int __left2679__ = (__left2680__ + 0);
+ int __leftop2682__ = 32;
+ int __leftop2684__ = 32;
+ int __leftop2686__ = 32;
+ int __leftop2688__ = 32;
+ int __leftop2690__ = 32;
+ int __leftop2692__ = 32;
+ int __rightop2693__ = 0;
+ int __rightop2691__ = __leftop2692__ + __rightop2693__;
+ int __rightop2689__ = __leftop2690__ + __rightop2691__;
+ int __rightop2687__ = __leftop2688__ + __rightop2689__;
+ int __rightop2685__ = __leftop2686__ + __rightop2687__;
+ int __rightop2683__ = __leftop2684__ + __rightop2685__;
+ int __sizeof2681__ = __leftop2682__ + __rightop2683__;
+ int __high2694__ = __left2679__ + __sizeof2681__;
+ assertvalidmemory(__left2679__, __high2694__);
+ // __left2679__ = d.s
+ // __offsetinbits2695__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2696__ = 32;
+ int __leftop2698__ = 32;
+ int __leftop2700__ = 32;
+ int __leftop2702__ = 32;
+ int __leftop2704__ = 32;
+ int __rightop2705__ = 0;
+ int __rightop2703__ = __leftop2704__ + __rightop2705__;
+ int __rightop2701__ = __leftop2702__ + __rightop2703__;
+ int __rightop2699__ = __leftop2700__ + __rightop2701__;
+ int __rightop2697__ = __leftop2698__ + __rightop2699__;
+ int __offsetinbits2695__ = __leftop2696__ + __rightop2697__;
+ // __offsetinbits2695__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2706__ = __offsetinbits2695__ >> 3;
+ int __shift2707__ = __offsetinbits2695__ - (__offset2706__ << 3);
+ int __rightop2678__ = ((*(int *)(__left2679__ + __offset2706__)) >> __shift2707__) & 0xffffffff;
+ int __leftop2676__ = __leftop2677__ * __rightop2678__;
+ int __rightop2708__ = 0;
+ int __leftop2675__ = __leftop2676__ + __rightop2708__;
+ int __rightop2709__ = 1;
+ int __rightop2674__ = __leftop2675__ * __rightop2709__;
+ int __offsetinbits2672__ = __leftop2673__ + __rightop2674__;
+ // __offsetinbits2672__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2710__ = __offsetinbits2672__ >> 3;
+ int __left2670__ = (__left2671__ + __offset2710__);
+ int __leftop2712__ = 32;
+ int __leftop2714__ = 32;
+ int __leftop2716__ = 32;
+ int __leftop2718__ = 32;
+ int __leftop2720__ = 32;
+ int __rightop2721__ = 0;
+ int __rightop2719__ = __leftop2720__ + __rightop2721__;
+ int __rightop2717__ = __leftop2718__ + __rightop2719__;
+ int __rightop2715__ = __leftop2716__ + __rightop2717__;
+ int __rightop2713__ = __leftop2714__ + __rightop2715__;
+ int __sizeof2711__ = __leftop2712__ + __rightop2713__;
+ int __high2722__ = __left2670__ + __sizeof2711__;
+ assertvalidmemory(__left2670__, __high2722__);
+ // __left2670__ = d.g
+ // __offsetinbits2723__ <-- (32 + 0)
+ int __leftop2724__ = 32;
+ int __rightop2725__ = 0;
+ int __offsetinbits2723__ = __leftop2724__ + __rightop2725__;
+ // __offsetinbits2723__ = (32 + 0)
+ int __offset2726__ = __offsetinbits2723__ >> 3;
+ int __shift2727__ = __offsetinbits2723__ - (__offset2726__ << 3);
+ int __element2669__ = ((*(int *)(__left2670__ + __offset2726__)) >> __shift2727__) & 0xffffffff;
+ int __addeditem2728__ = 1;
+ __addeditem2728__ = __Block___hash->add((int)__element2669__, (int)__element2669__);
+ }
+ }
+
+
+// build rule24
+ {
+ //(d.g.BlockBitmapBlock < d.s.NumberofBlocks)
+ // __left2731__ <-- d.g
+ // __left2732__ <-- d
+ int __left2732__ = (int) d; //varexpr
+ // __left2732__ = d
+ // __offsetinbits2733__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2734__ = 0;
+ int __leftop2738__ = 8;
+ // __left2740__ <-- d.s
+ // __left2741__ <-- d
+ int __left2741__ = (int) d; //varexpr
+ // __left2741__ = d
+ int __left2740__ = (__left2741__ + 0);
+ int __leftop2743__ = 32;
+ int __leftop2745__ = 32;
+ int __leftop2747__ = 32;
+ int __leftop2749__ = 32;
+ int __leftop2751__ = 32;
+ int __leftop2753__ = 32;
+ int __rightop2754__ = 0;
+ int __rightop2752__ = __leftop2753__ + __rightop2754__;
+ int __rightop2750__ = __leftop2751__ + __rightop2752__;
+ int __rightop2748__ = __leftop2749__ + __rightop2750__;
+ int __rightop2746__ = __leftop2747__ + __rightop2748__;
+ int __rightop2744__ = __leftop2745__ + __rightop2746__;
+ int __sizeof2742__ = __leftop2743__ + __rightop2744__;
+ int __high2755__ = __left2740__ + __sizeof2742__;
+ assertvalidmemory(__left2740__, __high2755__);
+ // __left2740__ = d.s
+ // __offsetinbits2756__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2757__ = 32;
+ int __leftop2759__ = 32;
+ int __leftop2761__ = 32;
+ int __leftop2763__ = 32;
+ int __leftop2765__ = 32;
+ int __rightop2766__ = 0;
+ int __rightop2764__ = __leftop2765__ + __rightop2766__;
+ int __rightop2762__ = __leftop2763__ + __rightop2764__;
+ int __rightop2760__ = __leftop2761__ + __rightop2762__;
+ int __rightop2758__ = __leftop2759__ + __rightop2760__;
+ int __offsetinbits2756__ = __leftop2757__ + __rightop2758__;
+ // __offsetinbits2756__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2767__ = __offsetinbits2756__ >> 3;
+ int __shift2768__ = __offsetinbits2756__ - (__offset2767__ << 3);
+ int __rightop2739__ = ((*(int *)(__left2740__ + __offset2767__)) >> __shift2768__) & 0xffffffff;
+ int __leftop2737__ = __leftop2738__ * __rightop2739__;
+ int __rightop2769__ = 0;
+ int __leftop2736__ = __leftop2737__ + __rightop2769__;
+ int __rightop2770__ = 1;
+ int __rightop2735__ = __leftop2736__ * __rightop2770__;
+ int __offsetinbits2733__ = __leftop2734__ + __rightop2735__;
+ // __offsetinbits2733__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2771__ = __offsetinbits2733__ >> 3;
+ int __left2731__ = (__left2732__ + __offset2771__);
+ int __leftop2773__ = 32;
+ int __leftop2775__ = 32;
+ int __leftop2777__ = 32;
+ int __leftop2779__ = 32;
+ int __leftop2781__ = 32;
+ int __rightop2782__ = 0;
+ int __rightop2780__ = __leftop2781__ + __rightop2782__;
+ int __rightop2778__ = __leftop2779__ + __rightop2780__;
+ int __rightop2776__ = __leftop2777__ + __rightop2778__;
+ int __rightop2774__ = __leftop2775__ + __rightop2776__;
+ int __sizeof2772__ = __leftop2773__ + __rightop2774__;
+ int __high2783__ = __left2731__ + __sizeof2772__;
+ assertvalidmemory(__left2731__, __high2783__);
+ // __left2731__ = d.g
+ int __leftop2730__ = ((*(int *)(__left2731__ + 0)) >> 0) & 0xffffffff;
+ // __left2785__ <-- d.s
+ // __left2786__ <-- d
+ int __left2786__ = (int) d; //varexpr
+ // __left2786__ = d
+ int __left2785__ = (__left2786__ + 0);
+ int __leftop2788__ = 32;
+ int __leftop2790__ = 32;
+ int __leftop2792__ = 32;
+ int __leftop2794__ = 32;
+ int __leftop2796__ = 32;
+ int __leftop2798__ = 32;
+ int __rightop2799__ = 0;
+ int __rightop2797__ = __leftop2798__ + __rightop2799__;
+ int __rightop2795__ = __leftop2796__ + __rightop2797__;
+ int __rightop2793__ = __leftop2794__ + __rightop2795__;
+ int __rightop2791__ = __leftop2792__ + __rightop2793__;
+ int __rightop2789__ = __leftop2790__ + __rightop2791__;
+ int __sizeof2787__ = __leftop2788__ + __rightop2789__;
+ int __high2800__ = __left2785__ + __sizeof2787__;
+ assertvalidmemory(__left2785__, __high2800__);
+ // __left2785__ = d.s
+ // __offsetinbits2801__ <-- (32 + (32 + 0))
+ int __leftop2802__ = 32;
+ int __leftop2804__ = 32;
+ int __rightop2805__ = 0;
+ int __rightop2803__ = __leftop2804__ + __rightop2805__;
+ int __offsetinbits2801__ = __leftop2802__ + __rightop2803__;
+ // __offsetinbits2801__ = (32 + (32 + 0))
+ int __offset2806__ = __offsetinbits2801__ >> 3;
+ int __shift2807__ = __offsetinbits2801__ - (__offset2806__ << 3);
+ int __rightop2784__ = ((*(int *)(__left2785__ + __offset2806__)) >> __shift2807__) & 0xffffffff;
+ int __tempvar2729__ = __leftop2730__ < __rightop2784__;
+ if (__tempvar2729__)
+ {
+ // __left2809__ <-- d.g
+ // __left2810__ <-- d
+ int __left2810__ = (int) d; //varexpr
+ // __left2810__ = d
+ // __offsetinbits2811__ <-- (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __leftop2812__ = 0;
+ int __leftop2816__ = 8;
+ // __left2818__ <-- d.s
+ // __left2819__ <-- d
+ int __left2819__ = (int) d; //varexpr
+ // __left2819__ = d
+ int __left2818__ = (__left2819__ + 0);
+ int __leftop2821__ = 32;
+ int __leftop2823__ = 32;
+ int __leftop2825__ = 32;
+ int __leftop2827__ = 32;
+ int __leftop2829__ = 32;
+ int __leftop2831__ = 32;
+ int __rightop2832__ = 0;
+ int __rightop2830__ = __leftop2831__ + __rightop2832__;
+ int __rightop2828__ = __leftop2829__ + __rightop2830__;
+ int __rightop2826__ = __leftop2827__ + __rightop2828__;
+ int __rightop2824__ = __leftop2825__ + __rightop2826__;
+ int __rightop2822__ = __leftop2823__ + __rightop2824__;
+ int __sizeof2820__ = __leftop2821__ + __rightop2822__;
+ int __high2833__ = __left2818__ + __sizeof2820__;
+ assertvalidmemory(__left2818__, __high2833__);
+ // __left2818__ = d.s
+ // __offsetinbits2834__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2835__ = 32;
+ int __leftop2837__ = 32;
+ int __leftop2839__ = 32;
+ int __leftop2841__ = 32;
+ int __leftop2843__ = 32;
+ int __rightop2844__ = 0;
+ int __rightop2842__ = __leftop2843__ + __rightop2844__;
+ int __rightop2840__ = __leftop2841__ + __rightop2842__;
+ int __rightop2838__ = __leftop2839__ + __rightop2840__;
+ int __rightop2836__ = __leftop2837__ + __rightop2838__;
+ int __offsetinbits2834__ = __leftop2835__ + __rightop2836__;
+ // __offsetinbits2834__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2845__ = __offsetinbits2834__ >> 3;
+ int __shift2846__ = __offsetinbits2834__ - (__offset2845__ << 3);
+ int __rightop2817__ = ((*(int *)(__left2818__ + __offset2845__)) >> __shift2846__) & 0xffffffff;
+ int __leftop2815__ = __leftop2816__ * __rightop2817__;
+ int __rightop2847__ = 0;
+ int __leftop2814__ = __leftop2815__ + __rightop2847__;
+ int __rightop2848__ = 1;
+ int __rightop2813__ = __leftop2814__ * __rightop2848__;
+ int __offsetinbits2811__ = __leftop2812__ + __rightop2813__;
+ // __offsetinbits2811__ = (0 + (((8 * d.s.blocksize) + 0) * 1))
+ int __offset2849__ = __offsetinbits2811__ >> 3;
+ int __left2809__ = (__left2810__ + __offset2849__);
+ int __leftop2851__ = 32;
+ int __leftop2853__ = 32;
+ int __leftop2855__ = 32;
+ int __leftop2857__ = 32;
+ int __leftop2859__ = 32;
+ int __rightop2860__ = 0;
+ int __rightop2858__ = __leftop2859__ + __rightop2860__;
+ int __rightop2856__ = __leftop2857__ + __rightop2858__;
+ int __rightop2854__ = __leftop2855__ + __rightop2856__;
+ int __rightop2852__ = __leftop2853__ + __rightop2854__;
+ int __sizeof2850__ = __leftop2851__ + __rightop2852__;
+ int __high2861__ = __left2809__ + __sizeof2850__;
+ assertvalidmemory(__left2809__, __high2861__);
+ // __left2809__ = d.g
+ int __element2808__ = ((*(int *)(__left2809__ + 0)) >> 0) & 0xffffffff;
+ int __addeditem2862__ = 1;
+ __addeditem2862__ = __Block___hash->add((int)__element2808__, (int)__element2808__);
+ }
+ }
+
+
+// build rule25
+ {
+ //(d.s.RootDirectoryInode < d.s.NumberofInodes)
+ // __left2865__ <-- d.s
+ // __left2866__ <-- d
+ int __left2866__ = (int) d; //varexpr
+ // __left2866__ = d
+ int __left2865__ = (__left2866__ + 0);
+ int __leftop2868__ = 32;
+ int __leftop2870__ = 32;
+ int __leftop2872__ = 32;
+ int __leftop2874__ = 32;
+ int __leftop2876__ = 32;
+ int __leftop2878__ = 32;
+ int __rightop2879__ = 0;
+ int __rightop2877__ = __leftop2878__ + __rightop2879__;
+ int __rightop2875__ = __leftop2876__ + __rightop2877__;
+ int __rightop2873__ = __leftop2874__ + __rightop2875__;
+ int __rightop2871__ = __leftop2872__ + __rightop2873__;
+ int __rightop2869__ = __leftop2870__ + __rightop2871__;
+ int __sizeof2867__ = __leftop2868__ + __rightop2869__;
+ int __high2880__ = __left2865__ + __sizeof2867__;
+ assertvalidmemory(__left2865__, __high2880__);
+ // __left2865__ = d.s
+ // __offsetinbits2881__ <-- (32 + (32 + (32 + (32 + 0))))
+ int __leftop2882__ = 32;
+ int __leftop2884__ = 32;
+ int __leftop2886__ = 32;
+ int __leftop2888__ = 32;
+ int __rightop2889__ = 0;
+ int __rightop2887__ = __leftop2888__ + __rightop2889__;
+ int __rightop2885__ = __leftop2886__ + __rightop2887__;
+ int __rightop2883__ = __leftop2884__ + __rightop2885__;
+ int __offsetinbits2881__ = __leftop2882__ + __rightop2883__;
+ // __offsetinbits2881__ = (32 + (32 + (32 + (32 + 0))))
+ int __offset2890__ = __offsetinbits2881__ >> 3;
+ int __shift2891__ = __offsetinbits2881__ - (__offset2890__ << 3);
+ int __leftop2864__ = ((*(int *)(__left2865__ + __offset2890__)) >> __shift2891__) & 0xffffffff;
+ // __left2893__ <-- d.s
+ // __left2894__ <-- d
+ int __left2894__ = (int) d; //varexpr
+ // __left2894__ = d
+ int __left2893__ = (__left2894__ + 0);
+ int __leftop2896__ = 32;
+ int __leftop2898__ = 32;
+ int __leftop2900__ = 32;
+ int __leftop2902__ = 32;
+ int __leftop2904__ = 32;
+ int __leftop2906__ = 32;
+ int __rightop2907__ = 0;
+ int __rightop2905__ = __leftop2906__ + __rightop2907__;
+ int __rightop2903__ = __leftop2904__ + __rightop2905__;
+ int __rightop2901__ = __leftop2902__ + __rightop2903__;
+ int __rightop2899__ = __leftop2900__ + __rightop2901__;
+ int __rightop2897__ = __leftop2898__ + __rightop2899__;
+ int __sizeof2895__ = __leftop2896__ + __rightop2897__;
+ int __high2908__ = __left2893__ + __sizeof2895__;
+ assertvalidmemory(__left2893__, __high2908__);
+ // __left2893__ = d.s
+ // __offsetinbits2909__ <-- (32 + (32 + (32 + 0)))
+ int __leftop2910__ = 32;
+ int __leftop2912__ = 32;
+ int __leftop2914__ = 32;
+ int __rightop2915__ = 0;
+ int __rightop2913__ = __leftop2914__ + __rightop2915__;
+ int __rightop2911__ = __leftop2912__ + __rightop2913__;
+ int __offsetinbits2909__ = __leftop2910__ + __rightop2911__;
+ // __offsetinbits2909__ = (32 + (32 + (32 + 0)))
+ int __offset2916__ = __offsetinbits2909__ >> 3;
+ int __shift2917__ = __offsetinbits2909__ - (__offset2916__ << 3);
+ int __rightop2892__ = ((*(int *)(__left2893__ + __offset2916__)) >> __shift2917__) & 0xffffffff;
+ int __tempvar2863__ = __leftop2864__ < __rightop2892__;
+ if (__tempvar2863__)
+ {
+ // __left2919__ <-- d.s
+ // __left2920__ <-- d
+ int __left2920__ = (int) d; //varexpr
+ // __left2920__ = d
+ int __left2919__ = (__left2920__ + 0);
+ int __leftop2922__ = 32;
+ int __leftop2924__ = 32;
+ int __leftop2926__ = 32;
+ int __leftop2928__ = 32;
+ int __leftop2930__ = 32;
+ int __leftop2932__ = 32;
+ int __rightop2933__ = 0;
+ int __rightop2931__ = __leftop2932__ + __rightop2933__;
+ int __rightop2929__ = __leftop2930__ + __rightop2931__;
+ int __rightop2927__ = __leftop2928__ + __rightop2929__;
+ int __rightop2925__ = __leftop2926__ + __rightop2927__;
+ int __rightop2923__ = __leftop2924__ + __rightop2925__;
+ int __sizeof2921__ = __leftop2922__ + __rightop2923__;
+ int __high2934__ = __left2919__ + __sizeof2921__;
+ assertvalidmemory(__left2919__, __high2934__);
+ // __left2919__ = d.s
+ // __offsetinbits2935__ <-- (32 + (32 + (32 + (32 + 0))))
+ int __leftop2936__ = 32;
+ int __leftop2938__ = 32;
+ int __leftop2940__ = 32;
+ int __leftop2942__ = 32;
+ int __rightop2943__ = 0;
+ int __rightop2941__ = __leftop2942__ + __rightop2943__;
+ int __rightop2939__ = __leftop2940__ + __rightop2941__;
+ int __rightop2937__ = __leftop2938__ + __rightop2939__;
+ int __offsetinbits2935__ = __leftop2936__ + __rightop2937__;
+ // __offsetinbits2935__ = (32 + (32 + (32 + (32 + 0))))
+ int __offset2944__ = __offsetinbits2935__ >> 3;
+ int __shift2945__ = __offsetinbits2935__ - (__offset2944__ << 3);
+ int __element2918__ = ((*(int *)(__left2919__ + __offset2944__)) >> __shift2945__) & 0xffffffff;
+ int __addeditem2946__ = 1;
+ __addeditem2946__ = __Inode___hash->add((int)__element2918__, (int)__element2918__);
+ }
+ }
+
+
+// build rule26
+ {
+ for (SimpleIterator* __i___iterator = __UsedInode___hash->iterator(); __i___iterator->hasNext(); )
+ {
+ int __i__ = (int) __i___iterator->next();
+ for (SimpleIterator* __itb___iterator = __InodeTableBlock___hash->iterator(); __itb___iterator->hasNext(); )
+ {
+ int __itb__ = (int) __itb___iterator->next();
+ int __tempvar2947__ = 0;
+ int __tempvar2948__ = 11;
+ for (int __j__ = __tempvar2947__; __j__ <= __tempvar2948__; __j__++)
+ {
+ //((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] < d.s.NumberofBlocks) && ((cast(__InodeTable__, d.b[itb]).itable[i].Blockptr[j] == 0)))
+ // __left2952__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
+ // __left2953__ <-- cast(__InodeTable__, d.b[itb])
+ // __left2955__ <-- d
+ int __left2955__ = (int) d; //varexpr
+ // __left2955__ = d
+ // __offsetinbits2956__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __leftop2957__ = 0;
+ int __leftop2961__ = 8;
+ // __left2963__ <-- d.s
+ // __left2964__ <-- d
+ int __left2964__ = (int) d; //varexpr
+ // __left2964__ = d
+ int __left2963__ = (__left2964__ + 0);
+ int __leftop2966__ = 32;
+ int __leftop2968__ = 32;
+ int __leftop2970__ = 32;
+ int __leftop2972__ = 32;
+ int __leftop2974__ = 32;
+ int __leftop2976__ = 32;
+ int __rightop2977__ = 0;
+ int __rightop2975__ = __leftop2976__ + __rightop2977__;
+ int __rightop2973__ = __leftop2974__ + __rightop2975__;
+ int __rightop2971__ = __leftop2972__ + __rightop2973__;
+ int __rightop2969__ = __leftop2970__ + __rightop2971__;
+ int __rightop2967__ = __leftop2968__ + __rightop2969__;
+ int __sizeof2965__ = __leftop2966__ + __rightop2967__;
+ int __high2978__ = __left2963__ + __sizeof2965__;
+ assertvalidmemory(__left2963__, __high2978__);
+ // __left2963__ = d.s
+ // __offsetinbits2979__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop2980__ = 32;
+ int __leftop2982__ = 32;
+ int __leftop2984__ = 32;
+ int __leftop2986__ = 32;
+ int __leftop2988__ = 32;
+ int __rightop2989__ = 0;
+ int __rightop2987__ = __leftop2988__ + __rightop2989__;
+ int __rightop2985__ = __leftop2986__ + __rightop2987__;
+ int __rightop2983__ = __leftop2984__ + __rightop2985__;
+ int __rightop2981__ = __leftop2982__ + __rightop2983__;
+ int __offsetinbits2979__ = __leftop2980__ + __rightop2981__;
+ // __offsetinbits2979__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset2990__ = __offsetinbits2979__ >> 3;
+ int __shift2991__ = __offsetinbits2979__ - (__offset2990__ << 3);
+ int __rightop2962__ = ((*(int *)(__left2963__ + __offset2990__)) >> __shift2991__) & 0xffffffff;
+ int __leftop2960__ = __leftop2961__ * __rightop2962__;
+ int __rightop2992__ = 0;
+ int __leftop2959__ = __leftop2960__ + __rightop2992__;
+ int __rightop2993__ = (int) __itb__; //varexpr
+ int __rightop2958__ = __leftop2959__ * __rightop2993__;
+ int __offsetinbits2956__ = __leftop2957__ + __rightop2958__;
+ // __offsetinbits2956__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __offset2994__ = __offsetinbits2956__ >> 3;
+ int __expr2954__ = (__left2955__ + __offset2994__);
+ int __leftop2997__ = 8;
+ // __left2999__ <-- d.s
+ // __left3000__ <-- d
+ int __left3000__ = (int) d; //varexpr
+ // __left3000__ = d
+ int __left2999__ = (__left3000__ + 0);
+ int __leftop3002__ = 32;
+ int __leftop3004__ = 32;
+ int __leftop3006__ = 32;
+ int __leftop3008__ = 32;
+ int __leftop3010__ = 32;
+ int __leftop3012__ = 32;
+ int __rightop3013__ = 0;
+ int __rightop3011__ = __leftop3012__ + __rightop3013__;
+ int __rightop3009__ = __leftop3010__ + __rightop3011__;
+ int __rightop3007__ = __leftop3008__ + __rightop3009__;
+ int __rightop3005__ = __leftop3006__ + __rightop3007__;
+ int __rightop3003__ = __leftop3004__ + __rightop3005__;
+ int __sizeof3001__ = __leftop3002__ + __rightop3003__;
+ int __high3014__ = __left2999__ + __sizeof3001__;
+ assertvalidmemory(__left2999__, __high3014__);
+ // __left2999__ = d.s
+ // __offsetinbits3015__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop3016__ = 32;
+ int __leftop3018__ = 32;
+ int __leftop3020__ = 32;
+ int __leftop3022__ = 32;
+ int __leftop3024__ = 32;
+ int __rightop3025__ = 0;
+ int __rightop3023__ = __leftop3024__ + __rightop3025__;
+ int __rightop3021__ = __leftop3022__ + __rightop3023__;
+ int __rightop3019__ = __leftop3020__ + __rightop3021__;
+ int __rightop3017__ = __leftop3018__ + __rightop3019__;
+ int __offsetinbits3015__ = __leftop3016__ + __rightop3017__;
+ // __offsetinbits3015__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset3026__ = __offsetinbits3015__ >> 3;
+ int __shift3027__ = __offsetinbits3015__ - (__offset3026__ << 3);
+ int __rightop2998__ = ((*(int *)(__left2999__ + __offset3026__)) >> __shift3027__) & 0xffffffff;
+ int __leftop2996__ = __leftop2997__ * __rightop2998__;
+ int __rightop3028__ = 0;
+ int __sizeof2995__ = __leftop2996__ + __rightop3028__;
+ int __high3029__ = __expr2954__ + __sizeof2995__;
+ assertvalidmemory(__expr2954__, __high3029__);
+ int __left2953__ = (int) __expr2954__;
+ // __left2953__ = cast(__InodeTable__, d.b[itb])
+ // __offsetinbits3030__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __leftop3031__ = 0;
+ int __leftop3034__ = 32;
+ int __leftop3037__ = 32;
+ int __rightop3038__ = 12;
+ int __leftop3036__ = __leftop3037__ * __rightop3038__;
+ int __leftop3040__ = 32;
+ int __rightop3041__ = 0;
+ int __rightop3039__ = __leftop3040__ + __rightop3041__;
+ int __rightop3035__ = __leftop3036__ + __rightop3039__;
+ int __leftop3033__ = __leftop3034__ + __rightop3035__;
+ int __rightop3042__ = (int) __i__; //varexpr
+ int __rightop3032__ = __leftop3033__ * __rightop3042__;
+ int __offsetinbits3030__ = __leftop3031__ + __rightop3032__;
+ // __offsetinbits3030__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __offset3043__ = __offsetinbits3030__ >> 3;
+ int __left2952__ = (__left2953__ + __offset3043__);
+ int __leftop3045__ = 32;
+ int __leftop3048__ = 32;
+ int __rightop3049__ = 12;
+ int __leftop3047__ = __leftop3048__ * __rightop3049__;
+ int __leftop3051__ = 32;
+ int __rightop3052__ = 0;
+ int __rightop3050__ = __leftop3051__ + __rightop3052__;
+ int __rightop3046__ = __leftop3047__ + __rightop3050__;
+ int __sizeof3044__ = __leftop3045__ + __rightop3046__;
+ int __high3053__ = __left2952__ + __sizeof3044__;
+ assertvalidmemory(__left2952__, __high3053__);
+ // __left2952__ = cast(__InodeTable__, d.b[itb]).itable[i]
+ // __offsetinbits3054__ <-- ((32 + 0) + (32 * j))
+ int __leftop3056__ = 32;
+ int __rightop3057__ = 0;
+ int __leftop3055__ = __leftop3056__ + __rightop3057__;
+ int __leftop3059__ = 32;
+ int __rightop3060__ = (int) __j__; //varexpr
+ int __rightop3058__ = __leftop3059__ * __rightop3060__;
+ int __offsetinbits3054__ = __leftop3055__ + __rightop3058__;
+ // __offsetinbits3054__ = ((32 + 0) + (32 * j))
+ int __offset3061__ = __offsetinbits3054__ >> 3;
+ int __shift3062__ = __offsetinbits3054__ - (__offset3061__ << 3);
+ int __leftop2951__ = ((*(int *)(__left2952__ + __offset3061__)) >> __shift3062__) & 0xffffffff;
+ // __left3064__ <-- d.s
+ // __left3065__ <-- d
+ int __left3065__ = (int) d; //varexpr
+ // __left3065__ = d
+ int __left3064__ = (__left3065__ + 0);
+ int __leftop3067__ = 32;
+ int __leftop3069__ = 32;
+ int __leftop3071__ = 32;
+ int __leftop3073__ = 32;
+ int __leftop3075__ = 32;
+ int __leftop3077__ = 32;
+ int __rightop3078__ = 0;
+ int __rightop3076__ = __leftop3077__ + __rightop3078__;
+ int __rightop3074__ = __leftop3075__ + __rightop3076__;
+ int __rightop3072__ = __leftop3073__ + __rightop3074__;
+ int __rightop3070__ = __leftop3071__ + __rightop3072__;
+ int __rightop3068__ = __leftop3069__ + __rightop3070__;
+ int __sizeof3066__ = __leftop3067__ + __rightop3068__;
+ int __high3079__ = __left3064__ + __sizeof3066__;
+ assertvalidmemory(__left3064__, __high3079__);
+ // __left3064__ = d.s
+ // __offsetinbits3080__ <-- (32 + (32 + 0))
+ int __leftop3081__ = 32;
+ int __leftop3083__ = 32;
+ int __rightop3084__ = 0;
+ int __rightop3082__ = __leftop3083__ + __rightop3084__;
+ int __offsetinbits3080__ = __leftop3081__ + __rightop3082__;
+ // __offsetinbits3080__ = (32 + (32 + 0))
+ int __offset3085__ = __offsetinbits3080__ >> 3;
+ int __shift3086__ = __offsetinbits3080__ - (__offset3085__ << 3);
+ int __rightop3063__ = ((*(int *)(__left3064__ + __offset3085__)) >> __shift3086__) & 0xffffffff;
+ int __leftop2950__ = __leftop2951__ < __rightop3063__;
+ // __left3090__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
+ // __left3091__ <-- cast(__InodeTable__, d.b[itb])
+ // __left3093__ <-- d
+ int __left3093__ = (int) d; //varexpr
+ // __left3093__ = d
+ // __offsetinbits3094__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __leftop3095__ = 0;
+ int __leftop3099__ = 8;
+ // __left3101__ <-- d.s
+ // __left3102__ <-- d
+ int __left3102__ = (int) d; //varexpr
+ // __left3102__ = d
+ int __left3101__ = (__left3102__ + 0);
+ int __leftop3104__ = 32;
+ int __leftop3106__ = 32;
+ int __leftop3108__ = 32;
+ int __leftop3110__ = 32;
+ int __leftop3112__ = 32;
+ int __leftop3114__ = 32;
+ int __rightop3115__ = 0;
+ int __rightop3113__ = __leftop3114__ + __rightop3115__;
+ int __rightop3111__ = __leftop3112__ + __rightop3113__;
+ int __rightop3109__ = __leftop3110__ + __rightop3111__;
+ int __rightop3107__ = __leftop3108__ + __rightop3109__;
+ int __rightop3105__ = __leftop3106__ + __rightop3107__;
+ int __sizeof3103__ = __leftop3104__ + __rightop3105__;
+ int __high3116__ = __left3101__ + __sizeof3103__;
+ assertvalidmemory(__left3101__, __high3116__);
+ // __left3101__ = d.s
+ // __offsetinbits3117__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop3118__ = 32;
+ int __leftop3120__ = 32;
+ int __leftop3122__ = 32;
+ int __leftop3124__ = 32;
+ int __leftop3126__ = 32;
+ int __rightop3127__ = 0;
+ int __rightop3125__ = __leftop3126__ + __rightop3127__;
+ int __rightop3123__ = __leftop3124__ + __rightop3125__;
+ int __rightop3121__ = __leftop3122__ + __rightop3123__;
+ int __rightop3119__ = __leftop3120__ + __rightop3121__;
+ int __offsetinbits3117__ = __leftop3118__ + __rightop3119__;
+ // __offsetinbits3117__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset3128__ = __offsetinbits3117__ >> 3;
+ int __shift3129__ = __offsetinbits3117__ - (__offset3128__ << 3);
+ int __rightop3100__ = ((*(int *)(__left3101__ + __offset3128__)) >> __shift3129__) & 0xffffffff;
+ int __leftop3098__ = __leftop3099__ * __rightop3100__;
+ int __rightop3130__ = 0;
+ int __leftop3097__ = __leftop3098__ + __rightop3130__;
+ int __rightop3131__ = (int) __itb__; //varexpr
+ int __rightop3096__ = __leftop3097__ * __rightop3131__;
+ int __offsetinbits3094__ = __leftop3095__ + __rightop3096__;
+ // __offsetinbits3094__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __offset3132__ = __offsetinbits3094__ >> 3;
+ int __expr3092__ = (__left3093__ + __offset3132__);
+ int __leftop3135__ = 8;
+ // __left3137__ <-- d.s
+ // __left3138__ <-- d
+ int __left3138__ = (int) d; //varexpr
+ // __left3138__ = d
+ int __left3137__ = (__left3138__ + 0);
+ int __leftop3140__ = 32;
+ int __leftop3142__ = 32;
+ int __leftop3144__ = 32;
+ int __leftop3146__ = 32;
+ int __leftop3148__ = 32;
+ int __leftop3150__ = 32;
+ int __rightop3151__ = 0;
+ int __rightop3149__ = __leftop3150__ + __rightop3151__;
+ int __rightop3147__ = __leftop3148__ + __rightop3149__;
+ int __rightop3145__ = __leftop3146__ + __rightop3147__;
+ int __rightop3143__ = __leftop3144__ + __rightop3145__;
+ int __rightop3141__ = __leftop3142__ + __rightop3143__;
+ int __sizeof3139__ = __leftop3140__ + __rightop3141__;
+ int __high3152__ = __left3137__ + __sizeof3139__;
+ assertvalidmemory(__left3137__, __high3152__);
+ // __left3137__ = d.s
+ // __offsetinbits3153__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop3154__ = 32;
+ int __leftop3156__ = 32;
+ int __leftop3158__ = 32;
+ int __leftop3160__ = 32;
+ int __leftop3162__ = 32;
+ int __rightop3163__ = 0;
+ int __rightop3161__ = __leftop3162__ + __rightop3163__;
+ int __rightop3159__ = __leftop3160__ + __rightop3161__;
+ int __rightop3157__ = __leftop3158__ + __rightop3159__;
+ int __rightop3155__ = __leftop3156__ + __rightop3157__;
+ int __offsetinbits3153__ = __leftop3154__ + __rightop3155__;
+ // __offsetinbits3153__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset3164__ = __offsetinbits3153__ >> 3;
+ int __shift3165__ = __offsetinbits3153__ - (__offset3164__ << 3);
+ int __rightop3136__ = ((*(int *)(__left3137__ + __offset3164__)) >> __shift3165__) & 0xffffffff;
+ int __leftop3134__ = __leftop3135__ * __rightop3136__;
+ int __rightop3166__ = 0;
+ int __sizeof3133__ = __leftop3134__ + __rightop3166__;
+ int __high3167__ = __expr3092__ + __sizeof3133__;
+ assertvalidmemory(__expr3092__, __high3167__);
+ int __left3091__ = (int) __expr3092__;
+ // __left3091__ = cast(__InodeTable__, d.b[itb])
+ // __offsetinbits3168__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __leftop3169__ = 0;
+ int __leftop3172__ = 32;
+ int __leftop3175__ = 32;
+ int __rightop3176__ = 12;
+ int __leftop3174__ = __leftop3175__ * __rightop3176__;
+ int __leftop3178__ = 32;
+ int __rightop3179__ = 0;
+ int __rightop3177__ = __leftop3178__ + __rightop3179__;
+ int __rightop3173__ = __leftop3174__ + __rightop3177__;
+ int __leftop3171__ = __leftop3172__ + __rightop3173__;
+ int __rightop3180__ = (int) __i__; //varexpr
+ int __rightop3170__ = __leftop3171__ * __rightop3180__;
+ int __offsetinbits3168__ = __leftop3169__ + __rightop3170__;
+ // __offsetinbits3168__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __offset3181__ = __offsetinbits3168__ >> 3;
+ int __left3090__ = (__left3091__ + __offset3181__);
+ int __leftop3183__ = 32;
+ int __leftop3186__ = 32;
+ int __rightop3187__ = 12;
+ int __leftop3185__ = __leftop3186__ * __rightop3187__;
+ int __leftop3189__ = 32;
+ int __rightop3190__ = 0;
+ int __rightop3188__ = __leftop3189__ + __rightop3190__;
+ int __rightop3184__ = __leftop3185__ + __rightop3188__;
+ int __sizeof3182__ = __leftop3183__ + __rightop3184__;
+ int __high3191__ = __left3090__ + __sizeof3182__;
+ assertvalidmemory(__left3090__, __high3191__);
+ // __left3090__ = cast(__InodeTable__, d.b[itb]).itable[i]
+ // __offsetinbits3192__ <-- ((32 + 0) + (32 * j))
+ int __leftop3194__ = 32;
+ int __rightop3195__ = 0;
+ int __leftop3193__ = __leftop3194__ + __rightop3195__;
+ int __leftop3197__ = 32;
+ int __rightop3198__ = (int) __j__; //varexpr
+ int __rightop3196__ = __leftop3197__ * __rightop3198__;
+ int __offsetinbits3192__ = __leftop3193__ + __rightop3196__;
+ // __offsetinbits3192__ = ((32 + 0) + (32 * j))
+ int __offset3199__ = __offsetinbits3192__ >> 3;
+ int __shift3200__ = __offsetinbits3192__ - (__offset3199__ << 3);
+ int __leftop3089__ = ((*(int *)(__left3090__ + __offset3199__)) >> __shift3200__) & 0xffffffff;
+ int __rightop3201__ = 0;
+ int __leftop3088__ = __leftop3089__ == __rightop3201__;
+ int __rightop3087__ = !__leftop3088__;
+ int __tempvar2949__ = __leftop2950__ && __rightop3087__;
+ if (__tempvar2949__)
+ {
+ // __left3203__ <-- cast(__InodeTable__, d.b[itb]).itable[i]
+ // __left3204__ <-- cast(__InodeTable__, d.b[itb])
+ // __left3206__ <-- d
+ int __left3206__ = (int) d; //varexpr
+ // __left3206__ = d
+ // __offsetinbits3207__ <-- (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __leftop3208__ = 0;
+ int __leftop3212__ = 8;
+ // __left3214__ <-- d.s
+ // __left3215__ <-- d
+ int __left3215__ = (int) d; //varexpr
+ // __left3215__ = d
+ int __left3214__ = (__left3215__ + 0);
+ int __leftop3217__ = 32;
+ int __leftop3219__ = 32;
+ int __leftop3221__ = 32;
+ int __leftop3223__ = 32;
+ int __leftop3225__ = 32;
+ int __leftop3227__ = 32;
+ int __rightop3228__ = 0;
+ int __rightop3226__ = __leftop3227__ + __rightop3228__;
+ int __rightop3224__ = __leftop3225__ + __rightop3226__;
+ int __rightop3222__ = __leftop3223__ + __rightop3224__;
+ int __rightop3220__ = __leftop3221__ + __rightop3222__;
+ int __rightop3218__ = __leftop3219__ + __rightop3220__;
+ int __sizeof3216__ = __leftop3217__ + __rightop3218__;
+ int __high3229__ = __left3214__ + __sizeof3216__;
+ assertvalidmemory(__left3214__, __high3229__);
+ // __left3214__ = d.s
+ // __offsetinbits3230__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop3231__ = 32;
+ int __leftop3233__ = 32;
+ int __leftop3235__ = 32;
+ int __leftop3237__ = 32;
+ int __leftop3239__ = 32;
+ int __rightop3240__ = 0;
+ int __rightop3238__ = __leftop3239__ + __rightop3240__;
+ int __rightop3236__ = __leftop3237__ + __rightop3238__;
+ int __rightop3234__ = __leftop3235__ + __rightop3236__;
+ int __rightop3232__ = __leftop3233__ + __rightop3234__;
+ int __offsetinbits3230__ = __leftop3231__ + __rightop3232__;
+ // __offsetinbits3230__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset3241__ = __offsetinbits3230__ >> 3;
+ int __shift3242__ = __offsetinbits3230__ - (__offset3241__ << 3);
+ int __rightop3213__ = ((*(int *)(__left3214__ + __offset3241__)) >> __shift3242__) & 0xffffffff;
+ int __leftop3211__ = __leftop3212__ * __rightop3213__;
+ int __rightop3243__ = 0;
+ int __leftop3210__ = __leftop3211__ + __rightop3243__;
+ int __rightop3244__ = (int) __itb__; //varexpr
+ int __rightop3209__ = __leftop3210__ * __rightop3244__;
+ int __offsetinbits3207__ = __leftop3208__ + __rightop3209__;
+ // __offsetinbits3207__ = (0 + (((8 * d.s.blocksize) + 0) * itb))
+ int __offset3245__ = __offsetinbits3207__ >> 3;
+ int __expr3205__ = (__left3206__ + __offset3245__);
+ int __leftop3248__ = 8;
+ // __left3250__ <-- d.s
+ // __left3251__ <-- d
+ int __left3251__ = (int) d; //varexpr
+ // __left3251__ = d
+ int __left3250__ = (__left3251__ + 0);
+ int __leftop3253__ = 32;
+ int __leftop3255__ = 32;
+ int __leftop3257__ = 32;
+ int __leftop3259__ = 32;
+ int __leftop3261__ = 32;
+ int __leftop3263__ = 32;
+ int __rightop3264__ = 0;
+ int __rightop3262__ = __leftop3263__ + __rightop3264__;
+ int __rightop3260__ = __leftop3261__ + __rightop3262__;
+ int __rightop3258__ = __leftop3259__ + __rightop3260__;
+ int __rightop3256__ = __leftop3257__ + __rightop3258__;
+ int __rightop3254__ = __leftop3255__ + __rightop3256__;
+ int __sizeof3252__ = __leftop3253__ + __rightop3254__;
+ int __high3265__ = __left3250__ + __sizeof3252__;
+ assertvalidmemory(__left3250__, __high3265__);
+ // __left3250__ = d.s
+ // __offsetinbits3266__ <-- (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __leftop3267__ = 32;
+ int __leftop3269__ = 32;
+ int __leftop3271__ = 32;
+ int __leftop3273__ = 32;
+ int __leftop3275__ = 32;
+ int __rightop3276__ = 0;
+ int __rightop3274__ = __leftop3275__ + __rightop3276__;
+ int __rightop3272__ = __leftop3273__ + __rightop3274__;
+ int __rightop3270__ = __leftop3271__ + __rightop3272__;
+ int __rightop3268__ = __leftop3269__ + __rightop3270__;
+ int __offsetinbits3266__ = __leftop3267__ + __rightop3268__;
+ // __offsetinbits3266__ = (32 + (32 + (32 + (32 + (32 + 0)))))
+ int __offset3277__ = __offsetinbits3266__ >> 3;
+ int __shift3278__ = __offsetinbits3266__ - (__offset3277__ << 3);
+ int __rightop3249__ = ((*(int *)(__left3250__ + __offset3277__)) >> __shift3278__) & 0xffffffff;
+ int __leftop3247__ = __leftop3248__ * __rightop3249__;
+ int __rightop3279__ = 0;
+ int __sizeof3246__ = __leftop3247__ + __rightop3279__;
+ int __high3280__ = __expr3205__ + __sizeof3246__;
+ assertvalidmemory(__expr3205__, __high3280__);
+ int __left3204__ = (int) __expr3205__;
+ // __left3204__ = cast(__InodeTable__, d.b[itb])
+ // __offsetinbits3281__ <-- (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __leftop3282__ = 0;
+ int __leftop3285__ = 32;
+ int __leftop3288__ = 32;
+ int __rightop3289__ = 12;
+ int __leftop3287__ = __leftop3288__ * __rightop3289__;
+ int __leftop3291__ = 32;
+ int __rightop3292__ = 0;
+ int __rightop3290__ = __leftop3291__ + __rightop3292__;
+ int __rightop3286__ = __leftop3287__ + __rightop3290__;
+ int __leftop3284__ = __leftop3285__ + __rightop3286__;
+ int __rightop3293__ = (int) __i__; //varexpr
+ int __rightop3283__ = __leftop3284__ * __rightop3293__;
+ int __offsetinbits3281__ = __leftop3282__ + __rightop3283__;
+ // __offsetinbits3281__ = (0 + ((32 + ((32 * 12) + (32 + 0))) * i))
+ int __offset3294__ = __offsetinbits3281__ >> 3;
+ int __left3203__ = (__left3204__ + __offset3294__);
+ int __leftop3296__ = 32;
+ int __leftop3299__ = 32;
+ int __rightop3300__ = 12;
+ int __leftop3298__ = __leftop3299__ * __rightop3300__;
+ int __leftop3302__ = 32;
+ int __rightop3303__ = 0;
+ int __rightop3301__ = __leftop3302__ + __rightop3303__;
+ int __rightop3297__ = __leftop3298__ + __rightop3301__;
+ int __sizeof3295__ = __leftop3296__ + __rightop3297__;
+ int __high3304__ = __left3203__ + __sizeof3295__;
+ assertvalidmemory(__left3203__, __high3304__);
+ // __left3203__ = cast(__InodeTable__, d.b[itb]).itable[i]
+ // __offsetinbits3305__ <-- ((32 + 0) + (32 * j))
+ int __leftop3307__ = 32;
+ int __rightop3308__ = 0;
+ int __leftop3306__ = __leftop3307__ + __rightop3308__;
+ int __leftop3310__ = 32;
+ int __rightop3311__ = (int) __j__; //varexpr
+ int __rightop3309__ = __leftop3310__ * __rightop3311__;
+ int __offsetinbits3305__ = __leftop3306__ + __rightop3309__;
+ // __offsetinbits3305__ = ((32 + 0) + (32 * j))
+ int __offset3312__ = __offsetinbits3305__ >> 3;
+ int __shift3313__ = __offsetinbits3305__ - (__offset3312__ << 3);
+ int __element3202__ = ((*(int *)(__left3203__ + __offset3312__)) >> __shift3313__) & 0xffffffff;
+ int __addeditem3314__ = 1;
+ __addeditem3314__ = __Block___hash->add((int)__element3202__, (int)__element3202__);
+ }