# The census of manual_limits_O0: what `aa; pdd` renders for each function `afl` lists.
# Regenerate with `scripts/census.py golden` when `afl` moves, then bless.

NAME=afl
FILE=tests/fixtures/manual_limits_O0
CMDS=afl
EXPECT=<<EOF
0x100000548    5    144 sym._struct_nested_array
0x1000005d8   15    388 sym._out_param_parse
0x10000075c   11    200 sym._fnv_fold
0x100000824   21    284 sym._sparse_switch
0x100000940   26    352 sym._table_walk
0x100000aa0   64    684 sym._state_machine
0x100000d4c   11    160 sym._mem_scan2
0x100000dec   13    492 sym._main
0x100000fd8    1     12 sym.imp.memcpy
EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000548
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000548
EXPECT=<<EOF
uint32_t _struct_nested_array(void* arg0, uint32_t arg1, uint32_t arg2)
{
    uint64_t tmp_100000568_8_1;
    uint32_t tmp_100000578_8_1;
    uint16_t tmp_100000588_8_1;
    uint32_t tmp_100000598_8_1;
    uint32_t tmp_1000005a0_8_1;
    uint32_t tmp_1000005b4_8_1;
    uint16_t tmp_1000005bc_8_1;
    uint32_t stack_m4_1;

    /* r2dec proof: no individual construct is marked; 47 source obligations: 44 rendered, 3 elided, 0 refused; 13 statements rendered */
    {
        tmp_100000568_8_1 = (uint64_t)((uint64_t)((uint64_t)(int32_t)arg1 * (uint64_t)40U) + (uint64_t)arg0);
        tmp_100000578_8_1 = r2sleigh_load_u32((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)4U * 4U));
        r2sleigh_store_u32((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)4U * 4U), (uint32_t)((uint32_t)tmp_100000578_8_1 + (uint32_t)arg2));
        tmp_100000588_8_1 = r2sleigh_load_u16((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)2U * 2U));
        if ((uint8_t)((uint32_t)((uint32_t)((uint32_t)2U >= (uint32_t)32U ? (uint32_t)0U : (uint32_t)((uint32_t)((uint64_t)(uint16_t)tmp_100000588_8_1 >> 0U) >> (uint32_t)2U)) & (uint32_t)1U) == (uint32_t)0U)) {
            tmp_1000005b4_8_1 = r2sleigh_load_u32((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)2U * 4U));
            tmp_1000005bc_8_1 = r2sleigh_load_u16((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)3U * 2U));
            stack_m4_1 = (uint32_t)((uint32_t)tmp_1000005b4_8_1 - (uint32_t)((uint64_t)(uint16_t)tmp_1000005bc_8_1 >> 0U));
            return (uint32_t)stack_m4_1;
        } else {
            {
                tmp_100000598_8_1 = r2sleigh_load_u32((void*)((uint64_t)tmp_100000568_8_1 + (uint64_t)4U * 4U));
                tmp_1000005a0_8_1 = r2sleigh_load_u32((void*)tmp_100000568_8_1);
                stack_m4_1 = (uint32_t)((uint32_t)tmp_100000598_8_1 + (uint32_t)tmp_1000005a0_8_1);
                return (uint32_t)stack_m4_1;
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x1000005d8
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x1000005d8
EXPECT=<<EOF
struct fcn_1000005d8_arg1 {
    uint32_t f_0;
    uint8_t _pad_4[4];
    uint64_t f_8;
    uint64_t f_10;
    uint64_t f_18;
};

uint32_t _out_param_parse(uint8_t* arg0, struct fcn_1000005d8_arg1* arg1)
{
    uint8_t tmp_10000060c_8_1;
    uint64_t stack_m40_1;
    uint32_t stack_m20_1;
    uint64_t stack_m48_1;
    uint64_t stack_m40_2;
    uint64_t stack_m32_1;
    uint8_t tmp_10000063c_18_1;
    uint8_t tmp_10000065c_18_1;
    uint32_t stack_m52_1;
    uint8_t tmp_100000690_18_1;
    uint64_t stack_m32_3;
    uint8_t tmp_1000006a8_18_1;
    uint64_t stack_m48_4;
    uint8_t tmp_100000738_18_1;
    uint32_t stack_m56_1;

    /* r2dec proof: no individual construct is marked; 116 source obligations: 113 rendered, 3 elided, 0 refused; 33 statements rendered; 1 structure laid out from a parameter's accesses */
    {
        tmp_10000060c_8_1 = r2sleigh_load_u8((void*)(uint64_t)arg0);
        if ((uint8_t)((uint32_t)(int8_t)tmp_10000060c_8_1 != (uint32_t)45U)) {
            stack_m40_1 = 0;
            stack_m20_1 = 1;
        } else {
            {
                stack_m40_1 = 1;
                stack_m20_1 = (uint32_t)0xffffffffU;
            }
        }
        {
            stack_m48_1 = (uint64_t)0x14650fb0739d0383U;
            stack_m40_2 = stack_m40_1;
            stack_m32_1 = 0;
            for (; ; ) {
                tmp_10000063c_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_2 * 1U));
                if ((uint8_t)((int32_t)(int8_t)tmp_10000063c_18_1 < (int32_t)48U)) {
                    stack_m52_1 = 0;
                } else {
                    {
                        tmp_10000065c_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_2 * 1U));
                        stack_m52_1 = (uint32_t)((uint64_t)(uint8_t)((int32_t)(int8_t)tmp_10000065c_18_1 <= (int32_t)57U) >> 0U);
                    }
                }
                {
                    if ((uint8_t)((uint32_t)((uint32_t)stack_m52_1 & (uint32_t)1U) == (uint32_t)0U)) {
                        break;
                    } else {
                        {
                            tmp_100000690_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_2 * 1U));
                            stack_m32_3 = (uint64_t)((uint64_t)((uint64_t)stack_m32_1 * (uint64_t)10U) + (uint64_t)(int32_t)((uint32_t)(int8_t)tmp_100000690_18_1 - (uint32_t)48U));
                            tmp_1000006a8_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_2 * 1U));
                            stack_m48_4 = (uint64_t)((uint64_t)((uint64_t)(uint8_t)tmp_1000006a8_18_1 ^ (uint64_t)stack_m48_1) * (uint64_t)0x100000001b3U);
                            {
                                stack_m48_1 = stack_m48_4;
                                stack_m40_2 = (uint64_t)((uint64_t)stack_m40_2 + (uint64_t)1U);
                                stack_m32_1 = stack_m32_3;
                            }
                        }
                    }
                }
            }
            {
                r2sleigh_store_u32((void*)&arg1->f_0, (uint32_t)((uint64_t)((uint64_t)(int32_t)stack_m20_1 * (uint64_t)stack_m32_1) >> 0U));
                r2sleigh_store_u64((void*)&arg1->f_8, (uint64_t)stack_m48_1);
                r2sleigh_store_u64((void*)&arg1->f_18, (uint64_t)stack_m40_2);
                r2sleigh_store_u64((void*)&arg1->f_10, (uint64_t)0U);
                if ((uint8_t)((uint64_t)stack_m40_2 <= (uint64_t)0U)) {
                    stack_m56_1 = 0;
                } else {
                    {
                        tmp_100000738_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_2 * 1U));
                        stack_m56_1 = (uint32_t)((uint64_t)(uint8_t)((uint32_t)(int8_t)tmp_100000738_18_1 == (uint32_t)0U) >> 0U);
                    }
                }
                {
                    return (uint32_t)((uint32_t)stack_m56_1 & (uint32_t)1U);
                }
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x10000075c
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x10000075c
EXPECT=<<EOF
uint64_t _fnv_fold(uint8_t* arg0, uint64_t arg1)
{
    uint64_t stack_m32_1;
    uint64_t stack_m24_1;
    uint8_t tmp_1000007a4_8_1;
    uint8_t stack_m33_2;
    uint8_t stack_m33_1;
    uint64_t stack_m24_4;

    /* r2dec proof: no individual construct is marked; 60 source obligations: 57 rendered, 3 elided, 0 refused; 14 statements rendered */
    {
        stack_m32_1 = 0;
        stack_m24_1 = (uint64_t)0x14650fb0739d0383U;
        while ((uint8_t)((uint64_t)arg1 > (uint64_t)stack_m32_1)) {
            {
                tmp_1000007a4_8_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m32_1 * 1U));
                stack_m33_2 = tmp_1000007a4_8_1;
                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)stack_m33_2 >> 0U) < (int32_t)65U)) {
                    stack_m33_1 = stack_m33_2;
                } else {
                    {
                        if ((uint8_t)((int32_t)90U < (int32_t)((uint64_t)(uint8_t)stack_m33_2 >> 0U))) {
                            stack_m33_1 = stack_m33_2;
                        } else {
                            {
                                stack_m33_1 = (uint8_t)((uint32_t)((uint32_t)((uint64_t)(uint8_t)stack_m33_2 >> 0U) + (uint32_t)32U) >> 0U);
                            }
                        }
                    }
                }
                {
                    stack_m24_4 = (uint64_t)((uint64_t)((uint64_t)(uint8_t)stack_m33_1 ^ (uint64_t)stack_m24_1) * (uint64_t)0x100000001b3U);
                    {
                        stack_m32_1 = (uint64_t)((uint64_t)stack_m32_1 + (uint64_t)1U);
                        stack_m24_1 = stack_m24_4;
                    }
                }
            }
        }
        {
            return (uint64_t)stack_m24_1;
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000824
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000824
EXPECT=<<EOF
uint32_t _sparse_switch(uint32_t arg0, uint32_t arg1, uint32_t arg2)
{
    uint8_t tmp_100000900_4_1;
    uint32_t tmp_100000900_5_1;
    uint32_t tmp_100000900_9_1;
    uint32_t stack_m24_1;
    uint32_t stack_m4_1;

    /* r2dec proof: 1 construct is marked below; 64 source obligations: 59 rendered, 3 elided, 0 refused, 2 residual; 23 statements rendered */
    {
        if ((uint8_t)((uint32_t)((uint32_t)arg0 + (uint32_t)7U) == (uint32_t)0U)) {
            stack_m4_1 = (uint32_t)((uint32_t)arg1 - (uint32_t)arg2);
            return (uint32_t)stack_m4_1;
        } else {
            {
                if ((uint8_t)((uint32_t)arg0 == (uint32_t)0U)) {
                    stack_m4_1 = (uint32_t)((uint32_t)arg1 + (uint32_t)arg2);
                    return (uint32_t)stack_m4_1;
                } else {
                    {
                        if ((uint8_t)((uint32_t)arg0 == (uint32_t)3U)) {
                            stack_m4_1 = (uint32_t)((uint32_t)((uint32_t)arg1 * (uint32_t)3U) + (uint32_t)arg2);
                            return (uint32_t)stack_m4_1;
                        } else {
                            {
                                if ((uint8_t)((uint32_t)arg0 == (uint32_t)42U)) {
                                    stack_m4_1 = (uint32_t)((uint32_t)((uint32_t)arg1 ^ (uint32_t)arg2) + (uint32_t)42U);
                                    return (uint32_t)stack_m4_1;
                                } else {
                                    {
                                        if ((uint8_t)((uint32_t)arg0 == (uint32_t)0x3e8U)) {
                                            if ((uint8_t)((uint32_t)arg2 != (uint32_t)0U)) {
                                                tmp_100000900_4_1 = (uint8_t)((uint32_t)arg2 == (uint32_t)0U);
                                                tmp_100000900_5_1 = tmp_100000900_4_1 ? (uint32_t)1U : (uint32_t)arg2;
                                                tmp_100000900_9_1 = (uint32_t)arg1 == (uint32_t)0x80000000U && (uint32_t)tmp_100000900_5_1 == (uint32_t)0xffffffffU ? r2sleigh_residual_u32(1) : (uint32_t)((int32_t)arg1 / (int32_t)tmp_100000900_5_1);
                                                stack_m24_1 = tmp_100000900_4_1 ? (uint32_t)0U : (uint32_t)tmp_100000900_9_1;
                                            } else {
                                                {
                                                    stack_m24_1 = (uint32_t)0xffffffffU;
                                                }
                                            }
                                            {
                                                stack_m4_1 = stack_m24_1;
                                                return (uint32_t)stack_m4_1;
                                            }
                                        } else {
                                            {
                                                stack_m4_1 = (uint32_t)((uint32_t)((uint32_t)arg0 + (uint32_t)arg1) - (uint32_t)arg2);
                                                return (uint32_t)stack_m4_1;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000940
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000940
EXPECT=<<EOF
uint32_t _table_walk(uint64_t arg0, uint8_t* arg1)
{
    uint64_t stack_m40_1;
    uint32_t stack_m28_1;
    uint32_t stack_m28_3;
    uint64_t x8_6;
    uint16_t tmp_100000988_8_1;
    uint64_t stack_m48_1;
    uint16_t tmp_1000009a8_8_1;
    uint8_t tmp_1000009cc_18_1;
    uint64_t x8_15;
    uint8_t tmp_1000009ec_18_1;
    uint8_t tmp_1000009f8_18_1;
    uint32_t stack_m52_1;
    uint16_t tmp_100000a30_8_1;
    uint8_t tmp_100000a48_18_1;
    uint32_t tmp_100000a58_8_1;
    uint64_t x8_30;
    uint32_t stack_m4_1;

    /* r2dec proof: no individual construct is marked; 120 source obligations: 117 rendered, 3 elided, 0 refused; 37 statements rendered */
    {
        stack_m40_1 = arg0;
        stack_m28_1 = 0;
        for (; ; ) {
            if ((uint8_t)((uint64_t)stack_m40_1 == (uint64_t)0U)) {
                stack_m4_1 = (uint32_t)((uint32_t)0U - (uint32_t)stack_m28_1);
                return (uint32_t)stack_m4_1;
            } else {
                {
                    stack_m28_3 = (uint32_t)((uint32_t)stack_m28_1 + (uint32_t)1U);
                    x8_6 = r2sleigh_load_u64((void*)((uint64_t)stack_m40_1 + (uint64_t)3U * 8U));
                    if ((uint8_t)((uint64_t)x8_6 == (uint64_t)0U)) {
                        {
                        }
                    } else {
                        {
                            tmp_100000988_8_1 = r2sleigh_load_u16((void*)((uint64_t)stack_m40_1 + (uint64_t)3U * 2U));
                            if ((uint8_t)((uint32_t)((uint64_t)(uint16_t)tmp_100000988_8_1 >> 0U) != (uint32_t)0U)) {
                                stack_m48_1 = 0;
                                for (; ; ) {
                                    tmp_1000009a8_8_1 = r2sleigh_load_u16((void*)((uint64_t)stack_m40_1 + (uint64_t)3U * 2U));
                                    if ((uint8_t)((uint64_t)(uint16_t)tmp_1000009a8_8_1 <= (uint64_t)stack_m48_1)) {
                                        stack_m52_1 = 0;
                                    } else {
                                        {
                                            tmp_1000009cc_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg1 + (uint64_t)stack_m48_1 * 1U));
                                            if ((uint8_t)((uint32_t)(int8_t)tmp_1000009cc_18_1 == (uint32_t)0U)) {
                                                stack_m52_1 = 0;
                                            } else {
                                                {
                                                    x8_15 = r2sleigh_load_u64((void*)((uint64_t)stack_m40_1 + (uint64_t)3U * 8U));
                                                    tmp_1000009ec_18_1 = r2sleigh_load_u8((void*)(uint64_t)((uint64_t)x8_15 + (uint64_t)stack_m48_1));
                                                    tmp_1000009f8_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg1 + (uint64_t)stack_m48_1 * 1U));
                                                    stack_m52_1 = (uint32_t)((uint64_t)(uint8_t)((uint32_t)(int8_t)tmp_1000009ec_18_1 == (uint32_t)(int8_t)tmp_1000009f8_18_1) >> 0U);
                                                }
                                            }
                                        }
                                    }
                                    {
                                        if ((uint8_t)((uint32_t)((uint32_t)stack_m52_1 & (uint32_t)1U) == (uint32_t)0U)) {
                                            break;
                                        } else {
                                            {
                                                stack_m48_1 = (uint64_t)((uint64_t)stack_m48_1 + (uint64_t)1U);
                                            }
                                        }
                                    }
                                }
                                {
                                    tmp_100000a30_8_1 = r2sleigh_load_u16((void*)((uint64_t)stack_m40_1 + (uint64_t)3U * 2U));
                                    if ((uint8_t)((uint64_t)(uint16_t)tmp_100000a30_8_1 != (uint64_t)stack_m48_1)) {
                                    } else {
                                        {
                                            tmp_100000a48_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg1 + (uint64_t)stack_m48_1 * 1U));
                                            if ((uint8_t)((uint32_t)(int8_t)tmp_100000a48_18_1 != (uint32_t)0U)) {
                                            } else {
                                                break;
                                            }
                                        }
                                    }
                                    {
                                    }
                                }
                            } else {
                                {
                                }
                            }
                        }
                    }
                    {
                        x8_30 = r2sleigh_load_u64((void*)((uint64_t)stack_m40_1 + (uint64_t)4U * 8U));
                        stack_m40_1 = x8_30;
                        stack_m28_1 = stack_m28_3;
                    }
                }
            }
        }
        {
            {
                tmp_100000a58_8_1 = r2sleigh_load_u32((void*)stack_m40_1);
                stack_m4_1 = (uint32_t)((uint32_t)tmp_100000a58_8_1 + (uint32_t)stack_m28_3);
                return (uint32_t)stack_m4_1;
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000aa0
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000aa0
EXPECT=<<EOF
uint32_t _state_machine(uint8_t* arg0)
{
    uint64_t stack_m32_1;
    uint32_t stack_m24_1;
    uint32_t stack_m20_1;
    uint8_t tmp_100000ac0_18_1;
    uint8_t tmp_100000ad8_8_1;
    uint32_t stack_m20_5;
    uint32_t stack_m20_6;
    uint32_t stack_m24_3;
    uint32_t stack_m20_3;
    uint32_t stack_m24_4;
    uint32_t stack_m20_4;
    uint32_t stack_m24_9;
    uint32_t stack_m24_2;
    uint32_t stack_m20_2;
    uint32_t stack_m24_5;
    uint32_t stack_m20_7;
    uint32_t stack_m4_1;

    /* r2dec proof: no individual construct is marked; 216 source obligations: 213 rendered, 3 elided, 0 refused; 77 statements rendered */
    {
        stack_m32_1 = 0;
        stack_m24_1 = 0;
        stack_m20_1 = 0;
        for (; ; ) {
            tmp_100000ac0_18_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m32_1 * 1U));
            if ((uint8_t)((uint32_t)(int8_t)tmp_100000ac0_18_1 == (uint32_t)0U)) {
                stack_m4_1 = (uint32_t)((uint32_t)stack_m24_1 + (uint32_t)stack_m20_1);
                return (uint32_t)stack_m4_1;
            } else {
                {
                    tmp_100000ad8_8_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m32_1 * 1U));
                    if ((uint8_t)((uint32_t)stack_m20_1 == (uint32_t)0U)) {
                        if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) < (int32_t)97U)) {
                        } else {
                            {
                                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) <= (int32_t)122U)) {
                                    goto L1;
                                } else {
                                }
                            }
                        }
                        {
                            if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) != (uint32_t)95U)) {
                                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) < (int32_t)48U)) {
                                    stack_m4_1 = (uint32_t)((uint32_t)0xffffff9cU - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                                    return (uint32_t)stack_m4_1;
                                } else {
                                    {
                                        if ((uint8_t)((int32_t)57U < (int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U))) {
                                            stack_m4_1 = (uint32_t)((uint32_t)0xffffff9cU - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                                            return (uint32_t)stack_m4_1;
                                        } else {
                                            {
                                                stack_m24_9 = (uint32_t)((uint32_t)stack_m24_1 - (uint32_t)5U);
                                                {
                                                    stack_m24_2 = stack_m24_9;
                                                    stack_m20_2 = 2;
                                                    goto L3;
                                                }
                                            }
                                        }
                                    }
                                }
                            } else {
                            }
                        }
                        {
L1: ;
                            stack_m24_2 = (uint32_t)((uint32_t)stack_m24_1 + (uint32_t)3U);
                            stack_m20_2 = 1;
                        }
                        {
L3: ;
                            stack_m24_5 = stack_m24_2;
                            stack_m20_7 = stack_m20_2;
                        }
                    } else {
                        {
                            if ((uint8_t)((uint32_t)stack_m20_1 == (uint32_t)1U)) {
                                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) < (int32_t)48U)) {
                                } else {
                                    {
                                        if ((uint8_t)((int32_t)57U < (int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U))) {
                                        } else {
                                            {
                                                stack_m24_4 = (uint32_t)((uint32_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) + (uint32_t)stack_m24_1) - (uint32_t)48U);
                                                stack_m20_4 = 2;
                                                goto L9;
                                            }
                                        }
                                    }
                                }
                                {
                                    if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) != (uint32_t)45U)) {
                                        if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) < (int32_t)97U)) {
                                        } else {
                                            {
                                                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) <= (int32_t)122U)) {
                                                    goto L7;
                                                } else {
                                                }
                                            }
                                        }
                                        {
                                            if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) == (uint32_t)95U)) {
                                            } else {
                                                stack_m4_1 = (uint32_t)((uint32_t)0xffffff38U - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                                                return (uint32_t)stack_m4_1;
                                            }
                                        }
                                        {
L7: ;
                                            stack_m24_3 = stack_m24_1;
                                            stack_m20_3 = stack_m20_1;
                                        }
                                    } else {
                                        {
                                            stack_m24_3 = (uint32_t)((uint32_t)stack_m24_1 + (uint32_t)7U);
                                            stack_m20_3 = 3;
                                        }
                                    }
                                    {
                                        stack_m24_4 = stack_m24_3;
                                        stack_m20_4 = stack_m20_3;
                                    }
                                }
                                {
L9: ;
                                    stack_m24_5 = stack_m24_4;
                                    stack_m20_7 = stack_m20_4;
                                }
                            } else {
                                {
                                    if ((uint8_t)((uint32_t)stack_m20_1 == (uint32_t)2U)) {
                                        if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) != (uint32_t)95U)) {
                                            if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) != (uint32_t)45U)) {
                                                if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) < (int32_t)48U)) {
                                                    stack_m4_1 = (uint32_t)((uint32_t)0xfffffed4U - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                                                    return (uint32_t)stack_m4_1;
                                                } else {
                                                    {
                                                        if ((uint8_t)((int32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) <= (int32_t)57U)) {
                                                            stack_m20_5 = stack_m20_1;
                                                        } else {
                                                            stack_m4_1 = (uint32_t)((uint32_t)0xfffffed4U - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                                                            return (uint32_t)stack_m4_1;
                                                        }
                                                    }
                                                }
                                            } else {
                                                {
                                                    stack_m20_5 = 3;
                                                }
                                            }
                                            {
                                                stack_m20_6 = stack_m20_5;
                                            }
                                        } else {
                                            {
                                                stack_m20_6 = 1;
                                            }
                                        }
                                        {
                                            stack_m24_5 = stack_m24_1;
                                            stack_m20_7 = stack_m20_6;
                                        }
                                    } else {
                                        {
                                            if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)tmp_100000ad8_8_1 >> 0U) == (uint32_t)120U)) {
                                                stack_m24_5 = stack_m24_1;
                                                stack_m20_7 = 0;
                                            } else {
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    {
                        {
                            stack_m32_1 = (uint64_t)((uint64_t)stack_m32_1 + (uint64_t)1U);
                            stack_m24_1 = stack_m24_5;
                            stack_m20_1 = stack_m20_7;
                        }
                    }
                }
            }
        }
        {
            {
                stack_m4_1 = (uint32_t)((uint32_t)0xfffffe70U - (uint32_t)((uint64_t)stack_m32_1 >> 0U));
                return (uint32_t)stack_m4_1;
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000d4c
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000d4c
EXPECT=<<EOF
uint64_t _mem_scan2(uint8_t* arg0, uint64_t arg1, uint8_t arg2, uint8_t arg3)
{
    uint64_t stack_m40_1;
    uint64_t stack_m32_1;
    uint8_t tmp_100000d8c_8_1;
    uint64_t stack_m32_2;

    /* r2dec proof: no individual construct is marked; 49 source obligations: 46 rendered, 3 elided, 0 refused; 12 statements rendered */
    {
        stack_m40_1 = 0;
        stack_m32_1 = 0;
        while ((uint8_t)((uint64_t)arg1 > (uint64_t)stack_m40_1)) {
            {
                tmp_100000d8c_8_1 = r2sleigh_load_u8((void*)((uint64_t)arg0 + (uint64_t)stack_m40_1 * 1U));
                if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)arg2 >> 0U) == (uint32_t)((uint64_t)(uint8_t)tmp_100000d8c_8_1 >> 0U))) {
                    {
                        stack_m32_2 = (uint64_t)((uint64_t)stack_m32_1 + (uint64_t)1U);
                    }
                } else {
                    {
                        if ((uint8_t)((uint32_t)((uint64_t)(uint8_t)arg3 >> 0U) != (uint32_t)((uint64_t)(uint8_t)tmp_100000d8c_8_1 >> 0U))) {
                            stack_m32_2 = stack_m32_1;
                        } else {
                            {
                                stack_m32_2 = (uint64_t)((uint64_t)stack_m32_1 + (uint64_t)1U);
                            }
                        }
                    }
                }
                {
                    {
                        stack_m40_1 = (uint64_t)((uint64_t)stack_m40_1 + (uint64_t)1U);
                        stack_m32_1 = stack_m32_2;
                    }
                }
            }
        }
        {
            return (uint64_t)stack_m32_1;
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000dec
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000dec
EXPECT=<<EOF
struct r2sleigh_bits_256 {
    uint8_t bytes[32];
};

static inline __uint128_t r2sleigh_bits_extract_256_128(struct r2sleigh_bits_256 carrier, uint64_t at)
{
    __uint128_t field = 0;
    for (uint32_t bit = 0; bit < 128u; ++bit) {
        const uint64_t from = at + bit;
        if (from < 256u && ((carrier.bytes[from / 8] >> (from % 8)) & 1) != 0) {
            field = (__uint128_t)(field | ((__uint128_t)1 << bit));
        }
    }
    return field;
}

static inline struct r2sleigh_bits_256 r2sleigh_bits_insert_256_64(struct r2sleigh_bits_256 carrier, uint64_t field, uint64_t at)
{
    for (uint32_t bit = 0; bit < 64u; ++bit) {
        const uint64_t to = at + bit;
        if (to < 256u) {
            const unsigned mask = 1u << (to % 8);
            if (((field >> bit) & 1) != 0) {
                carrier.bytes[to / 8] = (uint8_t)(carrier.bytes[to / 8] | mask);
            } else {
                carrier.bytes[to / 8] = (uint8_t)(carrier.bytes[to / 8] & ~mask);
            }
        }
    }
    return carrier;
}

static inline struct r2sleigh_bits_256 r2sleigh_bits_zero_extend_64_256(uint64_t field)
{
    struct r2sleigh_bits_256 carrier = {{0}};
    for (uint32_t bit = 0; bit < 64u; ++bit) {
        if (((field >> bit) & 1) != 0) {
            carrier.bytes[bit / 8] = (uint8_t)(carrier.bytes[bit / 8] | (1u << (bit % 8)));
        }
    }
    return carrier;
}

uint64_t _main(uint32_t arg0, uint64_t* arg1)
{
    uint64_t _fnv_fold(uint64_t, uint64_t);
    uint64_t _mem_scan2(uint64_t, uint64_t, uint8_t, uint8_t);
    uint32_t _out_param_parse(uint64_t, uint64_t);
    uint32_t _sparse_switch(uint32_t, uint32_t, uint32_t);
    uint32_t _state_machine(uint64_t);
    uint32_t _struct_nested_array(uint64_t, uint32_t, uint32_t);
    uint32_t _table_walk(uint64_t, uint64_t);
    void* memcpy(void*, const void*, uint64_t);
    extern char _manual_sink[];

    uint64_t x0_3;
    struct r2sleigh_bits_256 z0_2;
    struct r2sleigh_bits_256 z0_3;
    uint32_t tmp_100000e34_8_1;
    uint32_t tmp_100000e3c_8_1;
    uint64_t x2_3;
    uint64_t x0_4;
    uint32_t tmp_100000e4c_8_1;
    uint32_t tmp_100000e58_8_1;
    uint64_t x8_9;
    uint64_t x0_6;
    uint32_t tmp_100000ea0_8_1;
    uint64_t x0_9;
    uint64_t x8_18;
    uint32_t tmp_100000ec4_8_1;
    uint32_t tmp_100000ed0_8_1;
    uint32_t tmp_100000ed4_8_1;
    uint64_t x8_19;
    uint64_t x0_11;
    uint64_t x9_12;
    uint32_t tmp_100000ee8_8_1;
    uint32_t tmp_100000ef4_8_1;
    uint64_t x8_25;
    uint64_t x1_8;
    uint64_t x0_13;
    uint32_t tmp_100000f38_8_1;
    uint32_t tmp_100000f44_8_1;
    uint64_t x8_35;
    uint64_t x0_15;
    uint32_t tmp_100000f88_8_1;
    uint64_t x0_18;
    uint64_t x8_44;
    uint32_t tmp_100000fb4_8_1;
    uint32_t tmp_100000fc0_8_1;
    _Alignas(16) uint8_t frame[192];

    /* r2dec proof: no individual construct is marked; 229 source obligations: 178 rendered, 35 elided, 0 refused, 16 assumed (frame extent unproven); 61 statements rendered; 1 data object type refused; 1 callee prototype supplied by the source */
    {
        r2sleigh_store_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)124U), (uint32_t)0U);
        r2sleigh_store_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U), (uint32_t)arg0);
        r2sleigh_store_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)112U), (uint64_t)arg1);
        r2sleigh_store_u64((void*)(uint64_t)(frame + 40U), (uint64_t)((uint64_t)(frame + 48U) + (uint64_t)32U));
        memcpy((void*)(uint64_t)((uint64_t)(frame + 48U) + (uint64_t)32U), (const void*)(uint64_t)0x100004008U, 80);
        x0_3 = r2sleigh_load_u64((void*)(uint64_t)(frame + 40U));
        z0_2 = r2sleigh_bits_insert_256_64(r2sleigh_bits_zero_extend_64_256((uint64_t)0U), (uint64_t)0U, 0U);
        z0_3 = r2sleigh_bits_insert_256_64(z0_2, (uint64_t)0U, 64U);
        r2sleigh_store_u128((void*)(uint64_t)(frame + 48U), (__uint128_t)r2sleigh_bits_extract_256_128(z0_3, 0U));
        r2sleigh_store_u128((void*)(uint64_t)((uint64_t)(frame + 48U) + (uint64_t)16U), (__uint128_t)r2sleigh_bits_extract_256_128(z0_3, 0U));
        r2sleigh_store_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)64U), (uint64_t)((uint64_t)x0_3 + (uint64_t)40U));
        tmp_100000e34_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
        tmp_100000e3c_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
        x2_3 = (uint64_t)(uint32_t)tmp_100000e3c_8_1;
        x0_4 = (uint64_t)_struct_nested_array(x0_3, (uint32_t)((uint32_t)tmp_100000e34_8_1 & (uint32_t)1U), (uint32_t)x2_3);
        tmp_100000e4c_8_1 = r2sleigh_load_u32((void*)&_manual_sink);
        r2sleigh_store_u32((void*)&_manual_sink, (uint32_t)((uint32_t)((uint64_t)x0_4 >> 0U) + (uint32_t)tmp_100000e4c_8_1));
        tmp_100000e58_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
        if ((uint8_t)((int32_t)tmp_100000e58_8_1 <= (int32_t)1U)) {
            r2sleigh_store_u64((void*)(uint64_t)(frame + 32U), (uint64_t)0x100000fecU);
        } else {
            {
                x8_9 = r2sleigh_load_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)112U));
                r2sleigh_store_u64((void*)(uint64_t)(frame + 32U), (uint64_t)r2sleigh_load_u64((void*)((uint64_t)x8_9 + (uint64_t)1U * 8U)));
            }
        }
        {
            x0_6 = (uint64_t)_out_param_parse(r2sleigh_load_u64((void*)(uint64_t)(frame + 32U)), (uint64_t)(frame + 48U));
            r2sleigh_store_u64((void*)(uint64_t)(frame + 24U), (uint64_t)0x100008000U);
            tmp_100000ea0_8_1 = r2sleigh_load_u32((void*)&_manual_sink);
            r2sleigh_store_u32((void*)&_manual_sink, (uint32_t)((uint32_t)((uint64_t)x0_6 >> 0U) + (uint32_t)tmp_100000ea0_8_1));
            x0_9 = _fnv_fold((uint64_t)0x100000ff0U, 3);
            x8_18 = r2sleigh_load_u64((void*)(uint64_t)(frame + 24U));
            tmp_100000ec4_8_1 = r2sleigh_load_u32((void*)x8_18);
            r2sleigh_store_u32((void*)x8_18, (uint32_t)((uint32_t)((uint64_t)x0_9 >> 0U) + (uint32_t)tmp_100000ec4_8_1));
            tmp_100000ed0_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
            tmp_100000ed4_8_1 = r2sleigh_load_u32((void*)x8_18);
            x8_19 = r2sleigh_load_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)24U));
            x0_11 = (uint64_t)_sparse_switch((uint32_t)tmp_100000ed0_8_1, (uint32_t)tmp_100000ed4_8_1, (uint32_t)x8_19);
            x9_12 = r2sleigh_load_u64((void*)(uint64_t)(frame + 24U));
            tmp_100000ee8_8_1 = r2sleigh_load_u32((void*)x9_12);
            r2sleigh_store_u32((void*)x9_12, (uint32_t)((uint32_t)((uint64_t)x0_11 >> 0U) + (uint32_t)tmp_100000ee8_8_1));
            tmp_100000ef4_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
            if ((uint8_t)((int32_t)tmp_100000ef4_8_1 <= (int32_t)2U)) {
                r2sleigh_store_u64((void*)(uint64_t)(frame + 16U), (uint64_t)0x100000fe8U);
            } else {
                {
                    x8_25 = r2sleigh_load_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)112U));
                    r2sleigh_store_u64((void*)(uint64_t)(frame + 16U), (uint64_t)r2sleigh_load_u64((void*)((uint64_t)x8_25 + (uint64_t)2U * 8U)));
                }
            }
            {
                x1_8 = r2sleigh_load_u64((void*)(uint64_t)(frame + 16U));
                x0_13 = (uint64_t)_table_walk((uint64_t)((uint64_t)(frame + 48U) + (uint64_t)32U), x1_8);
                tmp_100000f38_8_1 = r2sleigh_load_u32((void*)&_manual_sink);
                r2sleigh_store_u32((void*)&_manual_sink, (uint32_t)((uint32_t)((uint64_t)x0_13 >> 0U) + (uint32_t)tmp_100000f38_8_1));
                tmp_100000f44_8_1 = r2sleigh_load_u32((void*)((uint64_t)(frame + 48U) + (uint64_t)120U));
                if ((uint8_t)((int32_t)tmp_100000f44_8_1 <= (int32_t)3U)) {
                    r2sleigh_store_u64((void*)(uint64_t)(frame + 8U), (uint64_t)0x100000ff4U);
                } else {
                    {
                        x8_35 = r2sleigh_load_u64((void*)((uint64_t)(frame + 48U) + (uint64_t)112U));
                        r2sleigh_store_u64((void*)(uint64_t)(frame + 8U), (uint64_t)r2sleigh_load_u64((void*)((uint64_t)x8_35 + (uint64_t)3U * 8U)));
                    }
                }
                {
                    x0_15 = (uint64_t)_state_machine(r2sleigh_load_u64((void*)(uint64_t)(frame + 8U)));
                    r2sleigh_store_u64((void*)(uint64_t)(frame + 0U), (uint64_t)0x100008000U);
                    tmp_100000f88_8_1 = r2sleigh_load_u32((void*)&_manual_sink);
                    r2sleigh_store_u32((void*)&_manual_sink, (uint32_t)((uint32_t)((uint64_t)x0_15 >> 0U) + (uint32_t)tmp_100000f88_8_1));
                    x0_18 = _mem_scan2((uint64_t)0x100000ffbU, 6, 97, 122);
                    x8_44 = r2sleigh_load_u64((void*)(uint64_t)(frame + 0U));
                    tmp_100000fb4_8_1 = r2sleigh_load_u32((void*)x8_44);
                    r2sleigh_store_u32((void*)x8_44, (uint32_t)((uint32_t)((uint64_t)x0_18 >> 0U) + (uint32_t)tmp_100000fb4_8_1));
                    tmp_100000fc0_8_1 = r2sleigh_load_u32((void*)x8_44);
                    return (uint64_t)(uint8_t)((uint32_t)tmp_100000fc0_8_1 == (uint32_t)0U);
                }
            }
        }
    }
}

EOF
EXPECT_ERR=<<EOF
EOF
RUN

NAME=0x100000fd8
FILE=tests/fixtures/manual_limits_O0
CMDS=aa; pdd @ 0x100000fd8
EXPECT=<<EOF
/* r2sleigh: import stub at 0x100000fd8; this symbol is the import `memcpy` and has no body of its own. */
extern void* memcpy(void*, const void*, uint64_t);

EOF
EXPECT_ERR=<<EOF
EOF
RUN
