_challengeCost

ctfIndex

AlreadyClaimed

AlreadyClaimedEverything

CTFNotSolved

CTFsQuantityDecreased

HasNotRunOutOfTime

NotEnoughValueLocked

NotOwner

becomeEVMWizard

students

bornEVMWizards

challengeCost

claimed

commitment

lockedValue

timestamp

ctfs

ctfContract

weight

getAllCTFs

student

hasClaimedDeposit

isStudent

outOfTime

refund

_newOwner

transferOwnership

_ctfs

updateCTFs

updateChallengeCost

solvedCTFIndices

withdraw

withdrawOwner

{
    { }
    function abi_decode_tuple_t_uint256_fromMemory(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        value0 := mload(headStart)
    }
}

#utility.yul

{
    { }
    function abi_decode_tuple_t_uint256(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        value0 := calldataload(headStart)
    }
    function abi_encode_tuple_t_address_t_uint16__to_t_address_t_uint16__fromStack_reversed(headStart, value1, value0) -> tail
    {
        tail := add(headStart, 64)
        mstore(headStart, and(value0, sub(shl(160, 1), 1)))
        mstore(add(headStart, 32), and(value1, 0xffff))
    }
    function abi_encode_tuple_t_array$_t_struct$_CTF_$34_memory_ptr_$dyn_memory_ptr__to_t_array$_t_struct$_CTF_$34_memory_ptr_$dyn_memory_ptr__fromStack_reversed(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        let _2 := 64
        pos := add(headStart, _2)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            let _3 := mload(srcPtr)
            mstore(pos, and(mload(_3), sub(shl(160, 1), 1)))
            mstore(add(pos, _1), and(mload(add(_3, _1)), 0xffff))
            pos := add(pos, _2)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function abi_decode_address(offset) -> value
    {
        value := calldataload(offset)
        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
    }
    function abi_decode_tuple_t_address(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
    }
    function panic_error_0x41()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x41)
        revert(0, 0x24)
    }
    function allocate_memory_1622() -> memPtr
    {
        memPtr := mload(0x40)
        let newFreePtr := add(memPtr, 0x40)
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(0x40, newFreePtr)
    }
    function allocate_memory(size) -> memPtr
    {
        memPtr := mload(64)
        let newFreePtr := add(memPtr, and(add(size, 31), not(31)))
        if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
        mstore(64, newFreePtr)
    }
    function array_allocation_size_array_uint256_dyn(length) -> size
    {
        if gt(length, 0xffffffffffffffff) { panic_error_0x41() }
        size := add(shl(5, length), 0x20)
    }
    function abi_decode_tuple_t_addresst_array$_t_uint256_$dyn_memory_ptr(headStart, dataEnd) -> value0, value1
    {
        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        let _1 := 32
        let offset := calldataload(add(headStart, _1))
        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
        let _2 := add(headStart, offset)
        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
        let _3 := calldataload(_2)
        let dst := allocate_memory(array_allocation_size_array_uint256_dyn(_3))
        let dst_1 := dst
        mstore(dst, _3)
        dst := add(dst, _1)
        let srcEnd := add(add(_2, shl(5, _3)), _1)
        if gt(srcEnd, dataEnd) { revert(0, 0) }
        let src := add(_2, _1)
        for { } lt(src, srcEnd) { src := add(src, _1) }
        {
            mstore(dst, calldataload(src))
            dst := add(dst, _1)
        }
        value1 := dst_1
    }
    function abi_encode_tuple_t_bool__to_t_bool__fromStack_reversed(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, iszero(iszero(value0)))
    }
    function abi_decode_tuple_t_addresst_uint256(headStart, dataEnd) -> value0, value1
    {
        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := calldataload(add(headStart, 32))
    }
    function abi_encode_tuple_t_uint192_t_uint64__to_t_uint192_t_uint64__fromStack_reversed(headStart, value1, value0) -> tail
    {
        tail := add(headStart, 64)
        mstore(headStart, and(value0, sub(shl(192, 1), 1)))
        mstore(add(headStart, 32), and(value1, 0xffffffffffffffff))
    }
    function abi_encode_tuple_t_uint256__to_t_uint256__fromStack_reversed(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, value0)
    }
    function abi_decode_tuple_t_array$_t_address_$dyn_memory_ptr(headStart, dataEnd) -> value0
    {
        let _1 := 32
        if slt(sub(dataEnd, headStart), _1) { revert(0, 0) }
        let offset := calldataload(headStart)
        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
        let _2 := add(headStart, offset)
        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
        let _3 := calldataload(_2)
        let dst := allocate_memory(array_allocation_size_array_uint256_dyn(_3))
        let dst_1 := dst
        mstore(dst, _3)
        dst := add(dst, _1)
        let srcEnd := add(add(_2, shl(5, _3)), _1)
        if gt(srcEnd, dataEnd) { revert(0, 0) }
        let src := add(_2, _1)
        for { } lt(src, srcEnd) { src := add(src, _1) }
        {
            mstore(dst, abi_decode_address(src))
            dst := add(dst, _1)
        }
        value0 := dst_1
    }
    function abi_decode_tuple_t_array$_t_struct$_CTF_$34_memory_ptr_$dyn_memory_ptr(headStart, dataEnd) -> value0
    {
        let _1 := 32
        if slt(sub(dataEnd, headStart), _1) { revert(0, 0) }
        let offset := calldataload(headStart)
        if gt(offset, 0xffffffffffffffff) { revert(0, 0) }
        let _2 := add(headStart, offset)
        if iszero(slt(add(_2, 0x1f), dataEnd)) { revert(0, 0) }
        let _3 := calldataload(_2)
        let dst := allocate_memory(array_allocation_size_array_uint256_dyn(_3))
        let dst_1 := dst
        mstore(dst, _3)
        dst := add(dst, _1)
        let srcEnd := add(add(_2, shl(6, _3)), _1)
        if gt(srcEnd, dataEnd) { revert(0, 0) }
        let src := add(_2, _1)
        for { } lt(src, srcEnd) { src := add(src, 0x40) }
        {
            if slt(sub(dataEnd, src), 0x40)
            {
                let _4 := 0
                revert(_4, _4)
            }
            let value := allocate_memory_1622()
            mstore(value, abi_decode_address(src))
            let value_1 := calldataload(add(src, _1))
            if iszero(eq(value_1, and(value_1, 0xffff)))
            {
                let _5 := 0
                revert(_5, _5)
            }
            mstore(add(value, _1), value_1)
            mstore(dst, value)
            dst := add(dst, _1)
        }
        value0 := dst_1
    }
    function panic_error_0x11()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x11)
        revert(0, 0x24)
    }
    function checked_sub_t_uint256(x, y) -> diff
    {
        diff := sub(x, y)
        if gt(diff, x) { panic_error_0x11() }
    }
    function checked_sub_t_uint192(x, y) -> diff
    {
        let _1 := sub(shl(192, 1), 1)
        diff := sub(and(x, _1), and(y, _1))
        if gt(diff, _1) { panic_error_0x11() }
    }
    function checked_add_t_uint256(x, y) -> sum
    {
        sum := add(x, y)
        if gt(x, sum) { panic_error_0x11() }
    }
    function panic_error_0x32()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x32)
        revert(0, 0x24)
    }
    function increment_t_uint256(value) -> ret
    {
        if eq(value, not(0)) { panic_error_0x11() }
        ret := add(value, 1)
    }
    function abi_encode_tuple_t_address__to_t_address__fromStack_reversed(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, and(value0, sub(shl(160, 1), 1)))
    }
    function abi_decode_tuple_t_bool_fromMemory(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        let value := mload(headStart)
        if iszero(eq(value, iszero(iszero(value)))) { revert(0, 0) }
        value0 := value
    }
    function checked_mul_t_uint256(x, y) -> product
    {
        product := mul(x, y)
        if iszero(or(iszero(x), eq(y, div(product, x)))) { panic_error_0x11() }
    }
    function checked_div_t_uint256(x, y) -> r
    {
        if iszero(y)
        {
            mstore(0, shl(224, 0x4e487b71))
            mstore(4, 0x12)
            revert(0, 0x24)
        }
        r := div(x, y)
    }
    function abi_encode_tuple_t_address_t_uint256__to_t_address_t_uint256__fromStack_reversed(headStart, value1, value0) -> tail
    {
        tail := add(headStart, 64)
        mstore(headStart, and(value0, sub(shl(160, 1), 1)))
        mstore(add(headStart, 32), value1)
    }
    function abi_encode_tuple_t_stringliteral_87ec06ce2059ab3cf6fe4dd2fb1218712f1c693016c832faa431271492b69c3e__to_t_string_memory_ptr__fromStack_reversed(headStart) -> tail
    {
        mstore(headStart, 32)
        mstore(add(headStart, 32), 14)
        mstore(add(headStart, 64), "Payment failed")
        tail := add(headStart, 96)
    }
}

{
    { }
    function abi_decode_tuple_t_address(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        let value := calldataload(headStart)
        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
        value0 := value
    }
}

contract