picoc/tests/csmith/rand84.c

#include <stdio.h>
int print_hash_value = 1;
static void platform_main_begin(void)
{
}
static unsigned crc32_tab[256];
static unsigned crc32_context = 0xFFFFFFFFUL;
static void
crc32_gentab (void)
{
 unsigned crc;
 unsigned poly = 0xEDB88320UL;
 int i, j;
 for (i = 0; i < 256; i++) {
  crc = i;
  for (j = 8; j > 0; j--) {
   if (crc & 1) {
    crc = (crc >> 1) ^ poly;
   } else {
    crc >>= 1;
   }
  }
  crc32_tab[i] = crc;
 }
}
static void
crc32_byte (unsigned char b) {
 crc32_context =
  ((crc32_context >> 8) & 0x00FFFFFF) ^
  crc32_tab[(crc32_context ^ b) & 0xFF];
}
extern int strcmp ( char *, char *);
static void
crc32_8bytes (unsigned val)
{
 crc32_byte ((val>>0) & 0xff);
 crc32_byte ((val>>8) & 0xff);
 crc32_byte ((val>>16) & 0xff);
 crc32_byte ((val>>24) & 0xff);
}
static void
transparent_crc (unsigned val, char* vname, int flag)
{
 crc32_8bytes(val);
 if (flag) {
    printf("...checksum after hashing %s : %X\n", vname, crc32_context ^ 0xFFFFFFFFU);
 }
}
static void
platform_main_end (int x, int flag)
{
  if (!flag) printf ("checksum = %x\n", x);
}
static long __undefined;
void csmith_compute_hash(void);
void step_hash(int stmt_id);
static signed char g_2[5] = {0x17L, 0x17L, 0x17L, 0x17L, 0x17L};
static int g_3 = 0x3245F1DBL;
static int g_26 = 0xD6A56C37L;
static int *g_25 = &g_26;
static unsigned short g_140 = 0xF30DL;
static int g_154 = 0x5DDDEB7DL;
static signed char g_184[9] = {0xB7L, 0xB7L, 1L, 0xB7L, 0xB7L, 1L, 0xB7L, 0xB7L, 1L};
static int ***g_193 = (void*)0;
static unsigned g_199 = 0UL;
static signed char g_210 = (-1L);
static unsigned char g_211 = 0x1BL;
static short g_225 = (-2L);
static short g_226 = (-1L);
static short g_228 = 0x4E76L;
static short g_230 = 0L;
static int g_232 = 0xB7EFDFD4L;
static signed char g_244 = 0x85L;
static unsigned g_249 = 0x41AC932FL;
static int *g_292 = &g_26;
static unsigned char g_328 = 0xA2L;
static short g_337[8][4] = {{(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}, {(-6L), (-6L), 0x03CDL, (-6L)}};
static short g_338[7] = {0L, 0L, 0xCEE1L, 0L, 0L, 0xCEE1L, 0L};
static short g_339 = 0x824DL;
static unsigned char g_340[2] = {251UL, 251UL};
static unsigned g_355 = 0x7B961AA7L;
static int g_396[9][6] = {{9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}, {9L, (-1L), 9L, 1L, (-1L), 1L}};
static unsigned char g_397 = 1UL;
static signed char g_422 = 0L;
static unsigned char g_423[9][1] = {{0UL}, {0UL}, {0UL}, {0UL}, {0UL}, {0UL}, {0UL}, {0UL}, {0UL}};
static unsigned short g_429 = 6UL;
static unsigned short g_444 = 0x2E8AL;
static unsigned short g_503 = 1UL;
static int g_524 = 0x61CFE555L;
static unsigned short g_534 = 0xFC48L;
static int g_543 = 0x3DDEC6CEL;
static unsigned g_545 = 0UL;
static unsigned g_548 = 5UL;
static unsigned g_577 = 0x4205539CL;
static int g_594[3][10] = {{6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL}, {6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL}, {6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL, 6L, 0xBEB9D53DL}};
static unsigned g_595 = 0x3237DB2EL;
static unsigned short g_883[9][1] = {{0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}, {0x9A7EL}};
static int g_1024[8] = {0x913B9430L, 0x913B9430L, 0x913B9430L, 0x913B9430L, 0x913B9430L, 0x913B9430L, 0x913B9430L, 0x913B9430L};
static signed char g_1083 = (-1L);
static unsigned short g_1196 = 65535UL;
static int *g_1357 = &g_232;
static int *g_1434 = &g_154;
static int g_1451 = 2L;
static unsigned char g_1531 = 0x61L;
static unsigned g_1534 = 0x6B1B78B5L;
static int g_1538 = (-1L);
static signed char g_1543 = 1L;
static int g_1584 = 0xE0C975B9L;
static int g_1649 = 0x953350D8L;
static unsigned g_1695 = 4294967295UL;
static unsigned short func_1(void);
static signed char func_6(unsigned short p_7, int p_8, int p_9, signed char p_10);
static unsigned short func_20(unsigned short p_21);
static int * func_27(int ** p_28, int ** p_29);
static int ** func_30(unsigned short p_31, int * p_32, unsigned p_33, unsigned char p_34);
static int func_39(unsigned p_40, int * p_41);
static int * func_42(unsigned p_43, unsigned char p_44);
static short func_51(unsigned p_52, short p_53, int p_54, int p_55, int ** p_56);
static short func_57(int p_58, unsigned p_59, int * p_60, short p_61, int p_62);
static int func_67(unsigned p_68, int * p_69, int ** p_70, unsigned char p_71);
static unsigned short func_1(void)
{
    short l_22 = 0x41A6L;
    int *l_1615 = &g_154;
    unsigned short l_1618 = 9UL;
    int l_1623 = 0x1F760722L;
    int l_1624 = 1L;
    int l_1625 = 0xD1AB473CL;
    int l_1628 = 3L;
    int l_1634 = (-9L);
    short l_1700[2];
    int l_1709 = (-1L);
    unsigned l_1714 = 0xFA50C062L;
    signed char l_1721 = 0x45L;
    int i;
    for (i = 0; i < 2; i++)
        l_1700[i] = 0xA852L;
    step_hash(1031);
    if (g_2[3])
    {
        step_hash(2);
        return g_2[2];
    }
    else
    {
        short l_19[3];
        int **l_1597 = &g_1434;
        int l_1611 = 0L;
        int l_1622 = 0x8F1291B4L;
        int l_1626 = 0x007BDE43L;
        int l_1632 = 0xB7560AB5L;
        int l_1633[9] = {(-1L), 1L, (-1L), 1L, (-1L), 1L, (-1L), 1L, (-1L)};
        unsigned l_1688 = 0xE7966B75L;
        unsigned l_1710 = 6UL;
        int i;
        for (i = 0; i < 3; i++)
            l_19[i] = 0xE912L;
        step_hash(979);
        for (g_3 = 4; (g_3 >= 0); g_3 -= 1)
        {
            unsigned l_1570 = 0xC1E8DC0DL;
            unsigned l_1571[1][5] = {{0xE55C3634L, 1UL, 0xE55C3634L, 1UL, 0xE55C3634L}};
            int **l_1596 = &g_25;
            int ***l_1595 = &l_1596;
            short l_1610 = 1L;
            int l_1630 = 0x51AA23C9L;
            int l_1631 = (-4L);
            int l_1656 = (-5L);
            int *l_1660 = &l_1622;
            int *l_1661 = &l_1656;
            int *l_1662 = &l_1630;
            int *l_1663 = &l_1633[3];
            int *l_1664[5][2] = {{&l_1625, &g_3}, {&l_1625, &g_3}, {&l_1625, &g_3}, {&l_1625, &g_3}, {&l_1625, &g_3}};
            unsigned l_1665 = 6UL;
            int i, j;
        }
        step_hash(1029);
        for (g_444 = 0; (g_444 <= 8); g_444 += 1)
        {
            unsigned short l_1672[4][10] = {{65532UL, 0x747CL, 65535UL, 0UL, 0xCD56L, 65531UL, 0xCD56L, 0UL, 65535UL, 0x747CL}, {65532UL, 0x747CL, 65535UL, 0UL, 0xCD56L, 65531UL, 0xCD56L, 0UL, 65535UL, 0x747CL}, {65532UL, 0x747CL, 65535UL, 0UL, 0xCD56L, 65531UL, 0xCD56L, 0UL, 65535UL, 0x747CL}, {65532UL, 0x747CL, 65535UL, 0UL, 0xCD56L, 65531UL, 0xCD56L, 0UL, 65535UL, 0x747CL}};
            int l_1687 = 3L;
            int l_1691[6][3] = {{0x67150A1DL, (-1L), 0x67150A1DL}, {0x67150A1DL, (-1L), 0x67150A1DL}, {0x67150A1DL, (-1L), 0x67150A1DL}, {0x67150A1DL, (-1L), 0x67150A1DL}, {0x67150A1DL, (-1L), 0x67150A1DL}, {0x67150A1DL, (-1L), 0x67150A1DL}};
            int i, j;
            step_hash(1016);
            for (l_1622 = 0; (l_1622 <= 0); l_1622 += 1)
            {
                int i, j;
            }
            step_hash(1021);
            for (g_140 = 0; (g_140 <= 0); g_140 += 1)
            {
                step_hash(1020);
                (*g_1357) = (g_534 ^ g_230);
            }
            step_hash(1022);
            (*g_25) = (g_1695 < ((short)g_1531 << (short)(!((g_193 == (void*)0) & (**l_1597)))));
            step_hash(1023);
            (*g_292) |= (!0x44EA343CL);
            step_hash(1028);
            for (g_232 = 0; (g_232 >= 0); g_232 -= 1)
            {
                signed char l_1711 = 9L;
                step_hash(1027);
                (**l_1597) &= ((unsigned short)l_1700[0] << (unsigned short)((!l_1691[4][0]) && l_1672[0][8]));
            }
        }
        step_hash(1030);
        l_1624 |= func_51(((((signed char)func_67((&l_1625 == &g_154), (*l_1597), l_1597, ((g_1024[5] ^ (g_340[1] < g_2[0])) > ((void*)0 != &l_1634))) * (signed char)g_1534) && l_1714) != (*l_1615)), (**l_1597), (*g_1357), g_337[3][0], l_1597);
    }
    step_hash(1041);
    for (g_595 = 0; (g_595 < 7); ++g_595)
    {
        signed char l_1723 = (-1L);
        int l_1724 = 1L;
        step_hash(1039);
        for (l_1624 = (-10); (l_1624 == (-9)); l_1624++)
        {
            int *l_1719 = &l_1628;
            int l_1720 = 0x982DA191L;
            int *l_1722[2];
            unsigned short l_1725 = 5UL;
            int i;
            for (i = 0; i < 2; i++)
                l_1722[i] = (void*)0;
            step_hash(1038);
            l_1725++;
        }
        step_hash(1040);
        return (*l_1615);
    }
    step_hash(1042);
    return (*l_1615);
}
static signed char func_6(unsigned short p_7, int p_8, int p_9, signed char p_10)
{
    int *l_1572 = &g_154;
    int *l_1573 = (void*)0;
    int *l_1574 = &g_26;
    int *l_1575 = &g_232;
    int *l_1576 = &g_232;
    int *l_1577 = (void*)0;
    int *l_1578 = &g_26;
    int l_1579 = 0x0242E28EL;
    int *l_1580 = &g_232;
    int *l_1581 = (void*)0;
    int *l_1582 = &g_232;
    int *l_1583[1][5] = {{&g_26, &g_1451, &g_26, &g_1451, &g_26}};
    unsigned short l_1585 = 1UL;
    int **l_1588 = &l_1582;
    int i, j;
    step_hash(937);
    l_1585--;
    step_hash(938);
    (*l_1588) = &p_8;
    step_hash(939);
    return g_184[7];
}
static unsigned short func_20(unsigned short p_21)
{
    int *l_23 = &g_3;
    int **l_24[9][7] = {{&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}, {&l_23, &l_23, &l_23, &l_23, &l_23, &l_23, &l_23}};
    signed char l_91 = (-8L);
    int l_549[1][4];
    int l_550 = 0x0EA5A63EL;
    unsigned l_1025 = 0x8EFCA73AL;
    unsigned short l_1026 = 65530UL;
    int *l_1526[7];
    int *l_1528 = (void*)0;
    int i, j;
    for (i = 0; i < 1; i++)
    {
        for (j = 0; j < 4; j++)
            l_549[i][j] = (-6L);
    }
    for (i = 0; i < 7; i++)
        l_1526[i] = (void*)0;
    step_hash(8);
    g_25 = l_23;
    step_hash(901);
    l_1526[2] = func_27(&l_23, func_30((*l_23), &g_26, ((int)(((short)(func_39(p_21, func_42(((int)(((short)((signed char)((func_51((*l_23), func_57((((unsigned short)((void*)0 == &g_3) >> (unsigned short)11) < ((((unsigned char)(0x4E023024L && func_67(p_21, &g_3, &g_25, g_2[3])) >> (unsigned char)4) <= (*l_23)) >= g_2[3])), l_91, &g_3, (*l_23), (*g_25)), p_21, g_338[2], &l_23) >= g_548) | l_549[0][0]) + (signed char)p_21) % (short)0xB658L) && 0x8FL) / (int)p_21), l_550)) <= p_21) << (short)8) > l_1025) / (int)g_184[6]), l_1026));
    step_hash(934);
    for (g_226 = 1; (g_226 <= 5); g_226 += 1)
    {
        int *l_1527[6][1];
        int l_1529 = (-2L);
        int l_1530 = 0x6FC280A2L;
        int ***l_1563 = &l_24[3][0];
        int i, j;
        for (i = 0; i < 6; i++)
        {
            for (j = 0; j < 1; j++)
                l_1527[i][j] = &g_26;
        }
        step_hash(905);
        g_292 = l_1527[4][0];
        step_hash(906);
        l_1528 = func_42(g_595, p_21);
        step_hash(907);
        --g_1531;
        step_hash(908);
        g_1534 ^= 0xD39955C9L;
        step_hash(933);
        for (g_444 = 0; (g_444 <= 0); g_444 += 1)
        {
            int *l_1548 = &g_594[0][9];
            int i, j;
            step_hash(929);
            if (g_396[(g_444 + 6)][(g_444 + 3)])
            {
                int i, j;
                step_hash(913);
                return g_396[(g_444 + 4)][g_226];
            }
            else
            {
                int **l_1549 = &l_1526[2];
                step_hash(928);
                if (func_39((((~0UL) != 0x4BL) < (-(short)(~((((signed char)g_1538 % (signed char)0xF4L) & (g_1024[1] != (0x07A3L == ((unsigned char)p_21 << (unsigned char)5)))) <= (p_21 > g_423[3][0]))))), &l_1529))
                {
                    unsigned l_1550 = 4294967295UL;
                    int l_1551 = 0xEFFFD444L;
                    int **l_1560 = &l_23;
                    step_hash(916);
                    if ((*g_292))
                        break;
                    step_hash(917);
                    l_1551 &= (((unsigned)(g_1543 || 0x4957L) % (unsigned)g_232) <= ((unsigned char)255UL / (unsigned char)((unsigned char)p_21 / (unsigned char)p_21)));
                    step_hash(918);
                    (*l_1548) = p_21;
                    step_hash(925);
                    if (((*g_1357) >= p_21))
                    {
                        step_hash(920);
                        (*l_1549) = &g_26;
                        step_hash(921);
                        (*g_292) = (l_1548 == l_1548);
                    }
                    else
                    {
                        step_hash(923);
                        (*l_1560) = (*l_1560);
                        step_hash(924);
                        if (p_21)
                            continue;
                    }
                }
                else
                {
                    step_hash(927);
                    (*l_1548) &= ((signed char)0x19L - (signed char)(&l_23 != (void*)0));
                }
            }
            step_hash(930);
            (*l_1548) = (l_1548 == (void*)0);
            step_hash(931);
            (*l_1548) &= (p_21 != (g_1024[3] > ((void*)0 != l_1563)));
            step_hash(932);
            l_1548 = &g_26;
        }
    }
    step_hash(935);
    return p_21;
}
static int * func_27(int ** p_28, int ** p_29)
{
    unsigned l_1436 = 0x3432664CL;
    int *l_1471[5];
    unsigned l_1485 = 0x6742CDC3L;
    int i;
    for (i = 0; i < 5; i++)
        l_1471[i] = &g_26;
    step_hash(824);
    l_1436++;
    step_hash(899);
    if (l_1436)
    {
        int *l_1439 = &g_3;
        step_hash(849);
        for (g_328 = 0; (g_328 <= 0); g_328 += 1)
        {
            unsigned l_1443 = 2UL;
            int **l_1455 = &g_292;
            step_hash(829);
            g_1357 = l_1439;
            step_hash(848);
            for (g_1083 = 1; (g_1083 >= 0); g_1083 -= 1)
            {
                int l_1444 = 1L;
                int ***l_1477 = &l_1455;
                step_hash(847);
                for (g_339 = 0; (g_339 >= 0); g_339 -= 1)
                {
                    unsigned l_1452 = 1UL;
                    int **l_1472 = &l_1439;
                    int i;
                    step_hash(843);
                    if (g_340[g_339])
                    {
                        int *l_1440 = &g_154;
                        int i;
                        step_hash(837);
                        l_1440 = func_42(g_340[g_1083], g_1196);
                        step_hash(838);
                        l_1452 = (g_444 | (((!((unsigned short)l_1443 / (unsigned short)0xEEEBL)) & (*l_1440)) ^ (*l_1439)));
                        step_hash(839);
                        (*l_1440) |= (g_184[7] == ((short)((+((((void*)0 != p_28) > l_1444) || (*g_1357))) >= g_244) / (short)0xACF4L));
                    }
                    else
                    {
                        int *l_1458 = &g_594[2][3];
                        step_hash(841);
                        (*l_1458) = (((unsigned char)0UL + (unsigned char)g_883[5][0]) & 0x59EBL);
                        step_hash(842);
                        (*p_28) = func_42(g_3, l_1444);
                    }
                    step_hash(844);
                    if ((*g_1357))
                        break;
                    step_hash(845);
                    g_594[2][5] ^= ((signed char)((unsigned short)g_340[1] + (unsigned short)((unsigned short)((unsigned char)((signed char)(((unsigned char)l_1436 % (unsigned char)l_1444) == (**l_1472)) % (signed char)((p_28 == p_28) ^ 5UL)) >> (unsigned char)(*l_1439)) / (unsigned short)(*l_1439))) * (signed char)g_423[5][0]);
                    step_hash(846);
                    g_154 = ((unsigned char)(**l_1472) - (unsigned char)(((unsigned)(&p_29 != l_1477) - (unsigned)(**p_28)) && g_184[8]));
                }
            }
        }
        step_hash(850);
        g_594[0][9] = (*l_1439);
    }
    else
    {
        short l_1482 = 0L;
        int **l_1483[3];
        int l_1484 = 7L;
        int ***l_1498 = &l_1483[0];
        int *l_1508 = &g_26;
        int i;
        for (i = 0; i < 3; i++)
            l_1483[i] = &l_1471[2];
        step_hash(852);
        (*p_28) = (*p_28);
        step_hash(853);
        (*g_1357) = ((unsigned short)l_1484 << (unsigned short)1);
        step_hash(854);
        ++l_1485;
        step_hash(898);
        for (g_232 = (-21); (g_232 < 28); g_232 += 4)
        {
            signed char l_1499 = 0x4FL;
            int **l_1505[2];
            int l_1518 = 0x8008F891L;
            int i;
            for (i = 0; i < 2; i++)
                l_1505[i] = (void*)0;
            step_hash(888);
            if (l_1499)
            {
                unsigned short l_1506[7][2] = {{0UL, 0x5B8DL}, {0UL, 0x5B8DL}, {0UL, 0x5B8DL}, {0UL, 0x5B8DL}, {0UL, 0x5B8DL}, {0UL, 0x5B8DL}, {0UL, 0x5B8DL}};
                int l_1507 = 0x3C7F1D90L;
                int i, j;
                step_hash(878);
                for (l_1436 = 0; (l_1436 != 34); l_1436++)
                {
                    step_hash(867);
                    for (g_225 = 0; (g_225 > (-26)); g_225 -= 5)
                    {
                        int *l_1504 = &g_3;
                        step_hash(865);
                        (*p_28) = (**l_1498);
                        step_hash(866);
                        return l_1504;
                    }
                    step_hash(868);
                    (***l_1498) ^= (l_1505[1] != (void*)0);
                    step_hash(869);
                    if (l_1506[0][0])
                        continue;
                    step_hash(877);
                    for (g_422 = 2; (g_422 >= 0); g_422 -= 1)
                    {
                        int i;
                        step_hash(873);
                        l_1507 |= (&l_1483[g_422] != &p_29);
                        step_hash(874);
                        if ((***l_1498))
                            continue;
                        step_hash(875);
                        if ((*g_1357))
                            break;
                        step_hash(876);
                        l_1507 |= 0x49BDF297L;
                    }
                }
                step_hash(879);
                (*p_28) = &g_154;
                step_hash(880);
                if ((*g_1357))
                    continue;
                step_hash(885);
                for (l_1436 = 0; (l_1436 <= 1); l_1436 += 1)
                {
                    step_hash(884);
                    return l_1508;
                }
            }
            else
            {
                unsigned l_1509[4][6];
                int i, j;
                for (i = 0; i < 4; i++)
                {
                    for (j = 0; j < 6; j++)
                        l_1509[i][j] = 0xB9049EE8L;
                }
                step_hash(887);
                ++l_1509[2][3];
            }
            step_hash(897);
            for (g_534 = 0; (g_534 < 10); g_534 += 9)
            {
                int **l_1521 = (void*)0;
                int **l_1525 = &g_25;
                step_hash(896);
                for (g_444 = 1; (g_444 > 23); g_444 += 8)
                {
                    unsigned short l_1523 = 0x4824L;
                    int l_1524[4];
                    int i;
                    for (i = 0; i < 4; i++)
                        l_1524[i] = 0L;
                    step_hash(895);
                    (***l_1498) = ((signed char)(g_337[3][0] || (&p_29 == &p_29)) + (signed char)g_328);
                }
            }
        }
    }
    step_hash(900);
    return l_1471[2];
}







static int ** func_30(unsigned short p_31, int * p_32, unsigned p_33, unsigned char p_34)
{
    int l_1029 = 0x6729AA0AL;
    int **l_1030 = (void*)0;
    unsigned char l_1033 = 0xA8L;
    int l_1052 = (-1L);
    unsigned short l_1062 = 0x32F2L;
    int l_1079[1];
    unsigned l_1107 = 4294967292UL;
    int **l_1190 = &g_25;
    int l_1242 = 5L;
    unsigned l_1262 = 1UL;
    int *l_1273 = &g_3;
    int *l_1274 = &g_154;
    int **l_1362 = &l_1274;
    unsigned short l_1370 = 0x04DDL;
    int l_1417 = 0xD329EBB8L;
    int **l_1435 = (void*)0;
    int i;
    for (i = 0; i < 1; i++)
        l_1079[i] = 5L;
    step_hash(820);
    if (((unsigned short)(l_1029 > (((void*)0 == l_1030) || p_31)) / (unsigned short)g_337[3][0]))
    {
        int l_1049 = 1L;
        int **l_1073[3][9] = {{&g_25, &g_292, &g_25, &g_292, &g_292, (void*)0, &g_292, &g_292, (void*)0}, {&g_25, &g_292, &g_25, &g_292, &g_292, (void*)0, &g_292, &g_292, (void*)0}, {&g_25, &g_292, &g_25, &g_292, &g_292, (void*)0, &g_292, &g_292, (void*)0}};
        int *l_1078 = &g_594[1][7];
        unsigned l_1085 = 0x289AD366L;
        int i, j;
        step_hash(643);
        for (l_1029 = 0; (l_1029 >= 0); l_1029 -= 1)
        {
            unsigned char l_1038 = 0xC8L;
            int **l_1053 = &g_292;
            int l_1080[9] = {0x37C6B1A2L, 0xB1AF1425L, 0x37C6B1A2L, 0xB1AF1425L, 0x37C6B1A2L, 0xB1AF1425L, 0x37C6B1A2L, 0xB1AF1425L, 0x37C6B1A2L};
            unsigned l_1103 = 8UL;
            int i;
            step_hash(605);
            (**l_1053) = ((short)(g_328 <= (((unsigned char)255UL / (unsigned char)p_31) != p_31)) / (short)0x48B3L);
            step_hash(606);
            (*p_32) &= ((void*)0 == &l_1053);
            step_hash(607);
            (**l_1053) = (p_32 != p_32);
            step_hash(642);
            for (p_34 = 0; (p_34 <= 0); p_34 += 1)
            {
                int *l_1054 = &g_3;
                short l_1058[5];
                int *l_1076 = &g_232;
                int ***l_1100 = (void*)0;
                int i, j;
                for (i = 0; i < 5; i++)
                    l_1058[i] = 0x1D6CL;
                step_hash(611);
                (**l_1053) = (0UL ^ 4UL);
                step_hash(639);
                if ((g_883[(l_1029 + 2)][l_1029] > (0x2281L != p_34)))
                {
                    unsigned l_1055 = 9UL;
                    int *l_1061 = &g_154;
                    int l_1081 = 0x7BA8F649L;
                    step_hash(613);
                    (*l_1061) = ((p_33 != l_1055) > ((unsigned short)((g_184[7] | p_34) > (*l_1061)) * (unsigned short)0xF7CFL));
                    step_hash(621);
                    if ((*l_1054))
                    {
                        signed char l_1077 = 0xA3L;
                        int l_1082 = 1L;
                        int l_1084 = 0xB80A7EEDL;
                        step_hash(615);
                        (*p_32) = ((unsigned)((short)((unsigned)g_422 / (unsigned)((unsigned char)((signed char)((-1L) || (g_1024[1] || (**l_1053))) * (signed char)p_31) / (unsigned char)5L)) * (short)g_199) - (unsigned)g_230);
                        step_hash(616);
                        --l_1085;
                        step_hash(617);
                        (*l_1053) = l_1054;
                    }
                    else
                    {
                        step_hash(619);
                        (*p_32) = (&p_32 != &p_32);
                        step_hash(620);
                        return l_1053;
                    }
                    step_hash(626);
                    for (g_249 = 13; (g_249 != 58); g_249 += 4)
                    {
                        step_hash(625);
                        return l_1030;
                    }
                    step_hash(634);
                    for (g_534 = 0; (g_534 <= 0); g_534 += 1)
                    {
                        int *l_1093 = &l_1080[6];
                        int i, j;
                        step_hash(630);
                        if (g_396[(g_534 + 8)][(l_1029 + 4)])
                            break;
                        step_hash(631);
                        l_1093 = func_42((0x7840B109L >= (-(signed char)(**l_1053))), ((unsigned char)p_34 << (unsigned char)4));
                        step_hash(632);
                        l_1103 = ((int)((short)((int)(*l_1061) / (int)((signed char)((void*)0 == &g_25) * (signed char)0xEAL)) << (short)1) + (int)g_337[5][3]);
                        step_hash(633);
                        l_1073[l_1029][(l_1029 + 1)] = &p_32;
                    }
                }
                else
                {
                    int ***l_1106 = &l_1073[2][2];
                    step_hash(636);
                    (**l_1053) = (((signed char)l_1062 % (signed char)0xBFL) || (*l_1076));
                    step_hash(637);
                    (*l_1106) = &p_32;
                    step_hash(638);
                    ++l_1107;
                }
                step_hash(640);
                for (l_1103 = 0; l_1103 < 3; l_1103 += 1)
                {
                    for (g_429 = 0; g_429 < 10; g_429 += 1)
                    {
                        g_594[l_1103][g_429] = 0xA992F5E7L;
                    }
                }
                step_hash(641);
                (*l_1053) = func_42(((short)p_34 / (short)(p_34 & ((signed char)p_34 / (signed char)(*l_1054)))), p_33);
            }
        }
    }
    else
    {
        int *l_1133 = &g_154;
        int l_1179 = 1L;
        short l_1191 = 0xA021L;
        int l_1195 = 0x3F256AA6L;
        unsigned char l_1211 = 0x0DL;
        signed char l_1226 = 0xE7L;
        int l_1232[8] = {(-1L), (-4L), (-1L), (-4L), (-1L), (-4L), (-1L), (-4L)};
        int l_1239[5][8] = {{0x4BCD9F93L, 6L, 1L, 0xABB36AE7L, 0L, 0xB3994CD8L, 0L, 0xABB36AE7L}, {0x4BCD9F93L, 6L, 1L, 0xABB36AE7L, 0L, 0xB3994CD8L, 0L, 0xABB36AE7L}, {0x4BCD9F93L, 6L, 1L, 0xABB36AE7L, 0L, 0xB3994CD8L, 0L, 0xABB36AE7L}, {0x4BCD9F93L, 6L, 1L, 0xABB36AE7L, 0L, 0xB3994CD8L, 0L, 0xABB36AE7L}, {0x4BCD9F93L, 6L, 1L, 0xABB36AE7L, 0L, 0xB3994CD8L, 0L, 0xABB36AE7L}};
        int l_1257 = 0x1883B8B8L;
        short l_1296 = 0xADBBL;
        int *l_1367 = &g_594[0][9];
        unsigned l_1368[7] = {0xF56B1555L, 0xF56B1555L, 0x513D8D3DL, 0xF56B1555L, 0xF56B1555L, 0x513D8D3DL, 0xF56B1555L};
        int i, j;
        step_hash(704);
        if ((0xABAFL != p_31))
        {
            unsigned char l_1119 = 0xF1L;
            int **l_1134 = &g_292;
            int *l_1171 = &g_154;
            int l_1180[8] = {0x0C4815FBL, 9L, 0x0C4815FBL, 9L, 0x0C4815FBL, 9L, 0x0C4815FBL, 9L};
            unsigned short l_1231 = 0x2100L;
            int i;
            step_hash(652);
            if (((((signed char)((g_397 && (-(short)(-4L))) || (l_1119 ^ p_33)) >> (signed char)5) ^ ((((short)(**l_1134) / (short)0x17B4L) ^ p_34) <= p_31)) < 0x023930F5L))
            {
                step_hash(647);
                p_32 = (void*)0;
            }
            else
            {
                step_hash(649);
                (*g_292) = (((void*)0 == g_193) ^ g_594[0][3]);
                step_hash(650);
                (**l_1134) = (((signed char)p_31 + (signed char)((void*)0 == &p_32)) && ((unsigned)(*l_1133) % (unsigned)4294967289UL));
                step_hash(651);
                (*l_1133) &= (*g_292);
            }
            step_hash(700);
            if (((unsigned)((unsigned char)((unsigned char)(**l_1134) / (unsigned char)p_33) / (unsigned char)g_594[1][6]) - (unsigned)((int)((((void*)0 == p_32) > (((unsigned short)0xEE0FL << (unsigned short)10) | (((&p_32 == (void*)0) != 1L) | g_211))) > p_33) / (int)(**l_1134))))
            {
                signed char l_1160[8];
                int *l_1174 = &g_232;
                unsigned short l_1205 = 0xF8ACL;
                int i;
                for (i = 0; i < 8; i++)
                    l_1160[i] = 0x27L;
                step_hash(682);
                if ((*g_292))
                {
                    unsigned short l_1159 = 0xEBBFL;
                    short l_1161[5][1] = {{(-6L)}, {(-6L)}, {(-6L)}, {(-6L)}, {(-6L)}};
                    int ***l_1168 = &l_1030;
                    signed char l_1175 = 0x7CL;
                    int *l_1176 = (void*)0;
                    int *l_1177 = &l_1079[0];
                    int *l_1178[2];
                    unsigned short l_1181 = 65527UL;
                    int i, j;
                    for (i = 0; i < 2; i++)
                        l_1178[i] = &g_594[1][3];
                    step_hash(662);
                    if (((int)((short)p_31 << (short)(((((void*)0 == p_32) != (*l_1133)) | (((0x9BFB424AL | ((short)((signed char)((unsigned short)65527UL >> (unsigned short)l_1159) << (signed char)0) * (short)((g_355 & l_1160[0]) || (*l_1133)))) | p_34) || l_1161[1][0])) ^ 0xDA59L)) + (int)(**l_1134)))
                    {
                        step_hash(656);
                        (*l_1133) = (((unsigned char)((int)l_1160[0] / (int)0x351159A8L) + (unsigned char)g_594[2][0]) || (**l_1134));
                        step_hash(657);
                        (*l_1133) = ((unsigned char)(p_31 | (p_31 >= (0x6E1D2D00L & g_1024[1]))) >> (unsigned char)g_338[6]);
                        step_hash(658);
                        (*l_1134) = p_32;
                        step_hash(659);
                        (*l_1134) = p_32;
                    }
                    else
                    {
                        step_hash(661);
                        (**l_1134) = (p_32 == &g_3);
                    }
                    step_hash(669);
                    if ((0xA5L != (((unsigned)(l_1133 == l_1171) - (unsigned)(*l_1133)) < (((unsigned char)(((0x26L < ((((g_1024[7] == g_3) != ((l_1174 == &g_154) ^ 1L)) > 0x83L) ^ 0xAB9571F0L)) < 0x1EF2892FL) <= 1L) << (unsigned char)3) > (*l_1174)))))
                    {
                        step_hash(664);
                        (*l_1171) = p_31;
                        step_hash(665);
                        (*l_1134) = p_32;
                    }
                    else
                    {
                        step_hash(667);
                        l_1079[0] ^= (*l_1171);
                        step_hash(668);
                        (*l_1171) = p_34;
                    }
                    step_hash(670);
                    ++l_1181;
                }
                else
                {
                    int l_1192 = 0L;
                    int l_1204 = 0xF0938542L;
                    step_hash(681);
                    if (((unsigned char)((g_355 & ((unsigned short)((unsigned char)(l_1190 == &g_25) / (unsigned char)g_423[6][0]) << (unsigned short)g_503)) ^ 0x2E28BBFAL) / (unsigned char)g_1024[1]))
                    {
                        step_hash(673);
                        (*l_1133) = (**l_1134);
                        step_hash(674);
                        (*g_292) = l_1195;
                        step_hash(675);
                        (*l_1133) |= (p_34 == (&g_25 != (void*)0));
                        step_hash(676);
                        (*l_1171) = (g_1196 == (+(*l_1133)));
                    }
                    else
                    {
                        unsigned char l_1199 = 0UL;
                        int *l_1202 = &l_1180[2];
                        int *l_1203[6] = {(void*)0, (void*)0, &g_594[0][9], (void*)0, (void*)0, &g_594[0][9]};
                        int i;
                        step_hash(678);
                        (*l_1202) ^= ((unsigned short)(4294967286UL & (((*l_1171) || (255UL != l_1199)) || (((unsigned short)g_524 << (unsigned short)8) & (*l_1174)))) * (unsigned short)((-6L) ^ p_33));
                        step_hash(679);
                        (*l_1190) = &g_154;
                        step_hash(680);
                        --l_1205;
                    }
                }
                step_hash(683);
                (*l_1134) = &g_3;
            }
            else
            {
                int *l_1208 = &l_1079[0];
                int *l_1209 = &l_1179;
                int *l_1210[7] = {(void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0};
                unsigned l_1243[10][7] = {{1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}, {1UL, 0UL, 1UL, 2UL, 0x4C3735E5L, 4294967295UL, 4294967295UL}};
                int i, j;
                step_hash(685);
                l_1211++;
                step_hash(698);
                for (g_249 = 2; (g_249 <= 7); g_249 += 1)
                {
                    unsigned short l_1218 = 2UL;
                    int **l_1221 = &g_292;
                    int **l_1228 = (void*)0;
                    int **l_1229 = &l_1171;
                    int l_1234 = 0x670A152EL;
                    int l_1235 = 1L;
                    int l_1236 = (-3L);
                    int l_1238 = (-1L);
                    int l_1240[4][2] = {{0x11F6C806L, 0x11F6C806L}, {0x11F6C806L, 0x11F6C806L}, {0x11F6C806L, 0x11F6C806L}, {0x11F6C806L, 0x11F6C806L}};
                    int i, j;
                    step_hash(689);
                    (*l_1134) = &l_1180[g_249];
                    step_hash(690);
                    (*l_1208) ^= l_1180[g_249];
                    step_hash(697);
                    if ((+p_31))
                    {
                        unsigned char l_1227 = 0UL;
                        int **l_1230 = &l_1210[4];
                        step_hash(692);
                        (*l_1171) ^= (((unsigned char)p_33 >> (unsigned char)6) >= (-5L));
                        step_hash(693);
                        l_1232[5] ^= l_1231;
                    }
                    else
                    {
                        int l_1233 = 7L;
                        int l_1237 = 0L;
                        int l_1241[5][3] = {{0x2DD17C1CL, 0x8AF23081L, 0x1FC8088CL}, {0x2DD17C1CL, 0x8AF23081L, 0x1FC8088CL}, {0x2DD17C1CL, 0x8AF23081L, 0x1FC8088CL}, {0x2DD17C1CL, 0x8AF23081L, 0x1FC8088CL}, {0x2DD17C1CL, 0x8AF23081L, 0x1FC8088CL}};
                        unsigned l_1250[7][7] = {{4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}, {4294967290UL, 1UL, 0xA6D5C212L, 1UL, 4294967290UL, 0xBE55C406L, 0x16F63DF4L}};
                        int i, j;
                        step_hash(695);
                        l_1243[9][6]--;
                        step_hash(696);
                        (**l_1134) |= ((unsigned short)(p_33 != (((short)l_1250[0][5] >> (short)15) ^ 9L)) << (unsigned short)7);
                    }
                }
                step_hash(699);
                (*l_1208) = 1L;
            }
        }
        else
        {
            unsigned char l_1263[6];
            int *l_1264 = &g_594[2][5];
            int i;
            for (i = 0; i < 6; i++)
                l_1263[i] = 0x54L;
            step_hash(702);
            (*g_292) = (*g_292);
            step_hash(703);
            (*l_1264) |= ((short)(((unsigned short)p_33 * (unsigned short)(8UL >= ((((unsigned)g_883[6][0] + (unsigned)(*l_1133)) != (*p_32)) < l_1257))) | 0xFD4EL) << (short)(((int)((unsigned char)(p_31 | ((*p_32) > l_1262)) * (unsigned char)g_199) + (int)(*p_32)) != l_1263[0]));
        }
        step_hash(819);
        if (((((unsigned short)((unsigned short)(g_396[0][4] != (*l_1133)) << (unsigned short)p_34) << (unsigned short)p_33) != g_26) || 0xD2D2L))
        {
            int *l_1275 = (void*)0;
            unsigned l_1278[3];
            unsigned char l_1283 = 0x72L;
            int l_1294 = (-1L);
            int l_1297 = 0x101F6C0DL;
            int l_1298 = (-1L);
            int l_1299[2][9] = {{0x23EAE8D2L, 0x23EAE8D2L, 1L, 0x23EAE8D2L, 0x23EAE8D2L, 1L, 0x23EAE8D2L, 0x23EAE8D2L, 1L}, {0x23EAE8D2L, 0x23EAE8D2L, 1L, 0x23EAE8D2L, 0x23EAE8D2L, 1L, 0x23EAE8D2L, 0x23EAE8D2L, 1L}};
            unsigned char l_1338 = 0x2DL;
            int i, j;
            for (i = 0; i < 3; i++)
                l_1278[i] = 0x94B24562L;
            step_hash(706);
            l_1274 = l_1273;
            step_hash(707);
            l_1275 = (void*)0;
            step_hash(772);
            if (((int)(*l_1133) - (int)0L))
            {
                int *l_1281 = &g_3;
                int l_1282[9];
                int l_1291 = 0x9630ACC0L;
                int l_1295[3][5] = {{0x28CDF635L, (-1L), 0x4EA173BFL, 0x4EA173BFL, (-1L)}, {0x28CDF635L, (-1L), 0x4EA173BFL, 0x4EA173BFL, (-1L)}, {0x28CDF635L, (-1L), 0x4EA173BFL, 0x4EA173BFL, (-1L)}};
                unsigned char l_1300 = 0x24L;
                int *l_1308[7][9] = {{&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}, {&l_1239[3][3], &g_154, &l_1179, &g_232, &l_1179, (void*)0, (void*)0, &l_1179, &g_232}};
                unsigned l_1335 = 0x4DAC3CDCL;
                int i, j;
                for (i = 0; i < 9; i++)
                    l_1282[i] = (-1L);
                step_hash(728);
                if ((~(*l_1274)))
                {
                    int **l_1289 = &l_1281;
                    int *l_1290 = &g_154;
                    int *l_1292 = &g_594[0][9];
                    int *l_1293[10] = {(void*)0, &l_1079[0], &l_1179, &l_1179, &l_1079[0], (void*)0, &l_1079[0], &l_1179, &l_1179, &l_1079[0]};
                    int i;
                    step_hash(715);
                    if (l_1278[0])
                    {
                        unsigned char l_1284 = 0UL;
                        step_hash(711);
                        --l_1284;
                        step_hash(712);
                        g_26 &= ((unsigned char)p_33 >> (unsigned char)6);
                    }
                    else
                    {
                        step_hash(714);
                        return &g_292;
                    }
                    step_hash(716);
                    l_1300++;
                    step_hash(717);
                    (*l_1289) = p_32;
                }
                else
                {
                    unsigned l_1305[3];
                    int i;
                    for (i = 0; i < 3; i++)
                        l_1305[i] = 0xB82D25A5L;
                    step_hash(719);
                    (*l_1133) = (*l_1281);
                    step_hash(727);
                    for (l_1062 = 0; (l_1062 > 48); l_1062 += 1)
                    {
                        step_hash(723);
                        if (l_1305[2])
                            break;
                        step_hash(724);
                        if (l_1305[2])
                            continue;
                        step_hash(725);
                        l_1294 = (*l_1133);
                        step_hash(726);
                        (*l_1133) = ((signed char)g_883[3][0] >> (signed char)(*l_1133));
                    }
                }
                step_hash(729);
                l_1133 = p_32;
                step_hash(730);
                l_1079[0] &= 0x2F1EE157L;
                step_hash(754);
                for (g_1083 = 0; (g_1083 < (-27)); g_1083--)
                {
                    unsigned char l_1311[8][4] = {{0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}, {0x19L, 0x19L, 0x03L, 4UL}};
                    int ***l_1320[2][5] = {{&l_1030, &l_1030, &l_1030, &l_1030, &l_1030}, {&l_1030, &l_1030, &l_1030, &l_1030, &l_1030}};
                    int l_1324 = (-1L);
                    int i, j;
                    step_hash(738);
                    for (l_1033 = 0; (l_1033 <= 0); l_1033 += 1)
                    {
                        step_hash(737);
                        l_1311[7][2]++;
                    }
                    step_hash(745);
                    for (g_595 = 0; (g_595 <= 3); g_595 += 1)
                    {
                        int l_1321 = 0xAB6B33DAL;
                        int i, j;
                        step_hash(742);
                        l_1321 |= (65535UL > ((unsigned char)((signed char)0L >> (signed char)(l_1311[(g_595 + 2)][g_595] == ((signed char)(l_1311[7][2] || (g_193 != l_1320[1][0])) * (signed char)(0x0AL & (0x4276L >= (g_225 >= g_594[1][1])))))) * (unsigned char)p_31));
                        step_hash(743);
                        (*l_1190) = &l_1257;
                        step_hash(744);
                        l_1321 &= (p_33 >= (((int)(((((l_1324 < ((signed char)g_232 + (signed char)((short)p_31 << (short)(g_232 || p_31)))) > ((6L | l_1311[(g_595 + 2)][g_595]) & (((-1L) < 0xCC03L) | 0x40BDL))) ^ p_34) & 0UL) || g_1024[3]) / (int)p_31) ^ 0x4CFEL));
                    }
                    step_hash(753);
                    for (g_328 = (-24); (g_328 < 13); g_328 += 1)
                    {
                        int l_1333 = 0L;
                        int *l_1334 = &g_26;
                        step_hash(749);
                        g_232 = (((int)0x891351B5L + (int)p_33) | l_1333);
                        step_hash(750);
                        l_1239[0][1] &= p_31;
                        step_hash(751);
                        (*l_1334) = l_1335;
                        step_hash(752);
                        (*l_1334) &= p_33;
                    }
                }
            }
            else
            {
                step_hash(769);
                for (l_1226 = 3; (l_1226 <= 9); l_1226 += 4)
                {
                    unsigned l_1354[9][8] = {{4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}, {4294967289UL, 0xFC687138L, 1UL, 0UL, 0x9584919CL, 0xD7D3AB05L, 4294967292UL, 0xECCD1F61L}};
                    int i, j;
                    step_hash(768);
                    if (l_1338)
                    {
                        unsigned l_1345 = 4294967287UL;
                        int **l_1346 = (void*)0;
                        step_hash(760);
                        (*l_1190) = (void*)0;
                        step_hash(761);
                        (*l_1133) ^= 0xC060893EL;
                        step_hash(762);
                        (*l_1133) ^= 0L;
                        step_hash(763);
                        (*l_1133) |= (0xAEDEL <= (((unsigned char)p_34 / (unsigned char)((short)(p_34 <= ((0x2EBC72F2L & ((unsigned char)p_33 >> (unsigned char)3)) < p_33)) / (short)g_184[8])) >= p_34));
                    }
                    else
                    {
                        int *l_1347 = &g_232;
                        int *l_1348 = &l_1079[0];
                        int *l_1349 = (void*)0;
                        int *l_1350 = &l_1179;
                        int *l_1351 = &g_154;
                        int *l_1352 = &l_1294;
                        int *l_1353[7][9] = {{&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}, {&g_594[0][9], &l_1242, &l_1298, &l_1079[0], &g_232, &l_1079[0], &g_232, &l_1079[0], &l_1298}};
                        int i, j;
                        step_hash(765);
                        l_1354[1][1]--;
                        step_hash(766);
                        if (l_1354[1][1])
                            break;
                        step_hash(767);
                        (*l_1350) = 0x4FB2CE7DL;
                    }
                }
                step_hash(770);
                (*l_1190) = g_1357;
                step_hash(771);
                return &g_292;
            }
            step_hash(773);
            (*l_1190) = func_42((9L | ((unsigned)0xCBCDA671L + (unsigned)(((unsigned)(**l_1362) + (unsigned)p_34) & p_31))), l_1239[2][6]);
        }
        else
        {
            int ***l_1363[6];
            unsigned l_1364[1];
            unsigned short l_1369 = 0x0ECEL;
            int i;
            for (i = 0; i < 6; i++)
                l_1363[i] = &l_1190;
            for (i = 0; i < 1; i++)
                l_1364[i] = 1UL;
            step_hash(790);
            if (l_1370)
            {
                int l_1373 = 0x270A1387L;
                step_hash(787);
                for (g_328 = (-19); (g_328 != 19); ++g_328)
                {
                    int **l_1376 = &g_1357;
                    step_hash(786);
                    if (l_1373)
                    {
                        step_hash(780);
                        return &g_1357;
                    }
                    else
                    {
                        short l_1391 = 0x2F59L;
                        step_hash(782);
                        if ((*g_1357))
                            break;
                        step_hash(783);
                        (*l_1367) = (**l_1376);
                        step_hash(784);
                        (**l_1376) = ((unsigned char)((-1L) != p_34) << (unsigned char)(g_249 & (((int)((p_32 == &g_594[0][9]) & ((short)(-1L) << (short)9)) + (int)(((*l_1273) || ((int)1L / (int)g_211)) & (*l_1273))) < g_577)));
                        step_hash(785);
                        (*l_1133) &= (((unsigned char)255UL - (unsigned char)((**l_1376) > ((&p_32 == &p_32) <= ((g_3 & ((unsigned short)(l_1373 & ((*l_1376) == p_32)) / (unsigned short)l_1391)) ^ l_1391)))) == 0x33L);
                    }
                }
            }
            else
            {
                step_hash(789);
                return &g_25;
            }
            step_hash(802);
            for (p_33 = 0; (p_33 != 24); p_33 += 5)
            {
                int l_1411[8][8] = {{(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}, {(-5L), 0xBDA87B23L, 0x7035D55DL, 3L, 0xCC240084L, 3L, 0x7035D55DL, 0xBDA87B23L}};
                int i, j;
                step_hash(801);
                if (((unsigned char)(((short)g_422 >> (short)(&l_1274 == &p_32)) > ((((unsigned char)((*l_1273) | ((((((((unsigned short)65535UL >> (unsigned short)3) | (g_339 ^ ((signed char)(p_31 | (+g_338[2])) >> (signed char)2))) == p_31) != (*l_1273)) == g_184[7]) || g_225) == 9UL)) >> (unsigned char)2) ^ p_33) < p_31)) << (unsigned char)3))
                {
                    step_hash(795);
                    (*l_1362) = func_42((*l_1367), ((&g_1357 != &p_32) >= p_33));
                    step_hash(796);
                    return &g_1357;
                }
                else
                {
                    unsigned short l_1406[7][10] = {{0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}, {0x8EEFL, 0x3DDCL, 0x9B17L, 0xC03CL, 0xB6E1L, 0xC03CL, 0x9B17L, 0x3DDCL, 0x8EEFL, 65535UL}};
                    int i, j;
                    step_hash(798);
                    if ((*g_1357))
                        break;
                    step_hash(799);
                    if (l_1406[2][0])
                        break;
                    step_hash(800);
                    (*g_1357) &= ((int)((signed char)l_1411[1][4] * (signed char)0x7DL) + (int)0x20919729L);
                }
            }
            step_hash(803);
            p_32 = (*l_1362);
            step_hash(818);
            for (p_31 = 0; (p_31 < 10); ++p_31)
            {
                int l_1416 = 0L;
                int **l_1432 = (void*)0;
                step_hash(817);
                for (l_1033 = 16; (l_1033 < 49); l_1033 += 8)
                {
                    int l_1431 = (-1L);
                    step_hash(816);
                    if (l_1416)
                    {
                        unsigned l_1426 = 4UL;
                        unsigned short l_1433 = 65535UL;
                        step_hash(811);
                        (*g_1357) |= (*p_32);
                        step_hash(812);
                        (*l_1274) = l_1433;
                        step_hash(813);
                        g_1434 = (void*)0;
                    }
                    else
                    {
                        step_hash(815);
                        if ((*p_32))
                            break;
                    }
                }
            }
        }
    }
    step_hash(821);
    (*g_1357) = (-1L);
    step_hash(822);
    return l_1435;
}







static int func_39(unsigned p_40, int * p_41)
{
    signed char l_608 = (-8L);
    int **l_612 = &g_25;
    int l_632 = 0x6FD6DD8CL;
    int l_633[1];
    short l_659 = 0x3DBFL;
    unsigned l_754[2];
    unsigned char l_755[10] = {0x42L, 0x76L, 0x42L, 0x76L, 0x42L, 0x76L, 0x42L, 0x76L, 0x42L, 0x76L};
    int l_783 = 1L;
    unsigned l_870 = 0xA0042BA8L;
    signed char l_879 = 0L;
    int l_994[1][5] = {{9L, 0xACA4125EL, 9L, 0xACA4125EL, 9L}};
    unsigned l_998 = 4294967286UL;
    int i, j;
    for (i = 0; i < 1; i++)
        l_633[i] = 1L;
    for (i = 0; i < 2; i++)
        l_754[i] = 0xCADE01FFL;
    step_hash(403);
    (*p_41) = 0L;
    step_hash(450);
    if (l_608)
    {
        step_hash(405);
        return l_608;
    }
    else
    {
        signed char l_609[8] = {2L, 2L, 0xF5L, 2L, 2L, 0xF5L, 2L, 2L};
        int *l_611[10];
        int l_663[4][3] = {{(-10L), (-3L), (-10L)}, {(-10L), (-3L), (-10L)}, {(-10L), (-3L), (-10L)}, {(-10L), (-3L), (-10L)}};
        unsigned char l_664 = 0xADL;
        int ***l_683 = (void*)0;
        int i, j;
        for (i = 0; i < 10; i++)
            l_611[i] = &g_594[0][9];
        step_hash(449);
        if ((p_40 & 0x170FL))
        {
            unsigned l_613 = 4294967295UL;
            int *l_621 = &g_26;
            int l_634 = 0L;
            int l_635 = 0L;
            int l_637 = 0x17D1E21DL;
            int l_641[6][1] = {{0xCEF855DCL}, {0xCEF855DCL}, {0xCEF855DCL}, {0xCEF855DCL}, {0xCEF855DCL}, {0xCEF855DCL}};
            unsigned short l_646 = 0x78F7L;
            int ***l_653 = &l_612;
            unsigned l_654 = 4294967286UL;
            int i, j;
            step_hash(412);
            for (l_608 = 0; (l_608 <= 6); l_608 += 1)
            {
                step_hash(411);
                if (l_609[2])
                    break;
            }
            step_hash(434);
            for (p_40 = 0; (p_40 <= 2); p_40 += 1)
            {
                int **l_610[6][5];
                short l_614 = 0x02F7L;
                int l_638 = 0L;
                int l_645 = (-4L);
                int i, j;
                for (i = 0; i < 6; i++)
                {
                    for (j = 0; j < 5; j++)
                        l_610[i][j] = &g_292;
                }
                step_hash(428);
                if ((*g_292))
                {
                    step_hash(417);
                    l_614 &= (*p_41);
                }
                else
                {
                    unsigned l_626 = 0xD29443E5L;
                    int l_631 = 0x1B1EF5C0L;
                    int l_636 = 1L;
                    int l_642[2];
                    int l_644 = 0x640B74C2L;
                    unsigned char l_649 = 0x51L;
                    int i;
                    for (i = 0; i < 2; i++)
                        l_642[i] = 8L;
                    step_hash(427);
                    if (((int)(((unsigned char)((unsigned short)(+p_40) + (unsigned short)((g_225 && (p_40 ^ g_328)) >= p_40)) + (unsigned char)l_613) <= 4294967288UL) - (int)g_232))
                    {
                        signed char l_639[4] = {0x5FL, 0xBFL, 0x5FL, 0xBFL};
                        int l_640[10] = {1L, 1L, 0x558BD61EL, 1L, 1L, 0x558BD61EL, 1L, 1L, 0x558BD61EL, 1L};
                        int l_643[9] = {0x38D2291BL, 0x7E288652L, 0x38D2291BL, 0x7E288652L, 0x38D2291BL, 0x7E288652L, 0x38D2291BL, 0x7E288652L, 0x38D2291BL};
                        int **l_650 = &l_611[2];
                        int i;
                        step_hash(420);
                        (*g_292) = (g_337[3][1] <= 0L);
                        step_hash(421);
                        l_646++;
                        step_hash(422);
                        (*g_292) = (*p_41);
                        step_hash(423);
                        (*l_612) = p_41;
                    }
                    else
                    {
                        step_hash(425);
                        l_644 &= ((unsigned char)(g_193 == l_653) + (unsigned char)(+(((g_193 == g_193) & p_40) ^ (*p_41))));
                        step_hash(426);
                        if (l_642[1])
                            break;
                    }
                }
                step_hash(433);
                for (g_140 = 0; (g_140 <= 2); g_140 += 1)
                {
                    step_hash(432);
                    l_654--;
                }
            }
        }
        else
        {
            int l_657 = 0xCB3DF271L;
            int l_658 = 0xFC905425L;
            signed char l_660[9] = {(-1L), (-1L), (-1L), (-1L), (-1L), (-1L), (-1L), (-1L), (-1L)};
            int l_661 = 4L;
            int l_662[10][3] = {{0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}, {0x712B81C2L, 1L, 0x70B5938AL}};
            int i, j;
            step_hash(436);
            ++l_664;
            step_hash(443);
            for (l_659 = 0; (l_659 >= (-16)); --l_659)
            {
                step_hash(440);
                (*g_292) = (*p_41);
                step_hash(441);
                (*l_612) = &g_594[0][9];
                step_hash(442);
                (**l_612) &= (p_40 <= (0x2B3FL > ((signed char)(g_423[6][0] ^ ((int)(*p_41) - (int)0x1F6C8B46L)) << (signed char)4)));
            }
            step_hash(448);
            for (g_355 = 13; (g_355 >= 53); g_355 += 5)
            {
                short l_684 = 0x8299L;
                step_hash(447);
                (*p_41) = ((unsigned char)(g_595 != (p_40 | ((short)(4UL == ((+(0xADL || l_660[2])) || ((((unsigned short)(l_683 == g_193) / (unsigned short)l_658) && p_40) < g_545))) * (short)g_338[2]))) + (unsigned char)l_662[8][2]);
            }
        }
    }
    step_hash(598);
    if ((*g_292))
    {
        unsigned char l_693 = 0x12L;
        step_hash(467);
        for (p_40 = 0; (p_40 <= 2); p_40 += 1)
        {
            int **l_695 = (void*)0;
            int *l_708 = (void*)0;
            int *l_709 = &l_633[0];
            step_hash(465);
            for (g_211 = 0; (g_211 <= 6); g_211 += 1)
            {
                unsigned l_694 = 0UL;
                int *l_704 = (void*)0;
                int l_705[2];
                int i;
                for (i = 0; i < 2; i++)
                    l_705[i] = 0x4D72859CL;
                step_hash(463);
                for (g_429 = 0; (g_429 <= 0); g_429 += 1)
                {
                    int i, j;
                    step_hash(461);
                    (*p_41) &= ((unsigned short)g_594[p_40][(g_429 + 7)] - (unsigned short)((unsigned char)((short)(((&p_41 != &p_41) == ((g_338[(g_429 + 4)] >= ((short)l_633[g_429] - (short)g_397)) < 0xFDL)) & ((l_633[g_429] <= p_40) & l_693)) >> (short)1) * (unsigned char)l_694));
                    step_hash(462);
                    l_695 = &g_25;
                }
                step_hash(464);
                l_705[0] ^= ((short)p_40 + (short)((unsigned)((int)(func_51(((unsigned char)255UL << (unsigned char)g_184[7]), g_545, (p_40 != ((void*)0 == &p_41)), g_543, &p_41) < p_40) % (int)p_40) % (unsigned)p_40));
            }
            step_hash(466);
            (*l_709) ^= ((unsigned short)g_26 % (unsigned short)g_595);
        }
    }
    else
    {
        unsigned short l_731 = 65528UL;
        int **l_753 = (void*)0;
        short l_785[3];
        int l_799 = 0x7E3166F0L;
        int l_803[1][8] = {{0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}};
        int l_830[9][4] = {{0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}, {0xB86EAC4EL, 1L, 0x72F5E222L, 0x659B7318L}};
        int **l_850 = &g_25;
        unsigned short l_882[7] = {65528UL, 65528UL, 1UL, 65528UL, 65528UL, 1UL, 65528UL};
        int ***l_919 = &l_753;
        signed char l_984 = 0x9CL;
        int l_990 = (-1L);
        short l_992 = (-5L);
        unsigned char l_1005 = 255UL;
        unsigned char l_1020 = 0xF3L;
        short l_1023 = 1L;
        int i, j;
        for (i = 0; i < 3; i++)
            l_785[i] = 0xD86FL;
        step_hash(479);
        for (l_659 = 0; (l_659 <= 13); l_659 += 1)
        {
            unsigned l_728 = 0UL;
            int l_745 = 0x62A8108DL;
            step_hash(472);
            (*g_292) = ((!(((short)((unsigned char)((signed char)(((int)(4294967295UL == g_396[0][3]) % (int)((unsigned short)((unsigned)((unsigned char)((unsigned char)(4294967295UL <= (l_728 & ((-1L) ^ (p_40 && (((unsigned short)(l_731 & (*g_292)) / (unsigned short)((((*p_41) != p_40) == 0x0BEB066EL) || g_154)) != l_731))))) << (unsigned char)p_40) * (unsigned char)p_40) % (unsigned)4294967295UL) + (unsigned short)0x6D2AL)) <= p_40) - (signed char)0xCEL) + (unsigned char)p_40) / (short)g_244) != (-4L))) != 0x74491D21L);
            step_hash(478);
            for (g_577 = (-16); (g_577 == 6); g_577 += 5)
            {
                unsigned short l_736 = 0x5BFBL;
                step_hash(476);
                (*p_41) |= (-1L);
                step_hash(477);
                l_745 |= ((unsigned short)l_736 >> (unsigned short)((((short)((unsigned short)p_40 * (unsigned short)((unsigned short)p_40 % (unsigned short)g_337[3][0])) % (short)(p_40 || ((unsigned char)g_2[3] * (unsigned char)g_210))) == ((*p_41) || ((1L || p_40) && 1L))) == l_728));
            }
        }
        step_hash(553);
        for (g_595 = 0; (g_595 <= 0); g_595 += 1)
        {
            int l_746 = 1L;
            int **l_756 = &g_25;
            int l_770[6][5] = {{6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}, {6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}, {6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}, {6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}, {6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}, {6L, 0x710053E7L, 0x1E9C7C64L, 0x1E9C7C64L, 0x710053E7L}};
            int l_795[5][9] = {{0L, 1L, 1L, 0xC018B887L, 1L, 0L, 1L, 0xC018B887L, 1L}, {0L, 1L, 1L, 0xC018B887L, 1L, 0L, 1L, 0xC018B887L, 1L}, {0L, 1L, 1L, 0xC018B887L, 1L, 0L, 1L, 0xC018B887L, 1L}, {0L, 1L, 1L, 0xC018B887L, 1L, 0L, 1L, 0xC018B887L, 1L}, {0L, 1L, 1L, 0xC018B887L, 1L, 0L, 1L, 0xC018B887L, 1L}};
            int *l_845[6] = {(void*)0, (void*)0, &l_799, (void*)0, (void*)0, &l_799};
            short l_897[9][3] = {{0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}, {0x1558L, 0x7885L, 0x1558L}};
            unsigned short l_898 = 65535UL;
            int i, j;
            step_hash(516);
            if ((l_746 <= g_594[0][9]))
            {
                unsigned l_771 = 0xBCD05241L;
                int **l_772 = &g_292;
                int l_786 = (-7L);
                int l_798 = 0x631DC005L;
                int l_801 = (-10L);
                int l_802[6][1] = {{6L}, {6L}, {6L}, {6L}, {6L}, {6L}};
                unsigned l_805 = 0x84597814L;
                int i, j;
                step_hash(496);
                if (((*p_41) != ((unsigned char)(l_612 != &p_41) >> (unsigned char)7)))
                {
                    unsigned short l_763 = 1UL;
                    step_hash(485);
                    l_770[2][2] ^= ((int)((short)l_763 << (short)((signed char)g_232 * (signed char)((((unsigned char)0x99L * (unsigned char)((((g_423[2][0] & (p_40 > ((int)l_763 % (int)(*p_41)))) | l_763) < (((247UL == 9UL) != p_40) >= p_40)) & l_763)) == g_244) > 0L))) % (int)p_40);
                }
                else
                {
                    int l_784 = 0L;
                    int l_796 = 8L;
                    int l_797 = (-1L);
                    int l_800 = 0xDBF02605L;
                    int l_804 = 0x7CF42B48L;
                    int **l_820 = &g_292;
                    step_hash(487);
                    l_771 = (*g_292);
                    step_hash(488);
                    (**l_772) = ((((l_772 == (void*)0) && p_40) != p_40) == 0x07BFL);
                    step_hash(495);
                    for (l_784 = 0; (l_784 >= 0); l_784 -= 1)
                    {
                        int *l_787 = &l_632;
                        int *l_788 = &l_632;
                        int *l_789 = (void*)0;
                        int *l_790 = &l_786;
                        int *l_791 = &l_633[0];
                        int *l_792 = &l_632;
                        int *l_793 = &l_633[0];
                        int *l_794[2];
                        int i, j;
                        for (i = 0; i < 2; i++)
                            l_794[i] = &l_633[0];
                        step_hash(492);
                        (*p_41) = g_423[g_595][g_595];
                        step_hash(493);
                        l_805--;
                        step_hash(494);
                        (*l_788) &= ((unsigned short)((unsigned char)(g_337[(l_784 + 4)][g_595] >= (((int)g_594[(g_595 + 2)][(l_784 + 3)] - (int)(**l_820)) > g_339)) * (unsigned char)g_2[0]) / (unsigned short)p_40);
                    }
                }
            }
            else
            {
                int l_825 = 9L;
                int l_828 = 0xC22744DCL;
                int l_829[8] = {0x946A2E76L, 0xFC538597L, 0x946A2E76L, 0xFC538597L, 0x946A2E76L, 0xFC538597L, 0x946A2E76L, 0xFC538597L};
                signed char l_833 = 0x0CL;
                unsigned short l_836 = 0x79BEL;
                int i;
                step_hash(509);
                for (g_429 = 0; (g_429 <= 3); g_429 += 1)
                {
                    short l_821[8];
                    int l_824 = 0x750C65E3L;
                    int l_826 = 6L;
                    int l_827 = 0x456ADDD7L;
                    int l_831 = 0xF443E775L;
                    int l_832 = (-1L);
                    int l_834 = (-1L);
                    int l_835[6][8] = {{7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}, {7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}, {7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}, {7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}, {7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}, {7L, 0xAEC1AA0DL, 0xC0B5452DL, 0xE87BF8C3L, 0xC9D4E88BL, 0L, 0x13AF5842L, 0x67943884L}};
                    int ***l_863[2];
                    int i, j;
                    for (i = 0; i < 8; i++)
                        l_821[i] = 6L;
                    for (i = 0; i < 2; i++)
                        l_863[i] = &l_753;
                    step_hash(508);
                    if ((p_41 != (void*)0))
                    {
                        int i, j;
                        step_hash(502);
                        (*l_756) = func_42(g_423[(g_595 + 2)][g_595], g_423[(g_429 + 5)][g_595]);
                    }
                    else
                    {
                        int *l_822 = &l_799;
                        int *l_823[5] = {&g_3, &g_232, &g_3, &g_232, &g_3};
                        int i, j;
                        step_hash(504);
                        l_836--;
                        step_hash(505);
                        (*g_292) = ((g_337[(g_429 + 4)][g_429] && (*p_41)) >= (~g_444));
                        step_hash(506);
                        (*g_292) = (*g_292);
                        step_hash(507);
                        g_154 |= ((signed char)((0xECL != ((*p_41) <= ((short)l_832 + (short)((unsigned short)(p_40 | 1L) * (unsigned short)((unsigned char)(((unsigned short)p_40 >> (unsigned short)11) <= (((short)g_3 >> (short)9) == ((&l_850 != l_863[0]) == g_337[4][2]))) - (unsigned char)0x2DL))))) == 0x10L) / (signed char)0x59L);
                    }
                }
                step_hash(515);
                for (g_230 = 0; (g_230 >= 0); g_230 -= 1)
                {
                    step_hash(513);
                    (*p_41) = (0xA7L > g_232);
                    step_hash(514);
                    return (*p_41);
                }
            }
            step_hash(517);
            (*g_292) = ((short)0x26EAL % (short)((((p_40 <= 0x3CL) > p_40) != (0xDD62B185L < ((unsigned)g_340[1] / (unsigned)(-10L)))) & g_211));
            step_hash(518);
            l_870--;
            step_hash(519);
            (*l_612) = func_42(p_40, ((unsigned char)(g_210 || (p_40 || (4294967292UL || (p_40 <= p_40)))) << (unsigned char)6));
            step_hash(552);
            for (g_548 = 0; (g_548 <= 0); g_548 += 1)
            {
                unsigned l_886 = 4294967295UL;
                int l_911[7][5] = {{0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}, {0xCBEF739AL, 1L, 0x1F71F7AFL, (-4L), 0xCCA97FF3L}};
                int **l_914[2];
                int i, j;
                for (i = 0; i < 2; i++)
                    l_914[i] = &g_25;
                step_hash(523);
                g_883[5][0]++;
            }
        }
        step_hash(597);
        if (((signed char)g_548 * (signed char)((((void*)0 != l_919) | (*p_41)) <= ((g_444 >= (-(unsigned)(g_226 ^ 0x32DDFB4BL))) == g_244))))
        {
            unsigned char l_921 = 251UL;
            short l_937[2];
            short l_959 = 0xE01CL;
            int l_962 = (-1L);
            short l_976 = 0L;
            signed char l_987 = 3L;
            int l_991 = (-1L);
            int l_993[3];
            short l_995[8] = {0x8A39L, (-1L), 0x8A39L, (-1L), 0x8A39L, (-1L), 0x8A39L, (-1L)};
            short l_996[5] = {1L, 1L, 1L, 1L, 1L};
            int l_997 = 6L;
            int **l_1006 = &g_292;
            int i;
            for (i = 0; i < 2; i++)
                l_937[i] = 0xA9FEL;
            for (i = 0; i < 3; i++)
                l_993[i] = 1L;
            step_hash(585);
            if ((&l_612 == g_193))
            {
                unsigned short l_928 = 0xD013L;
                int l_931 = 0x63DD22BBL;
                int l_932 = 0x43F9A84AL;
                step_hash(556);
                l_921++;
                step_hash(557);
                (*p_41) |= (((unsigned short)l_932 >> (unsigned short)9) == 0L);
            }
            else
            {
                int *l_938 = &g_154;
                int l_972 = 0x18932DBCL;
                int l_978 = (-6L);
                int l_985 = 0x2802EFB3L;
                int l_986 = 0xC3595CD8L;
                int l_988[5][6] = {{0xA41D02B1L, 0x1B51728EL, 0x498EBFC9L, 0x498EBFC9L, 0x1B51728EL, 0xA41D02B1L}, {0xA41D02B1L, 0x1B51728EL, 0x498EBFC9L, 0x498EBFC9L, 0x1B51728EL, 0xA41D02B1L}, {0xA41D02B1L, 0x1B51728EL, 0x498EBFC9L, 0x498EBFC9L, 0x1B51728EL, 0xA41D02B1L}, {0xA41D02B1L, 0x1B51728EL, 0x498EBFC9L, 0x498EBFC9L, 0x1B51728EL, 0xA41D02B1L}, {0xA41D02B1L, 0x1B51728EL, 0x498EBFC9L, 0x498EBFC9L, 0x1B51728EL, 0xA41D02B1L}};
                signed char l_989 = 1L;
                int i, j;
                step_hash(559);
                l_938 = func_42(p_40, ((unsigned short)1UL >> (unsigned short)l_937[1]));
                step_hash(564);
                for (g_534 = 0; (g_534 > 8); g_534 += 7)
                {
                    step_hash(563);
                    return (*p_41);
                }
                step_hash(565);
                l_938 = func_42(((unsigned char)g_429 % (unsigned char)p_40), ((signed char)(0xF171L == ((short)((short)((unsigned char)((g_543 != ((short)((short)p_40 - (short)g_328) >> (short)4)) && l_937[1]) << (unsigned char)6) / (short)((unsigned short)(0L != g_422) * (unsigned short)0x6A16L)) * (short)g_337[3][0])) / (signed char)l_937[0]));
                step_hash(584);
                if ((g_338[6] || (&l_612 != g_193)))
                {
                    step_hash(567);
                    return (*l_938);
                }
                else
                {
                    unsigned l_973 = 0xCC4C3DC6L;
                    int l_977 = (-8L);
                    int l_979 = 0x3D5EA11EL;
                    int l_980 = 1L;
                    int l_981 = 0L;
                    int l_982 = 1L;
                    int l_983[7] = {0xED08B0C9L, 0xFB109138L, 0xED08B0C9L, 0xFB109138L, 0xED08B0C9L, 0xFB109138L, 0xED08B0C9L};
                    int i;
                    step_hash(573);
                    for (l_731 = 0; (l_731 <= 0); l_731 += 1)
                    {
                        step_hash(572);
                        (*l_850) = (void*)0;
                    }
                    step_hash(574);
                    l_959 |= ((*l_938) == ((short)((void*)0 != p_41) << (short)2));
                    step_hash(575);
                    (*l_850) = &g_3;
                    step_hash(583);
                    for (g_328 = 0; (g_328 == 40); ++g_328)
                    {
                        int *l_963 = (void*)0;
                        int *l_964 = &l_799;
                        int *l_965 = &l_783;
                        int *l_966 = (void*)0;
                        int *l_967 = &g_594[0][9];
                        int *l_968 = (void*)0;
                        int *l_969 = &l_633[0];
                        int *l_970 = &l_799;
                        int *l_971[6] = {(void*)0, (void*)0, &g_594[0][1], (void*)0, (void*)0, &g_594[0][1]};
                        int i;
                        step_hash(579);
                        --l_973;
                        step_hash(580);
                        l_998--;
                        step_hash(581);
                        if ((**l_612))
                            continue;
                        step_hash(582);
                        (*l_965) &= (&l_612 != g_193);
                    }
                }
            }
            step_hash(592);
            if (((g_339 & (**l_1006)) != p_40))
            {
                step_hash(587);
                return (*g_292);
            }
            else
            {
                step_hash(589);
                (*l_1006) = func_42((**l_1006), p_40);
                step_hash(590);
                for (g_429 = 0; g_429 < 1; g_429 += 1)
                {
                    l_633[g_429] = 0xFFB7C9FAL;
                }
                step_hash(591);
                (**l_1006) = (+(**l_1006));
            }
            step_hash(593);
            (*l_1006) = p_41;
        }
        else
        {
            int l_1007 = 1L;
            int *l_1008 = &g_154;
            int *l_1009 = (void*)0;
            int *l_1010 = &l_799;
            int *l_1011 = &g_26;
            int *l_1012 = &l_633[0];
            int *l_1013 = &g_154;
            int *l_1014 = (void*)0;
            int l_1015 = 0x0EA46510L;
            int *l_1016 = (void*)0;
            int l_1017 = 5L;
            int *l_1018 = (void*)0;
            int *l_1019[4][7] = {{&l_803[0][1], (void*)0, &l_632, (void*)0, &l_803[0][1], &l_1007, &l_803[0][1]}, {&l_803[0][1], (void*)0, &l_632, (void*)0, &l_803[0][1], &l_1007, &l_803[0][1]}, {&l_803[0][1], (void*)0, &l_632, (void*)0, &l_803[0][1], &l_1007, &l_803[0][1]}, {&l_803[0][1], (void*)0, &l_632, (void*)0, &l_803[0][1], &l_1007, &l_803[0][1]}};
            int i, j;
            step_hash(595);
            l_1020++;
            step_hash(596);
            (*l_1008) &= g_1024[1];
        }
    }
    step_hash(599);
    return l_632;
}







static int * func_42(unsigned p_43, unsigned char p_44)
{
    int **l_555 = &g_25;
    int *l_556 = &g_26;
    int l_557 = 0x731AC907L;
    unsigned char l_569 = 255UL;
    int l_574 = 0L;
    int l_576 = 0L;
    int *l_607 = &g_26;
    step_hash(400);
    if ((0x804FL | (((((unsigned)(l_555 == l_555) % (unsigned)(*l_556)) ^ p_43) | l_557) != 251UL)))
    {
        short l_558 = 0L;
        int *l_559 = &g_154;
        int *l_560 = &g_154;
        int *l_561 = &g_154;
        int *l_562 = &g_232;
        int *l_563 = &g_26;
        int *l_564 = (void*)0;
        int *l_565 = &g_232;
        int *l_566 = &g_26;
        int *l_567 = &g_154;
        int *l_568 = &g_232;
        step_hash(381);
        ++l_569;
        step_hash(382);
        (*l_565) |= 0x745DCFF6L;
    }
    else
    {
        int *l_572 = (void*)0;
        int *l_573 = &g_232;
        int *l_575[1];
        unsigned short l_582 = 0xD90DL;
        int i;
        for (i = 0; i < 1; i++)
            l_575[i] = (void*)0;
        step_hash(384);
        --g_577;
        step_hash(399);
        for (l_574 = 0; (l_574 == 10); l_574++)
        {
            int l_583 = (-6L);
            int **l_605[4][3] = {{&l_573, (void*)0, &l_573}, {&l_573, (void*)0, &l_573}, {&l_573, (void*)0, &l_573}, {&l_573, (void*)0, &l_573}};
            int *l_606 = &g_3;
            int i, j;
            step_hash(388);
            l_583 |= l_582;
            step_hash(397);
            if (((unsigned short)((unsigned char)((signed char)((((65535UL < (*l_556)) < ((unsigned short)(l_583 <= ((p_43 >= (&g_25 != &l_575[0])) | ((&g_292 == (void*)0) && ((((g_524 <= 65534UL) | g_340[1]) | g_594[0][9]) == l_583)))) * (unsigned short)g_594[1][1])) == g_249) || g_595) << (signed char)g_396[0][3]) - (unsigned char)0x93L) / (unsigned short)l_583))
            {
                int *l_604 = &g_232;
                step_hash(390);
                (*l_573) = (((((unsigned short)((int)((signed char)(p_44 && (l_604 != (void*)0)) << (signed char)2) - (int)0xA9E3DA89L) + (unsigned short)((void*)0 != l_605[2][1])) | p_43) > (l_606 != l_572)) <= g_595);
                step_hash(391);
                if ((*l_573))
                    continue;
                step_hash(392);
                (*l_604) = p_44;
                step_hash(393);
                (*l_573) = p_44;
            }
            else
            {
                step_hash(395);
                (*l_555) = (void*)0;
                step_hash(396);
                return &g_232;
            }
            step_hash(398);
            (*l_556) = ((0xE3L < g_226) < (*l_606));
        }
    }
    step_hash(401);
    return l_607;
}







static short func_51(unsigned p_52, short p_53, int p_54, int p_55, int ** p_56)
{
    unsigned short l_470 = 65535UL;
    int **l_472 = &g_292;
    int l_480 = (-8L);
    unsigned l_485 = 4294967295UL;
    int l_525 = 0L;
    step_hash(308);
    (*g_292) = 0L;
    step_hash(375);
    if (((unsigned)l_470 + (unsigned)(-1L)))
    {
        int *l_471 = &g_154;
        step_hash(310);
        (**l_472) |= (*l_471);
        step_hash(315);
        for (g_230 = (-8); (g_230 == 14); g_230 += 2)
        {
            step_hash(314);
            if ((*g_292))
                break;
        }
    }
    else
    {
        int ***l_477 = &l_472;
        int l_489[10][4] = {{0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}, {0xFC82DC88L, (-1L), 0L, 0x4A013A1BL}};
        int l_490 = 0x9C44CCC5L;
        int l_502[2][2];
        short l_522 = (-6L);
        int i, j;
        for (i = 0; i < 2; i++)
        {
            for (j = 0; j < 2; j++)
                l_502[i][j] = 0xA92C175DL;
        }
        step_hash(321);
        for (g_355 = 0; (g_355 >= 40); g_355++)
        {
            step_hash(320);
            (**l_472) = (l_477 == (void*)0);
        }
        step_hash(326);
        for (g_26 = 0; (g_26 != 7); g_26 += 7)
        {
            step_hash(325);
            return l_480;
        }
        step_hash(374);
        for (g_228 = 0; (g_228 >= 0); g_228 -= 1)
        {
            int *l_487 = &g_3;
            int l_499 = 0x9B31973DL;
            int l_501 = 0x5AFA4DA5L;
            int l_544 = 0x073718EFL;
        }
    }
    step_hash(376);
    p_54 = (*g_292);
    step_hash(377);
    (**l_472) = (0xE07780E1L || (**p_56));
    step_hash(378);
    return (**l_472);
}







static short func_57(int p_58, unsigned p_59, int * p_60, short p_61, int p_62)
{
    int *l_96 = &g_26;
    unsigned char l_97 = 255UL;
    unsigned short l_100[8][3];
    int *l_103 = &g_26;
    int l_129 = 0x95E3EEF2L;
    int l_136 = 0xEB2EF126L;
    unsigned char l_163 = 9UL;
    int l_223 = (-10L);
    int l_233 = 0x2D96BE51L;
    int **l_303 = &l_103;
    int ***l_302[9] = {(void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0};
    unsigned short l_392 = 65533UL;
    int *l_393 = &l_136;
    unsigned l_466[3][10] = {{0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L, 0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L}, {0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L, 0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L}, {0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L, 0xAA1151E7L, 0x437FD6A4L, 6UL, 6UL, 0x437FD6A4L}};
    int *l_467 = &g_26;
    int i, j;
    for (i = 0; i < 8; i++)
    {
        for (j = 0; j < 3; j++)
            l_100[i][j] = 0xD8FEL;
    }
    step_hash(29);
    if ((((unsigned)((unsigned char)((l_97 >= ((unsigned short)l_100[4][0] - (unsigned short)0x8654L)) || g_26) << (unsigned char)0) / (unsigned)3UL) ^ 0x348DL))
    {
        step_hash(19);
        p_60 = &g_26;
        step_hash(20);
        return g_3;
    }
    else
    {
        unsigned char l_112[4][1];
        int i, j;
        for (i = 0; i < 4; i++)
        {
            for (j = 0; j < 1; j++)
                l_112[i][j] = 0x52L;
        }
        step_hash(28);
        for (p_59 = (-4); (p_59 <= 14); p_59 += 9)
        {
            int l_106 = 0L;
            int *l_107 = &g_26;
            step_hash(25);
            l_103 = &g_26;
            step_hash(26);
            if ((*g_25))
                break;
            step_hash(27);
            (*l_107) &= ((unsigned char)246UL % (unsigned char)l_112[0][0]);
        }
    }
    step_hash(304);
    if ((*l_103))
    {
        unsigned l_115 = 0x1824DA47L;
        int l_139 = 2L;
        int l_153 = 0x76DB0F71L;
        int *l_160 = &l_136;
        step_hash(54);
        for (p_59 = 15; (p_59 > 53); p_59 += 4)
        {
            unsigned short l_118 = 0UL;
            int *l_119 = &g_3;
            signed char l_127 = 0x0EL;
            int l_138 = 7L;
            int l_151 = 1L;
            int l_152[3][5];
            short l_155 = 0x031CL;
            unsigned short l_156[7][5] = {{65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}, {65530UL, 0x1100L, 0x019FL, 0x019FL, 0x1100L}};
            int *l_159 = (void*)0;
            int i, j;
            for (i = 0; i < 3; i++)
            {
                for (j = 0; j < 5; j++)
                    l_152[i][j] = 1L;
            }
            step_hash(34);
            ++l_115;
            step_hash(51);
            if (func_67((l_115 | func_67(l_118, &g_3, &l_103, (g_3 ^ (*p_60)))), l_119, &g_25, l_115))
            {
                int **l_128 = &l_103;
                int l_137 = 1L;
                step_hash(46);
                for (p_62 = 0; (p_62 > 25); p_62 += 9)
                {
                    unsigned l_124 = 0x402E0EFCL;
                    int *l_130 = &l_129;
                    int *l_131 = &l_129;
                    int *l_132 = (void*)0;
                    int *l_133 = (void*)0;
                    int *l_134 = (void*)0;
                    int *l_135[8][6] = {{&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}, {&l_129, &g_26, &g_26, &g_26, &l_129, &g_26}};
                    int i, j;
                    step_hash(39);
                    (**l_128) = ((unsigned short)l_115 * (unsigned short)(l_124 | (((unsigned short)g_2[4] * (unsigned short)l_115) == (((void*)0 != l_128) | 6UL))));
                    step_hash(40);
                    g_140--;
                    step_hash(45);
                    for (l_127 = 0; (l_127 <= 5); l_127 += 1)
                    {
                        step_hash(44);
                        return g_3;
                    }
                }
                step_hash(47);
                (**l_128) &= (-10L);
            }
            else
            {
                int **l_145 = (void*)0;
                int *l_148 = (void*)0;
                int *l_149 = &l_139;
                int *l_150[9][3] = {{&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}, {&l_138, &l_136, &g_26}};
                int i, j;
                step_hash(49);
                (*l_103) = (((unsigned char)g_140 >> (unsigned char)2) ^ p_61);
                step_hash(50);
                --l_156[2][0];
            }
            step_hash(52);
            l_159 = &p_62;
            step_hash(53);
            g_25 = l_160;
        }
        step_hash(82);
        for (l_129 = 12; (l_129 >= 6); l_129--)
        {
            unsigned short l_175[2][8];
            int i, j;
            for (i = 0; i < 2; i++)
            {
                for (j = 0; j < 8; j++)
                    l_175[i][j] = 0x9F31L;
            }
            step_hash(81);
            if ((*p_60))
            {
                step_hash(59);
                if ((*p_60))
                    break;
                step_hash(60);
                if ((*g_25))
                    break;
            }
            else
            {
                int *l_182 = &l_129;
                step_hash(62);
                if ((*g_25))
                    break;
                step_hash(63);
                if (l_163)
                    continue;
                step_hash(80);
                for (p_62 = 0; (p_62 >= (-3)); p_62 -= 9)
                {
                    short l_168[4][1] = {{(-1L)}, {(-1L)}, {(-1L)}, {(-1L)}};
                    int i, j;
                    step_hash(71);
                    for (p_61 = 0; (p_61 == (-2)); --p_61)
                    {
                        step_hash(70);
                        (*l_96) ^= l_168[3][0];
                    }
                    step_hash(79);
                    if ((((signed char)(((unsigned char)((int)(0L ^ (-9L)) - (int)(l_175[0][7] ^ (((int)((short)p_58 % (short)((signed char)func_67(g_26, l_182, &g_25, p_61) * (signed char)1UL)) + (int)(*p_60)) > p_58))) * (unsigned char)p_61) & 0x07L) << (signed char)p_59) > 0L))
                    {
                        int **l_183 = &l_160;
                        step_hash(73);
                        (*l_183) = &g_154;
                        step_hash(74);
                        if (g_184[7])
                            break;
                    }
                    else
                    {
                        int **l_186 = &l_160;
                        int ***l_185 = &l_186;
                        step_hash(76);
                        (*l_185) = &g_25;
                        step_hash(77);
                        l_153 &= func_67((*l_160), &g_3, (*l_185), (*l_182));
                        step_hash(78);
                        (**l_185) = (**l_185);
                    }
                }
            }
        }
    }
    else
    {
        int *l_194 = &g_26;
        int l_206 = (-4L);
        int l_207 = 1L;
        int l_208 = 0xD7E750E0L;
        int l_209 = 1L;
        int l_227 = 0x0B6075C1L;
        int l_231 = 0xF5C7D206L;
        int l_234 = 0x5F4AB859L;
        unsigned l_313 = 0xABF1D935L;
        int ***l_349 = &l_303;
        int l_410 = 4L;
        unsigned l_451 = 1UL;
        step_hash(84);
        (*l_194) = (((unsigned short)(*l_103) % (unsigned short)p_61) && 0x4FL);
        step_hash(290);
        if (((unsigned)((unsigned char)((65529UL || g_184[7]) ^ g_2[1]) >> (unsigned char)(*l_96)) % (unsigned)g_199))
        {
            int l_200 = (-1L);
            int *l_201 = &l_200;
            int *l_202 = &g_154;
            int *l_203 = &g_26;
            int *l_204 = (void*)0;
            int *l_205[9][2];
            short l_220 = (-5L);
            unsigned l_332[4][8] = {{0xED5DEBCBL, 0x8F58FCC1L, 4294967295UL, 4294967295UL, 0xE7A8B45EL, 0x835EB3EBL, 0xE7A8B45EL, 4294967295UL}, {0xED5DEBCBL, 0x8F58FCC1L, 4294967295UL, 4294967295UL, 0xE7A8B45EL, 0x835EB3EBL, 0xE7A8B45EL, 4294967295UL}, {0xED5DEBCBL, 0x8F58FCC1L, 4294967295UL, 4294967295UL, 0xE7A8B45EL, 0x835EB3EBL, 0xE7A8B45EL, 4294967295UL}, {0xED5DEBCBL, 0x8F58FCC1L, 4294967295UL, 4294967295UL, 0xE7A8B45EL, 0x835EB3EBL, 0xE7A8B45EL, 4294967295UL}};
            int ***l_348[5];
            int i, j;
            for (i = 0; i < 9; i++)
            {
                for (j = 0; j < 2; j++)
                    l_205[i][j] = &g_154;
            }
            for (i = 0; i < 5; i++)
                l_348[i] = &l_303;
            step_hash(86);
            g_211++;
            step_hash(203);
            if ((func_67((*l_202), &l_129, &l_201, p_59) == (((unsigned char)(((((*p_60) ^ (*p_60)) != (((unsigned char)p_59 << (unsigned char)p_59) ^ 0x88F8C125L)) | p_62) < p_59) / (unsigned char)1L) < l_220)))
            {
                short l_221 = 0x76C0L;
                int l_222 = 0x1FDA6A71L;
                int l_224 = 0xC58C7FB5L;
                int l_229 = 0L;
                int l_235 = 4L;
                int l_236 = 2L;
                unsigned l_241 = 0xF134357EL;
                unsigned l_262 = 0x68317A62L;
                int **l_263 = &g_25;
                step_hash(105);
                if (l_221)
                {
                    step_hash(89);
                    g_154 = l_221;
                    step_hash(90);
                    (*l_96) &= (p_59 ^ (p_61 >= p_58));
                    step_hash(91);
                    (*l_103) = (*l_96);
                    step_hash(92);
                    l_203 = &l_208;
                }
                else
                {
                    unsigned char l_237 = 255UL;
                    int **l_240 = &l_205[8][1];
                    int l_242 = 0x68A72DF7L;
                    int l_246 = 1L;
                    int l_247 = 0x965F41A6L;
                    step_hash(94);
                    l_237++;
                    step_hash(95);
                    (*l_240) = &l_136;
                    step_hash(96);
                    (*l_240) = &p_62;
                    step_hash(104);
                    if (l_241)
                    {
                        step_hash(98);
                        (*l_240) = &l_200;
                        step_hash(99);
                        (*l_240) = &p_62;
                    }
                    else
                    {
                        short l_243 = 0x9B24L;
                        int l_245 = 0xB8529774L;
                        int l_248 = 0xD9C56D79L;
                        step_hash(101);
                        g_249--;
                        step_hash(102);
                        (**l_240) = (*g_25);
                        step_hash(103);
                        l_207 &= ((**l_240) | (((l_248 ^ ((signed char)l_235 >> (signed char)1)) && (*l_194)) == ((short)p_62 * (short)((unsigned short)p_62 + (unsigned short)(&p_60 != &g_25)))));
                    }
                }
                step_hash(124);
                for (g_230 = (-19); (g_230 == 2); ++g_230)
                {
                    int l_268 = 0xF9731A4EL;
                    int l_279 = 0xC40897D5L;
                    step_hash(113);
                    for (l_129 = 0; (l_129 <= 8); l_129 += 1)
                    {
                        step_hash(112);
                        (*l_194) = (*g_25);
                    }
                    step_hash(114);
                    (*l_202) &= (((*p_60) != ((l_262 >= ((&g_25 == l_263) == ((unsigned char)((unsigned char)func_67(g_249, &g_3, &p_60, l_268) % (unsigned char)p_61) * (unsigned char)0UL))) > 0L)) || g_2[3]);
                    step_hash(122);
                    for (l_222 = 0; (l_222 != (-26)); l_222 -= 5)
                    {
                        int l_290 = 0x11371912L;
                        int *l_291 = (void*)0;
                        step_hash(118);
                        l_279 &= (((unsigned)p_61 / (unsigned)((unsigned char)((unsigned)g_184[6] + (unsigned)(*g_25)) - (unsigned char)((signed char)p_58 + (signed char)(-1L)))) <= g_232);
                        step_hash(119);
                        (*l_103) |= (~l_279);
                        step_hash(120);
                        (*l_201) &= (((unsigned char)((p_61 == (0xFA4CL || (*l_103))) & ((unsigned short)p_59 % (unsigned short)g_211)) + (unsigned char)p_58) < ((((unsigned char)((unsigned short)0x1156L << (unsigned short)((l_290 > (l_291 == g_292)) && 0x30F2670DL)) << (unsigned char)6) != (-6L)) == g_232));
                        step_hash(121);
                        (*l_202) ^= (*l_96);
                    }
                    step_hash(123);
                    if ((*l_201))
                        break;
                }
                step_hash(142);
                for (l_206 = 0; (l_206 <= 2); l_206 += 1)
                {
                    step_hash(132);
                    for (g_230 = 2; (g_230 >= 0); g_230 -= 1)
                    {
                        int i, j;
                        step_hash(131);
                        if (l_100[(l_206 + 5)][g_230])
                            break;
                    }
                    step_hash(133);
                    (*l_103) = (*l_194);
                    step_hash(141);
                    for (g_210 = 2; (g_210 >= 0); g_210 -= 1)
                    {
                        int i, j;
                        step_hash(137);
                        if (l_100[(l_206 + 3)][g_210])
                            break;
                        step_hash(138);
                        if ((*g_25))
                            break;
                        step_hash(139);
                        if ((*g_25))
                            continue;
                        step_hash(140);
                        if ((**l_263))
                            continue;
                    }
                }
            }
            else
            {
                signed char l_299[8][5] = {{0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}, {0x3CL, (-1L), 0L, 0x02L, (-1L)}};
                int *l_306 = &g_154;
                unsigned l_314 = 0x42308839L;
                short l_318 = 0xA17FL;
                int l_327 = 0x51733B03L;
                int l_336 = (-1L);
                int i, j;
                step_hash(185);
                if (func_67(g_2[2], &p_62, &p_60, (((short)((signed char)(p_61 == (((unsigned short)func_67((*l_194), &g_232, &l_96, g_184[6]) * (unsigned short)0L) < 0x12L)) >> (signed char)g_210) * (short)l_299[5][4]) && p_62)))
                {
                    int l_315 = 0x2D44B38EL;
                    step_hash(151);
                    if (((unsigned)p_62 + (unsigned)0x182FCCD7L))
                    {
                        step_hash(146);
                        (*l_201) &= (-6L);
                        step_hash(147);
                        (*l_103) = ((l_302[1] == (void*)0) == func_67(p_58, &l_200, &l_194, ((unsigned)g_249 % (unsigned)4294967288UL)));
                        step_hash(148);
                        (*l_303) = l_306;
                    }
                    else
                    {
                        step_hash(150);
                        return p_59;
                    }
                    step_hash(152);
                    (*l_303) = (void*)0;
                    step_hash(153);
                    (*l_306) = (((((int)(*l_306) / (int)(*g_292)) > ((signed char)((signed char)(l_313 > ((p_61 < p_59) & l_314)) - (signed char)0x92L) * (signed char)(p_61 & 0xAEL))) > g_249) != l_315);
                    step_hash(161);
                    if ((~((p_59 && ((((4294967295UL != ((signed char)(g_26 > l_318) / (signed char)((int)(*p_60) - (int)0xE40CD6EAL))) == g_211) != (g_193 != &l_303)) | g_210)) < p_62)))
                    {
                        step_hash(155);
                        p_60 = &l_315;
                    }
                    else
                    {
                        step_hash(157);
                        l_194 = &g_26;
                        step_hash(158);
                        (*l_303) = &p_62;
                        step_hash(159);
                        (*l_303) = &l_315;
                        step_hash(160);
                        (*l_201) |= (((**l_303) == 2UL) || (((unsigned char)p_62 / (unsigned char)func_67((*l_306), &g_154, &g_25, p_62)) && func_67(l_315, &l_209, &g_292, (**l_303))));
                    }
                }
                else
                {
                    int l_331 = 0xF8220F61L;
                    int l_335[5];
                    int i;
                    for (i = 0; i < 5; i++)
                        l_335[i] = (-1L);
                    step_hash(170);
                    for (l_129 = (-11); (l_129 != (-16)); l_129 -= 6)
                    {
                        signed char l_325 = (-10L);
                        int l_326[5];
                        int i;
                        for (i = 0; i < 5; i++)
                            l_326[i] = 0x39BD6E01L;
                        step_hash(166);
                        --g_328;
                        step_hash(167);
                        l_332[3][0]--;
                        step_hash(168);
                        (*l_203) |= 0x141A13E0L;
                        step_hash(169);
                        if ((*p_60))
                            break;
                    }
                    step_hash(171);
                    ++g_340[1];
                    step_hash(177);
                    for (g_328 = (-11); (g_328 > 55); g_328++)
                    {
                        step_hash(175);
                        p_60 = &p_62;
                        step_hash(176);
                        (*l_303) = &p_62;
                    }
                    step_hash(184);
                    for (g_328 = 0; (g_328 <= 8); g_328 += 1)
                    {
                        int l_345 = (-1L);
                        int i;
                        step_hash(181);
                        if (l_345)
                            break;
                        step_hash(182);
                        (*l_306) &= (*g_292);
                        step_hash(183);
                        (*l_203) |= (0x999CL ^ g_328);
                    }
                }
                step_hash(202);
                if ((*l_194))
                {
                    unsigned l_350 = 6UL;
                    int l_353[4];
                    int *l_354 = (void*)0;
                    int i;
                    for (i = 0; i < 4; i++)
                        l_353[i] = 0xDEA73EE1L;
                    step_hash(187);
                    (*g_292) &= ((signed char)(l_348[4] != l_349) << (signed char)(+l_350));
                    step_hash(195);
                    for (g_225 = (-17); (g_225 > 0); g_225 += 2)
                    {
                        step_hash(191);
                        (*g_292) ^= l_353[0];
                        step_hash(192);
                        (**l_349) = &p_62;
                        step_hash(193);
                        p_60 = (*l_303);
                        step_hash(194);
                        if ((*p_60))
                            continue;
                    }
                    step_hash(196);
                    (*g_292) = (((void*)0 != l_354) ^ (p_62 || g_199));
                }
                else
                {
                    step_hash(198);
                    (*g_292) ^= (p_62 & g_2[3]);
                    step_hash(199);
                    g_355++;
                    step_hash(200);
                    (*l_203) = (g_199 > g_210);
                    step_hash(201);
                    (*l_201) = (-3L);
                }
            }
            step_hash(204);
            (*l_96) &= 0xF551BCBEL;
            step_hash(220);
            for (g_226 = 15; (g_226 == (-4)); g_226 -= 9)
            {
                int *l_360 = &l_206;
                step_hash(212);
                for (l_223 = 0; (l_223 <= 1); l_223 += 1)
                {
                    step_hash(211);
                    (**l_349) = l_360;
                }
                step_hash(213);
                for (l_209 = 0; l_209 < 8; l_209 += 1)
                {
                    for (g_339 = 0; g_339 < 3; g_339 += 1)
                    {
                        l_100[l_209][g_339] = 0x7FFDL;
                    }
                }
                step_hash(218);
                for (g_26 = 0; (g_26 == 18); g_26++)
                {
                    unsigned char l_363 = 255UL;
                    step_hash(217);
                    ++l_363;
                }
                step_hash(219);
                (*g_292) = (-(unsigned char)((signed char)((short)0L % (short)p_61) / (signed char)g_340[1]));
            }
        }
        else
        {
            int *l_385 = (void*)0;
            short l_394[7][3] = {{0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}, {0xAB95L, (-3L), (-6L)}};
            unsigned char l_408 = 0x2AL;
            int l_412[10][3] = {{0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}, {0x353F31BBL, 0x353F31BBL, 0x58FA1B2EL}};
            int i, j;
            step_hash(228);
            if ((g_193 != (void*)0))
            {
                int **l_386 = &l_96;
                int *l_391 = &l_234;
                int l_395 = (-9L);
                step_hash(223);
                (*l_391) = func_67((((unsigned)(((unsigned short)((unsigned short)((signed char)g_2[1] - (signed char)((((short)(((&p_60 == (void*)0) != ((signed char)((unsigned short)g_3 >> (unsigned short)7) >> (signed char)g_184[7])) > (*p_60)) << (short)2) | 0xEAL) ^ p_58)) + (unsigned short)(*l_194)) << (unsigned short)g_340[0]) > g_337[3][0]) - (unsigned)l_392) && 0x52L), l_393, &g_25, p_58);
                step_hash(224);
                (*l_303) = (*l_386);
                step_hash(225);
                --g_397;
            }
            else
            {
                step_hash(227);
                return g_184[7];
            }
            step_hash(277);
            for (g_397 = (-16); (g_397 == 37); g_397 += 7)
            {
                int l_409[3][9] = {{0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL, 0x21EED9EFL, 0x0EC9AAEDL, 0L, 0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL}, {0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL, 0x21EED9EFL, 0x0EC9AAEDL, 0L, 0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL}, {0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL, 0x21EED9EFL, 0x0EC9AAEDL, 0L, 0x0EC9AAEDL, 0x21EED9EFL, 0xB403FD4EL}};
                int l_416[8][8] = {{0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}, {0L, 7L, 0L, 0xE56BA82FL, 0xFF766F32L, 0xA9BD53F7L, 8L, 0L}};
                int i, j;
            }
            step_hash(278);
            p_60 = &p_62;
            step_hash(289);
            for (p_59 = 0; (p_59 <= 2); p_59 += 1)
            {
                unsigned char l_452 = 1UL;
                step_hash(282);
                if (l_451)
                    break;
                step_hash(283);
                --l_452;
                step_hash(288);
                for (l_163 = 0; (l_163 <= 2); l_163 += 1)
                {
                    int i, j;
                    step_hash(287);
                    (*l_194) ^= l_412[(l_163 + 5)][l_163];
                }
            }
        }
        step_hash(297);
        for (g_397 = 0; (g_397 <= 3); g_397 += 1)
        {
            int *l_455[1];
            int i;
            for (i = 0; i < 1; i++)
                l_455[i] = &l_208;
            step_hash(294);
            (**l_349) = &p_62;
            step_hash(295);
            (*l_303) = l_455[0];
            step_hash(296);
            return p_59;
        }
        step_hash(303);
        for (p_62 = 10; (p_62 < 17); p_62 += 2)
        {
            unsigned short l_460 = 0x08C2L;
            int **l_465 = &l_96;
            step_hash(301);
            (*l_393) = (0xDBL & (((short)l_460 * (short)(((unsigned char)((unsigned short)func_67(p_59, &g_3, l_465, p_58) << (unsigned short)9) * (unsigned char)l_466[1][6]) < ((p_58 < p_58) || g_244))) && p_61));
            step_hash(302);
            if ((**l_465))
                break;
        }
    }
    step_hash(305);
    l_467 = &p_62;
    step_hash(306);
    return p_61;
}







static int func_67(unsigned p_68, int * p_69, int ** p_70, unsigned char p_71)
{
    int l_72 = 0x689278A4L;
    unsigned l_78 = 0UL;
    step_hash(10);
    l_72 = (*g_25);
    step_hash(16);
    if ((**p_70))
    {
        unsigned char l_75[3];
        unsigned char l_79 = 0xA5L;
        int *l_90 = &g_26;
        int i;
        for (i = 0; i < 3; i++)
            l_75[i] = 0x81L;
        step_hash(12);
        (*l_90) ^= ((short)l_75[1] << (short)((((short)l_78 + (short)(l_79 == l_78)) >= p_71) | (((unsigned)(((((short)(&g_26 == (*p_70)) * (short)((signed char)((unsigned short)(p_71 > ((((((((signed char)g_2[0] << (signed char)0) & g_2[3]) > p_68) >= p_71) == l_75[2]) == g_2[1]) && 1L)) * (unsigned short)g_2[3]) + (signed char)l_75[0])) != l_72) ^ l_78) || (*p_69)) / (unsigned)(-1L)) >= p_68)));
        step_hash(13);
        return (*g_25);
    }
    else
    {
        step_hash(15);
        return (*p_69);
    }
}


void csmith_compute_hash(void)
{
    int i, j;
    for (i = 0; i < 5; i++)
    {
        transparent_crc(g_2[i], "g_2[i]", print_hash_value);
        if (print_hash_value) printf("index = [%d]\n", i);

    }
    transparent_crc(g_3, "g_3", print_hash_value);
    transparent_crc(g_26, "g_26", print_hash_value);
    transparent_crc(g_140, "g_140", print_hash_value);
    transparent_crc(g_154, "g_154", print_hash_value);
    for (i = 0; i < 9; i++)
    {
        transparent_crc(g_184[i], "g_184[i]", print_hash_value);
        if (print_hash_value) printf("index = [%d]\n", i);

    }
    transparent_crc(g_199, "g_199", print_hash_value);
    transparent_crc(g_210, "g_210", print_hash_value);
    transparent_crc(g_211, "g_211", print_hash_value);
    transparent_crc(g_225, "g_225", print_hash_value);
    transparent_crc(g_226, "g_226", print_hash_value);
    transparent_crc(g_228, "g_228", print_hash_value);
    transparent_crc(g_230, "g_230", print_hash_value);
    transparent_crc(g_232, "g_232", print_hash_value);
    transparent_crc(g_244, "g_244", print_hash_value);
    transparent_crc(g_249, "g_249", print_hash_value);
    transparent_crc(g_328, "g_328", print_hash_value);
    for (i = 0; i < 8; i++)
    {
        for (j = 0; j < 4; j++)
        {
            transparent_crc(g_337[i][j], "g_337[i][j]", print_hash_value);
            if (print_hash_value) printf("index = [%d][%d]\n", i, j);

        }
    }
    for (i = 0; i < 7; i++)
    {
        transparent_crc(g_338[i], "g_338[i]", print_hash_value);
        if (print_hash_value) printf("index = [%d]\n", i);

    }
    transparent_crc(g_339, "g_339", print_hash_value);
    for (i = 0; i < 2; i++)
    {
        transparent_crc(g_340[i], "g_340[i]", print_hash_value);
        if (print_hash_value) printf("index = [%d]\n", i);

    }
    transparent_crc(g_355, "g_355", print_hash_value);
    for (i = 0; i < 9; i++)
    {
        for (j = 0; j < 6; j++)
        {
            transparent_crc(g_396[i][j], "g_396[i][j]", print_hash_value);
            if (print_hash_value) printf("index = [%d][%d]\n", i, j);

        }
    }
    transparent_crc(g_397, "g_397", print_hash_value);
    transparent_crc(g_422, "g_422", print_hash_value);
    for (i = 0; i < 9; i++)
    {
        for (j = 0; j < 1; j++)
        {
            transparent_crc(g_423[i][j], "g_423[i][j]", print_hash_value);
            if (print_hash_value) printf("index = [%d][%d]\n", i, j);

        }
    }
    transparent_crc(g_429, "g_429", print_hash_value);
    transparent_crc(g_444, "g_444", print_hash_value);
    transparent_crc(g_503, "g_503", print_hash_value);
    transparent_crc(g_524, "g_524", print_hash_value);
    transparent_crc(g_534, "g_534", print_hash_value);
    transparent_crc(g_543, "g_543", print_hash_value);
    transparent_crc(g_545, "g_545", print_hash_value);
    transparent_crc(g_548, "g_548", print_hash_value);
    transparent_crc(g_577, "g_577", print_hash_value);
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 10; j++)
        {
            transparent_crc(g_594[i][j], "g_594[i][j]", print_hash_value);
            if (print_hash_value) printf("index = [%d][%d]\n", i, j);

        }
    }
    transparent_crc(g_595, "g_595", print_hash_value);
    for (i = 0; i < 9; i++)
    {
        for (j = 0; j < 1; j++)
        {
            transparent_crc(g_883[i][j], "g_883[i][j]", print_hash_value);
            if (print_hash_value) printf("index = [%d][%d]\n", i, j);

        }
    }
    for (i = 0; i < 8; i++)
    {
        transparent_crc(g_1024[i], "g_1024[i]", print_hash_value);
        if (print_hash_value) printf("index = [%d]\n", i);

    }
    transparent_crc(g_1083, "g_1083", print_hash_value);
    transparent_crc(g_1196, "g_1196", print_hash_value);
    transparent_crc(g_1451, "g_1451", print_hash_value);
    transparent_crc(g_1531, "g_1531", print_hash_value);
    transparent_crc(g_1534, "g_1534", print_hash_value);
    transparent_crc(g_1538, "g_1538", print_hash_value);
    transparent_crc(g_1543, "g_1543", print_hash_value);
    transparent_crc(g_1584, "g_1584", print_hash_value);
    transparent_crc(g_1649, "g_1649", print_hash_value);
    transparent_crc(g_1695, "g_1695", print_hash_value);
}

void step_hash(int stmt_id)
{
    int i = 0;
    csmith_compute_hash();
    printf("before stmt(%d): checksum = %X\n", stmt_id, crc32_context ^ 0xFFFFFFFFUL);
    crc32_context = 0xFFFFFFFFUL;
    for (i = 0; i < 256; i++) {
        crc32_tab[i] = 0;
    }
    crc32_gentab();
}



int main (void)
{
    int i, j;
    int print_hash_value = 0;
    platform_main_begin();
    crc32_gentab();
    func_1();
    csmith_compute_hash();
    platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
    return 0;
}