Seaport duplicated IR functions

aggregateAvailable.sol

/**
 * @dev First function is for OfferItems, second function is for ConsiderationItems.
 *      The intial revert check could be factored out as a function to take the Side as a param.
 */
function fun_aggregateAvailable(var_advancedOrders_mpos, var_fulfillmentComponents_mpos, var_recipient) -> var_execution_mpos
{
    var_execution_mpos :=  allocate_and_zero_memory_struct_struct_Execution()
    if  iszero( mload( var_fulfillmentComponents_mpos))
    {
        mstore( 0x00,  928785601)
        mstore(32,  0x00)
        revert(28, 36)
    }
    mstore( add( mload(var_execution_mpos),  128),  and( var_recipient,  0xffffffffffffffffffffffffffffffffffffffff))
    fun_aggregateValidFulfillmentOfferItems(var_advancedOrders_mpos, var_fulfillmentComponents_mpos, var_execution_mpos)
    let _1 := mload(var_execution_mpos)
    if  iszero( mload( add( _1,  96)))
    {
        mstore( add(var_execution_mpos, 32),  0x00)
        mstore( add( _1,  128),  0x00)
    }
}
function fun_aggregateAvailable_22784(var_advancedOrders_mpos, var_fulfillmentComponents_mpos, var_fulfillerConduitKey) -> var_execution_mpos
{
    var_execution_mpos :=  allocate_and_zero_memory_struct_struct_Execution()
    if  iszero( mload( var_fulfillmentComponents_mpos))
    {
        mstore( 0,  928785601)
        mstore(32,  1)
        revert(28, 36)
    }
    fun_aggregateValidFulfillmentConsiderationItems(var_advancedOrders_mpos, var_fulfillmentComponents_mpos, var_execution_mpos)
    let _1 := add(var_execution_mpos, 32)
    mstore(_1,  caller())
    mstore( add(var_execution_mpos, 64),  var_fulfillerConduitKey)
    let _2 := mload(var_execution_mpos)
    if  iszero( mload( add( _2,  96)))
    {
        mstore(_1,  0)
        mstore( add( _2,  128),  0)
    }
}

applyFraction.sol

/**
 * @dev Only difference is which function is called to get the fraction - fun_locateCurrentAmount_22544 or fun_locateCurrentAmount
 *      Depending on where this is called - could store var on the stack to switch on within the case 0 switch to call the correct function
 *
 *      22576: round up
 *      og: round down
 */
function fun_applyFraction_22576(var_startAmount, var_endAmount, var_numerator, var_denominator, var_startTime, var_endTime) -> var_amount
{
    switch  eq(var_startAmount, var_endAmount)
    case  0 {
        let expr := fun_getFraction(var_numerator, var_denominator, var_startAmount)
        var_amount :=  fun_locateCurrentAmount_22544(expr,  fun_getFraction(var_numerator, var_denominator, var_endAmount),  var_startTime, var_endTime)
    }
    default 
    {
        var_amount :=  fun_getFraction(var_numerator, var_denominator, var_endAmount)
    }
}
function fun_applyFraction(var_startAmount, var_endAmount, var_numerator, var_denominator, var_startTime, var_endTime) -> var_amount
{
    switch  eq(var_startAmount, var_endAmount)
    case  0 {
        let expr := fun_getFraction(var_numerator, var_denominator, var_startAmount)
        var_amount :=  fun_locateCurrentAmount(expr,  fun_getFraction(var_numerator, var_denominator, var_endAmount),  var_startTime, var_endTime)
    }
    default 
    {
        var_amount :=  fun_getFraction(var_numerator, var_denominator, var_endAmount)
    }
}

callAndCheckStatus.sol

/**
 * @dev Only similarity is the first five lines - up to and including fun_revertWithReasonIfOneIsReturned() - but each takes different arguments
 *      Likely reverting vs non-reverting.
 */
function fun_callAndCheckStatus_22623(var_target, var_orderHash, var_callData_mpos)
{
    let _1 := mload( var_callData_mpos)
    mstore( 0, 0)
    if  iszero( call(gas(), var_target,  0,  add(var_callData_mpos, 32),  _1,  0,  32))
    {
        fun_revertWithReasonIfOneIsReturned()
        dispatch_internal_in_out_39753(var_orderHash)
    }
    if  iszero(eq( and( mload( 0),  shl(224,  0xffffffff)),  shl(225, 0x0bd8fca1)))
    {
        dispatch_internal_in_out_39753(var_orderHash)
    }
}
function fun_callAndCheckStatus(var_target, var_orderHash, var_callData_mpos, var_magicValue, var_errorHandler_functionIdentifier)
{
    let _1 := mload( var_callData_mpos)
    mstore( 0, 0)
    if  iszero( call(gas(), var_target,  0,  add(var_callData_mpos, 32),  _1,  0,  32))
    {
        fun_revertWithReasonIfOneIsReturned()
        dispatch_internal_in_out_0(var_errorHandler_functionIdentifier, var_orderHash)
    }
    let var_result := mload( 0)
    let _2 := shl(224,  0xffffffff)
    if  iszero(eq( and( var_result,  _2), and( var_magicValue,  _2)))
    {
        dispatch_internal_in_out_0(var_errorHandler_functionIdentifier, var_orderHash)
    }
}

emitOrderFulfilledEvent.sol

/**
 * @dev difference here is an empty "fulfiller" vs non-empty - og includes fulfiller var, and var_offer_mpos and var_consideration_mpos params are renamed in og
 */
function fun_emitOrderFulfilledEvent_39743(var_orderHash, var_offerer, var_zone, var_offer_mpos, var_consideration_mpos)
{
    let _1 := sub(shl(160, 1), 1)
    let _2 :=  mload(64)
    mstore(_2, var_orderHash)
    mstore(add(_2, 32), 0)
    mstore(add(_2, 64), 128)
    let tail := abi_encode_array_struct_SpentItem_memory_ptr_dyn_memory_ptr(var_offer_mpos, add(_2, 128))
    mstore(add(_2, 96), sub(tail, _2))
    log3(_2, sub( abi_encode_array_struct_ReceivedItem_memory_ptr_dyn_memory_ptr(var_consideration_mpos, tail),  _2), 0x9d9af8e38d66c62e2c12f0225249fd9d721c54b83f48d9352c97c6cacdcb6f31,  and( var_offerer,  _1), and( var_zone,  _1))
}
function fun_emitOrderFulfilledEvent(var_orderHash, var_offerer, var_zone, var_fulfiller, var_offer_8741_mpos, var_consideration_8745_mpos)
{
    let _1 := sub(shl(160, 1), 1)
    let _2 :=  mload(64)
    mstore(_2, var_orderHash)
    mstore(add(_2, 32), and(var_fulfiller, _1))
    mstore(add(_2, 64), 128)
    let tail := abi_encode_array_struct_SpentItem_memory_ptr_dyn_memory_ptr(var_offer_8741_mpos, add(_2, 128))
    mstore(add(_2, 96), sub(tail, _2))
    log3(_2, sub( abi_encode_array_struct_ReceivedItem_memory_ptr_dyn_memory_ptr(var_consideration_8745_mpos, tail),  _2), 0x9d9af8e38d66c62e2c12f0225249fd9d721c54b83f48d9352c97c6cacdcb6f31,  and( var_offerer,  _1), and( var_zone,  _1))
}

Findings.md

Findings

1. Most bifurcated definitions seem to be for reverting vs non-reverting codepaths - ie, normal fulfill vs fulfillAvailable. Introducing branching logic may add gas overhead.
   1. aggregateAvailable
   2. callAndCheckStatus (probably)
   3. fun_getGeneratedOrder (vs others, likely)
   4. fun_validateOrderAndUpdateStatus (vs others)
   5. fun_validateOrderAndPrepareToFulfill
   6. fun_verifyOrderStatus
   7. fun_verifyTime
2. Some are split due to differing logic. These may be able to be streamlined though they are likely be separated to eliminate branching when processing similar items, eg, deriving amounts for offer vs consideration items
   1. fun_aggregateAvailable - offer vs consideration
   2. fun_applyFraction - round up vs round down
   3. fun_locateCurrentAmount - round up vs round down
3. Some are split by a single differing variable, usually an empty-vs-non-empty variable. These are good candidates to streamline by (effectively) adding a parameter to the function signature
   1. emitOrderFulfilledEvent - empty fulfiller versus non-empty fulfiller (matchOrders fulfillments)
   2. generateValidateCalldata - empty extraBytes versus non-empty extraBytes (regular versus advanced order fulfillment)
   3. fun_locateCurrentAmount - the righthand side of the mul in the var_amount assignment could potentially be parameterized
4. Some functions are entirely duplicated besides name (and sometimes using decimal vs hexadecimal notation)
   1. fun_getGeneratedOrder vs fun_getGeneratedOrder_39750
   2. fun_locateCurrentAmount vs fun_locateCurrentAmount_40135
   3. fun_verifyOrderStatus_22485 vs fun_verifyOrderStatus_39751
   4. fun_validateOrderAndUpdateStatus_22567 vs fun_validateOrderAndUpdateStatus_39742
      1. seems to do some weird stack stuff
      2. calls known duplicate of fun_getGeneratedOrder_39750
   5. fun_verifyOrderStatus_22485 vs fun_verifyOrderStatus_39751
5. Some functions are duplicated besides the overloaded functions they call, and are not reverting vs non-reverting codepaths
   1. fun_validateOrderAndUpdateStatus2257 vs fun_validateOrderAndUpdateStatus_39742
   2. fun_getGeneratedOrder_39750 vs fun_getGeneratedOrder
   3. fun_validateOrdersAndPrepareToFulfill (points to fun_validateOrderAndUpdateStatus_40131 which is missing?)
   4. fun_validateOrdersAndPrepareToFulfill calls fun_emitOrderFulfilledEvent with different arguments depending on if fulfiller/recipient is empty

Other bytecode optimizations

• Patterns similar to add(sum, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) can be manually tuned to sub(sum, 1)

???

fun_fulfillAvailableAdvancedOrders_2038 seems to call fun_fulfillAvailableAdvancedOrders, so is not a duplicate

fun_verifyOrderStatus - includes revert branch but can never revert

some functions do weird stack variable shuffling for reasons unknown

fulfillAvailableAdvancedOrders.sol

/**
 * @dev first seems to call the second - not really a duplicate? unless inlining whatever branch logic would help significantly
 */
function fun_fulfillAvailableAdvancedOrders_2038(var_advancedOrders_1995_mpos, var_criteriaResolvers_offset, var_criteriaResolvers_length, var_offerFulfillments_offset, var_offerFulfillments_length, var_considerationFulfillments_2009_offset, var_considerationFulfillments_2009_length, var_fulfillerConduitKey, var_recipient, var_maximumFulfilled) -> var_2019_mpos, var__mpos
{
    let expr_2035_component_1_mpos, expr_2035_component_2_mpos := fun_fulfillAvailableAdvancedOrders(var_advancedOrders_1995_mpos,  abi_decode_available_length_array_struct_CriteriaResolver_dyn( var_criteriaResolvers_offset, var_criteriaResolvers_length,  calldatasize()),  var_offerFulfillments_offset, var_offerFulfillments_length, var_considerationFulfillments_2009_offset, var_considerationFulfillments_2009_length, var_fulfillerConduitKey,  add( var_recipient,  mul(iszero( var_recipient),  caller())),  var_maximumFulfilled)
    var_2019_mpos := expr_2035_component_1_mpos
    var__mpos := expr_2035_component_2_mpos
}

function fun_fulfillAvailableAdvancedOrders(var_advancedOrders_7523_mpos, var_criteriaResolvers_mpos, var_offerFulfillments_7532_offset, var_offerFulfillments_7532_length, var_considerationFulfillments_offset, var_considerationFulfillments_length, var_fulfillerConduitKey, var_recipient, var_maximumFulfilled) -> var_7547_mpos, var_7551_mpos
{
    let expr_7564_mpos := fun_validateOrdersAndPrepareToFulfill(var_advancedOrders_7523_mpos, var_criteriaResolvers_mpos, var_maximumFulfilled, var_recipient)
    let _498_mpos :=  abi_decode_available_length_array_array_struct_FulfillmentComponent_dyn_dyn( var_offerFulfillments_7532_offset, var_offerFulfillments_7532_length,  calldatasize())
    let _1 := abi_decode_available_length_array_array_struct_FulfillmentComponent_dyn_dyn( var_considerationFulfillments_offset, var_considerationFulfillments_length,  calldatasize())
    let expr :=  mload( _498_mpos)
    let expr_1 :=  mload( _1)
    let expr_mpos := allocate_and_zero_memory_array_array_struct_Execution_dyn( checked_add_uint256(expr, expr_1))
    let var_totalFilteredExecutions :=  0x00
    let var_i :=  var_totalFilteredExecutions
    for { }
     lt(var_i, expr)
    { }
    {
        let 
        var_execution_mpos :=   fun_aggregateAvailable( var_advancedOrders_7523_mpos,  mload(memory_array_index_access_struct_AdvancedOrder_dyn(_498_mpos, var_i)),  var_recipient)
        let _2 := read_from_memoryt_address(add( mload(var_execution_mpos),  128))
        switch  eq( and( _2,  0xffffffffffffffffffffffffffffffffffffffff), cleanup_address(mload( add(var_execution_mpos, 32))))
        case  0 {
            let expr_2 :=  sub( var_i, var_totalFilteredExecutions)
            mstore(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, expr_2), var_execution_mpos)
            pop(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, expr_2))
        }
        default 
        {
            var_totalFilteredExecutions :=  add( var_totalFilteredExecutions,  1)
        }
        var_i :=  add( var_i,  1)
    }
    let var_i_1 :=  0x00
    for { }
     lt(var_i_1, expr_1)
    { }
    {
        let expr_mpos_1 := fun_aggregateAvailable_22784(var_advancedOrders_7523_mpos,  mload(memory_array_index_access_struct_AdvancedOrder_dyn(_1, var_i_1)),  var_fulfillerConduitKey)
        let _3 := read_from_memoryt_address(add( mload(expr_mpos_1),  128))
        switch  eq( and( _3,  0xffffffffffffffffffffffffffffffffffffffff), cleanup_address(mload( add(expr_mpos_1,  32))))
        case  0 {
            let expr_3 :=  sub(add( var_i_1, expr),  var_totalFilteredExecutions)
            mstore(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, expr_3), expr_mpos_1)
            pop(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, expr_3))
        }
        default 
        {
            var_totalFilteredExecutions :=  add( var_totalFilteredExecutions,  1)
        }
        var_i_1 :=  add( var_i_1,  1)
    }
    if  iszero(iszero(var_totalFilteredExecutions))
    {
        mstore(expr_mpos, sub(mload(expr_mpos), var_totalFilteredExecutions))
    }
    if  iszero( mload( expr_mpos))
    {
        fun_revertNoSpecifiedOrdersAvailable()
    }
    var_7547_mpos :=  fun_performFinalChecksAndExecuteOrders(var_advancedOrders_7523_mpos, expr_mpos, expr_7564_mpos)
    var_7551_mpos := expr_mpos
}

generateValidateCalldata.sol

/**
 * @dev One difference: og supplies a pointer to extraData at add(memPtr, 160) via an extra param (vareExtraData_mpos) versus 0x60 (the 0-pointer)
 */
function fun_generateValidateCallData_22871(var_orderHash, var_offerer, var_offer_mpos, var_consideration_mpos, var_orderHashes_mpos, var_startTime, var_endTime, var_zoneHash) -> var_mpos
{
    let memPtr := mload(64)
    finalize_allocation_22874(memPtr)
    mstore(memPtr, var_orderHash)
    mstore( add(memPtr, 32),  caller())
    mstore( add(memPtr,  64), and(var_offerer, 0xffffffffffffffffffffffffffffffffffffffff))
    mstore( add(memPtr,  96),  var_offer_mpos)
    mstore( add(memPtr, 128),  var_consideration_mpos)
    mstore( add(memPtr, 160),  96)
    mstore( add(memPtr, 192),  var_orderHashes_mpos)
    mstore( add(memPtr, 224),  var_startTime)
    mstore( add(memPtr, 256),  var_endTime)
    mstore( add(memPtr, 288),  var_zoneHash)
    let expr_mpos :=  mload(64)
    mstore(add(expr_mpos,  32),  0x17b1f94200000000000000000000000000000000000000000000000000000000)
    let _1 := sub(abi_encode_struct_ZoneParameters(add(expr_mpos, 36), memPtr), expr_mpos)
    mstore(expr_mpos, add(_1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))
    finalize_allocation(expr_mpos, _1)
    var_mpos := expr_mpos
}

function fun_generateValidateCallData(var_orderHash, var_offerer, var_offer_13992_mpos, var_consideration_13996_mpos, var_extraData_mpos, var_orderHashes_14001_mpos, var_startTime, var_endTime, var_zoneHash) -> var_mpos
{
    let memPtr := mload(64)
    finalize_allocation_22874(memPtr)
    mstore(memPtr, var_orderHash)
    mstore( add(memPtr, 32),  caller())
    mstore( add(memPtr,  64), and(var_offerer, 0xffffffffffffffffffffffffffffffffffffffff))
    mstore( add(memPtr, 96),  var_offer_13992_mpos)
    mstore( add(memPtr, 128),  var_consideration_13996_mpos)
    mstore( add(memPtr, 160),  var_extraData_mpos)
    mstore( add(memPtr, 192),  var_orderHashes_14001_mpos)
    mstore( add(memPtr, 224),  var_startTime)
    mstore( add(memPtr, 256),  var_endTime)
    mstore( add(memPtr, 288),  var_zoneHash)
    let expr_14030_mpos :=  mload(64)
    mstore(add(expr_14030_mpos,  32),  0x17b1f94200000000000000000000000000000000000000000000000000000000)
    let _1 := sub(abi_encode_struct_ZoneParameters(add(expr_14030_mpos, 36), memPtr), expr_14030_mpos)
    mstore(expr_14030_mpos, add(_1, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))
    finalize_allocation(expr_14030_mpos, _1)
    var_mpos := expr_14030_mpos
}

getGeneratedOrder.sol

/**
 * @dev Differences
 *      39750 vs 52220: (reverting vs non-reverting)
 *          - integer formatting (probably not in actual code - may have been generated differently?)
 *          - var_orderHash_1 vs var_orderHash - copied for some reason
 *          - 39750 always calls revert function - 52220 sets var_orderHash to itself(??) and sets numer/denom to 0 and leaves function execution
 *          - 52220 may be for the "fulfillAvailable" case since it does not revert
 *
 *      39750 vs og:
 *          - no difference besides name, lol
 *     
 *      52220 vs og:
 *          - same differences as 39750 vs 52220
 */

function fun_getGeneratedOrder_39750(var_orderParameters_mpos, var_context_mpos) -> var_orderHash, var_numerator, var_denominator
{
    let var_offer_mpos :=  0
    var_offer_mpos :=  96
    let var_consideration_mpos :=  0
    var_consideration_mpos :=  var_offer_mpos
    let _1 :=  cleanup_address(mload( var_orderParameters_mpos))
    let _2 := mapping_index_access_mapping_address_uint256_of_address(_1)
    let _3 := sload( _2)
    sstore(_2, add( _3,  0x01))
    let var_orderHash_1 := or(_3, shl( var_offer_mpos,  _1))
    let _4 := 64
    let _5 := add(var_orderParameters_mpos, _4)
    let _mpos := mload(_5)
    let _6 := add(var_orderParameters_mpos,  var_offer_mpos)
    let _7 := mload(_6)
    let _8 :=  mload( _4)
    mstore(_8,  shl(224, 0x98919765))
    let trySuccessCondition := call(gas(),  and( _1,  sub(shl(160, 1), 1)),  0,  _8, sub(abi_encode_address_array_struct_SpentItem_dyn_array_struct_SpentItem_dyn_bytes(add(_8, 4),  caller(),  _mpos, _7, var_context_mpos), _8), _8,  0)
    let expr_component_mpos :=  0
    let expr_component_mpos_1 := expr_component_mpos
    if trySuccessCondition
    {
        let _9 := returndatasize()
        returndatacopy(_8,  expr_component_mpos,  _9)
        finalize_allocation(_8, _9)
        let expr_component_mpos_2, expr_component_mpos_3 := abi_decode_array_struct_SpentItem_dynt_array_struct_ReceivedItem_dyn_fromMemory(_8, add(_8, _9))
        expr_component_mpos := expr_component_mpos_2
        expr_component_mpos_1 := expr_component_mpos_3
    }
    switch iszero(trySuccessCondition)
    case 0 {
        var_offer_mpos := expr_component_mpos
        var_consideration_mpos := expr_component_mpos_1
    }
    default 
    {
        pop(extract_returndata())
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    let var_errorBuffer :=  0
    let length := mload( mload(_5))
    let expr :=  mload( var_offer_mpos)
    switch  gt(length, expr)
    case  0 {
        if  gt(expr, length)
        {
            let expr_mpos := allocate_and_zero_memory_array_array_struct_OfferItem_dyn(expr)
            let var_i :=  var_errorBuffer
            for { }
             lt(var_i, length)
            {
                var_i := increment_uint256(var_i)
            }
            {
                mstore(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i),  mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i)))
                pop(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i))
            }
            mstore(_5, expr_mpos)
        }
    }
    default 
    {
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    let var_i_1 :=  var_errorBuffer
    for { }
     lt(var_i_1, length)
    {
        var_i_1 := increment_uint256(var_i_1)
    }
    {
        let _mpos_1 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_1))
        let _mpos_2 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_1))
        let _10 := mload( add(_mpos_1, 128))
        var_errorBuffer :=  fun_check(_mpos_1, _mpos_2, _10,  mload( add(_mpos_2,  96)),  var_errorBuffer)
    }
    let var_i_2 := length
    for { }
     lt(var_i_2, expr)
    {
        var_i_2 := increment_uint256(var_i_2)
    }
    {
        let _mpos_3 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_2))
        let _mpos_4 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_2))
        let _11 := mload( _mpos_4)
        validator_assert_enum_ItemType(_11)
        write_to_memory_enum_ItemType(_mpos_3,  _11)
        let _12 := 32
        write_to_memory_address( add(_mpos_3,  _12),  cleanup_address(mload( add(_mpos_4, _12))))
        mstore( add(_mpos_3,  _4),  mload( add(_mpos_4,  _4)))
        let _13 := add(_mpos_4,  96)
        mstore( add(_mpos_3,  96), mload( _13))
        mstore( add(_mpos_3,  128),  mload( _13))
    }
    let _mpos_5 := mload(_6)
    let expr_1 :=  mload( _mpos_5)
    let expr_2 :=  mload( var_consideration_mpos)
    switch  iszero(iszero(expr_1))
    case  0 {
        mstore(_6,  allocate_and_zero_memory_array_array_struct_ConsiderationItem_dyn(expr_2))
        let var_i_3 :=  0
        for { }
         lt(var_i_3, expr_2)
        {
            var_i_3 := increment_uint256(var_i_3)
        }
        {
            let _mpos_6 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_6),  var_i_3))
            write_to_memory_enum_ItemType(_mpos_6,  read_from_memoryt_enum_ItemType( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3))))
            let _14 := 32
            write_to_memory_address( add(_mpos_6,  _14),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _14)))
            mstore( add(_mpos_6,  _4),  mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _4)))
            mstore( add(_mpos_6,  96), mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96)))
            let _15 := mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96))
            let _16 := 128
            mstore( add(_mpos_6,  _16),  _15)
            write_to_memory_address( add(_mpos_6, 160),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _16)))
        }
    }
    default 
    {
        if  gt(expr_2, expr_1)
        {
            fun_revertInvalidContractOrder(var_orderHash_1)
        }
        let var_i_4 :=  0
        for { }
         lt(var_i_4, expr_2)
        {
            var_i_4 := increment_uint256(var_i_4)
        }
        {
            let _mpos_7 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_4))
            let _mpos_8 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_5, var_i_4))
            let _17 := mload( add(_mpos_7,  96))
            let _18 := 128
            var_errorBuffer :=  fun_check(_mpos_8, _mpos_7, _17, mload( add(_mpos_8,  _18)),  var_errorBuffer)
            write_to_memory_address( add(_mpos_8, 160),  cleanup_address(mload( add(_mpos_7,  _18))))
        }
        mstore(_mpos_5, expr_2)
    }
    if  iszero(iszero(var_errorBuffer))
    {
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    var_orderHash := var_orderHash_1
    var_numerator :=  0x01
    var_denominator :=  var_numerator
}

function fun_getGeneratedOrder_52220(var_orderParameters_mpos, var_context_mpos) -> var_orderHash, var_numerator, var_denominator
{
    let var_offer_mpos :=  0x00
    var_offer_mpos :=  96
    let var_consideration_mpos :=  0x00
    var_consideration_mpos :=  var_offer_mpos
    let _1 :=  cleanup_address(mload( var_orderParameters_mpos))
    let _2 := mapping_index_access_mapping_address_uint256_of_address(_1)
    let _3 := sload( _2)
    sstore(_2, add( _3,  1))
    var_orderHash := or(_3, shl( var_offer_mpos,  _1))
    let var_orderHash_1 := var_orderHash
    let _4 := 64
    let _5 := add(var_orderParameters_mpos, _4)
    let _mpos := mload(_5)
    let _6 := add(var_orderParameters_mpos,  var_offer_mpos)
    let _7 := mload(_6)
    let _8 :=  mload( _4)
    mstore(_8,  shl(224, 0x98919765))
    let trySuccessCondition := call(gas(),  and( _1,  sub(shl(160, 1), 1)),  0x00,  _8, sub(abi_encode_address_array_struct_SpentItem_dyn_array_struct_SpentItem_dyn_bytes(add(_8, 4),  caller(),  _mpos, _7, var_context_mpos), _8), _8,  0x00)
    let expr_component_mpos :=  0x00
    let expr_component_mpos_1 := expr_component_mpos
    if trySuccessCondition
    {
        let _9 := returndatasize()
        returndatacopy(_8,  expr_component_mpos,  _9)
        finalize_allocation(_8, _9)
        let expr_component_mpos_2, expr_component_mpos_3 := abi_decode_array_struct_SpentItem_dynt_array_struct_ReceivedItem_dyn_fromMemory(_8, add(_8, _9))
        expr_component_mpos := expr_component_mpos_2
        expr_component_mpos_1 := expr_component_mpos_3
    }
    switch iszero(trySuccessCondition)
    case 0 {
        var_offer_mpos := expr_component_mpos
        var_consideration_mpos := expr_component_mpos_1
    }
    default 
    {
        pop(extract_returndata())
        var_orderHash := var_orderHash_1
        var_numerator :=  0x00
        var_denominator :=  0x00
        leave
    }
    let var_errorBuffer :=  0x00
    let length := mload( mload(_5))
    let expr :=  mload( var_offer_mpos)
    switch  gt(length, expr)
    case  0 {
        if  gt(expr, length)
        {
            let expr_mpos := allocate_and_zero_memory_array_array_struct_OfferItem_dyn(expr)
            let var_i :=  var_errorBuffer
            for { }
             lt(var_i, length)
            {
                var_i := increment_uint256(var_i)
            }
            {
                mstore(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i),  mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i)))
                pop(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i))
            }
            mstore(_5, expr_mpos)
        }
    }
    default 
    {
        var_orderHash := var_orderHash
        var_numerator :=  var_errorBuffer
        var_denominator :=  var_errorBuffer
        leave
    }
    let var_i_1 :=  var_errorBuffer
    for { }
     lt(var_i_1, length)
    {
        var_i_1 := increment_uint256(var_i_1)
    }
    {
        let _mpos_1 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_1))
        let _mpos_2 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_1))
        let _10 := mload( add(_mpos_1, 128))
        var_errorBuffer :=  fun_check(_mpos_1, _mpos_2, _10,  mload( add(_mpos_2,  96)),  var_errorBuffer)
    }
    let var_i_2 := length
    for { }
     lt(var_i_2, expr)
    {
        var_i_2 := increment_uint256(var_i_2)
    }
    {
        let _mpos_3 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_2))
        let _mpos_4 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_2))
        let _11 := mload( _mpos_4)
        validator_assert_enum_ItemType(_11)
        write_to_memory_enum_ItemType(_mpos_3,  _11)
        let _12 := 32
        write_to_memory_address( add(_mpos_3,  _12),  cleanup_address(mload( add(_mpos_4, _12))))
        mstore( add(_mpos_3,  _4),  mload( add(_mpos_4,  _4)))
        let _13 := add(_mpos_4,  96)
        mstore( add(_mpos_3,  96), mload( _13))
        mstore( add(_mpos_3,  128),  mload( _13))
    }
    let _mpos_5 := mload(_6)
    let expr_1 :=  mload( _mpos_5)
    let expr_2 :=  mload( var_consideration_mpos)
    switch  iszero(iszero(expr_1))
    case  0 {
        mstore(_6,  allocate_and_zero_memory_array_array_struct_ConsiderationItem_dyn(expr_2))
        let var_i_3 :=  0x00
        for { }
         lt(var_i_3, expr_2)
        {
            var_i_3 := increment_uint256(var_i_3)
        }
        {
            let _mpos_6 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_6),  var_i_3))
            write_to_memory_enum_ItemType(_mpos_6,  read_from_memoryt_enum_ItemType( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3))))
            let _14 := 32
            write_to_memory_address( add(_mpos_6,  _14),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _14)))
            mstore( add(_mpos_6,  _4),  mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _4)))
            mstore( add(_mpos_6,  96), mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96)))
            let _15 := mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96))
            let _16 := 128
            mstore( add(_mpos_6,  _16),  _15)
            write_to_memory_address( add(_mpos_6, 160),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _16)))
        }
    }
    default 
    {
        if  gt(expr_2, expr_1)
        {
            var_orderHash := var_orderHash
            var_numerator :=  0x00
            var_denominator :=  0x00
            leave
        }
        let var_i_4 :=  0x00
        for { }
         lt(var_i_4, expr_2)
        {
            var_i_4 := increment_uint256(var_i_4)
        }
        {
            let _mpos_7 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_4))
            let _mpos_8 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_5, var_i_4))
            let _17 := mload( add(_mpos_7,  96))
            let _18 := 128
            var_errorBuffer :=  fun_check(_mpos_8, _mpos_7, _17, mload( add(_mpos_8,  _18)),  var_errorBuffer)
            write_to_memory_address( add(_mpos_8, 160),  cleanup_address(mload( add(_mpos_7,  _18))))
        }
        mstore(_mpos_5, expr_2)
    }
    if  iszero(iszero(var_errorBuffer))
    {
        var_orderHash := var_orderHash
        var_numerator :=  0x00
        var_denominator :=  0x00
        leave
    }
    var_orderHash := var_orderHash
    var_numerator :=  1
    var_denominator :=  var_numerator
}

function fun_getGeneratedOrder(var_orderParameters_mpos, var_context_mpos) -> var_orderHash, var_numerator, var_denominator
{
    let var_offer_mpos :=  0
    var_offer_mpos :=  96
    let var_consideration_mpos :=  0
    var_consideration_mpos :=  var_offer_mpos
    let _1 :=  cleanup_address(mload( var_orderParameters_mpos))
    let _2 := mapping_index_access_mapping_address_uint256_of_address(_1)
    let _3 := sload( _2)
    sstore(_2, add( _3,  0x01))
    let var_orderHash_1 := or(_3, shl( var_offer_mpos,  _1))
    let _4 := 64
    let _5 := add(var_orderParameters_mpos, _4)
    let _mpos := mload(_5)
    let _6 := add(var_orderParameters_mpos,  var_offer_mpos)
    let _7 := mload(_6)
    let _8 :=  mload( _4)
    mstore(_8,  shl(224, 0x98919765))
    let trySuccessCondition := call(gas(),  and( _1,  sub(shl(160, 1), 1)),  0,  _8, sub(abi_encode_address_array_struct_SpentItem_dyn_array_struct_SpentItem_dyn_bytes(add(_8, 4),  caller(),  _mpos, _7, var_context_mpos), _8), _8,  0)
    let expr_component_mpos :=  0
    let expr_component_mpos_1 := expr_component_mpos
    if trySuccessCondition
    {
        let _9 := returndatasize()
        returndatacopy(_8,  expr_component_mpos,  _9)
        finalize_allocation(_8, _9)
        let expr_component_mpos_2, expr_component_mpos_3 := abi_decode_array_struct_SpentItem_dynt_array_struct_ReceivedItem_dyn_fromMemory(_8, add(_8, _9))
        expr_component_mpos := expr_component_mpos_2
        expr_component_mpos_1 := expr_component_mpos_3
    }
    switch iszero(trySuccessCondition)
    case 0 {
        var_offer_mpos := expr_component_mpos
        var_consideration_mpos := expr_component_mpos_1
    }
    default 
    {
        pop(extract_returndata())
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    let var_errorBuffer :=  0
    let length := mload( mload(_5))
    let expr :=  mload( var_offer_mpos)
    switch  gt(length, expr)
    case  0 {
        if  gt(expr, length)
        {
            let expr_mpos := allocate_and_zero_memory_array_array_struct_OfferItem_dyn(expr)
            let var_i :=  var_errorBuffer
            for { }
             lt(var_i, length)
            {
                var_i := increment_uint256(var_i)
            }
            {
                mstore(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i),  mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i)))
                pop(memory_array_index_access_struct_AdvancedOrder_dyn(expr_mpos, var_i))
            }
            mstore(_5, expr_mpos)
        }
    }
    default 
    {
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    let var_i_1 :=  var_errorBuffer
    for { }
     lt(var_i_1, length)
    {
        var_i_1 := increment_uint256(var_i_1)
    }
    {
        let _mpos_1 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_1))
        let _mpos_2 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_1))
        let _10 := mload( add(_mpos_1, 128))
        var_errorBuffer :=  fun_check(_mpos_1, _mpos_2, _10,  mload( add(_mpos_2,  96)),  var_errorBuffer)
    }
    let var_i_2 := length
    for { }
     lt(var_i_2, expr)
    {
        var_i_2 := increment_uint256(var_i_2)
    }
    {
        let _mpos_3 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_5),  var_i_2))
        let _mpos_4 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_offer_mpos, var_i_2))
        let _11 := mload( _mpos_4)
        validator_assert_enum_ItemType(_11)
        write_to_memory_enum_ItemType(_mpos_3,  _11)
        let _12 := 32
        write_to_memory_address( add(_mpos_3,  _12),  cleanup_address(mload( add(_mpos_4, _12))))
        mstore( add(_mpos_3,  _4),  mload( add(_mpos_4,  _4)))
        let _13 := add(_mpos_4,  96)
        mstore( add(_mpos_3,  96), mload( _13))
        mstore( add(_mpos_3,  128),  mload( _13))
    }
    let _mpos_5 := mload(_6)
    let expr_1 :=  mload( _mpos_5)
    let expr_2 :=  mload( var_consideration_mpos)
    switch  iszero(iszero(expr_1))
    case  0 {
        mstore(_6,  allocate_and_zero_memory_array_array_struct_ConsiderationItem_dyn(expr_2))
        let var_i_3 :=  0
        for { }
         lt(var_i_3, expr_2)
        {
            var_i_3 := increment_uint256(var_i_3)
        }
        {
            let _mpos_6 := mload(memory_array_index_access_struct_AdvancedOrder_dyn( mload(_6),  var_i_3))
            write_to_memory_enum_ItemType(_mpos_6,  read_from_memoryt_enum_ItemType( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3))))
            let _14 := 32
            write_to_memory_address( add(_mpos_6,  _14),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _14)))
            mstore( add(_mpos_6,  _4),  mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _4)))
            mstore( add(_mpos_6,  96), mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96)))
            let _15 := mload( add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  96))
            let _16 := 128
            mstore( add(_mpos_6,  _16),  _15)
            write_to_memory_address( add(_mpos_6, 160),  read_from_memoryt_address(add( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_3)),  _16)))
        }
    }
    default 
    {
        if  gt(expr_2, expr_1)
        {
            fun_revertInvalidContractOrder(var_orderHash_1)
        }
        let var_i_4 :=  0
        for { }
         lt(var_i_4, expr_2)
        {
            var_i_4 := increment_uint256(var_i_4)
        }
        {
            let _mpos_7 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_consideration_mpos, var_i_4))
            let _mpos_8 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_5, var_i_4))
            let _17 := mload( add(_mpos_7,  96))
            let _18 := 128
            var_errorBuffer :=  fun_check(_mpos_8, _mpos_7, _17, mload( add(_mpos_8,  _18)),  var_errorBuffer)
            write_to_memory_address( add(_mpos_8, 160),  cleanup_address(mload( add(_mpos_7,  _18))))
        }
        mstore(_mpos_5, expr_2)
    }
    if  iszero(iszero(var_errorBuffer))
    {
        fun_revertInvalidContractOrder(var_orderHash_1)
    }
    var_orderHash := var_orderHash_1
    var_numerator :=  0x01
    var_denominator :=  var_numerator
}

locateCurrentAmount.sol

/**
 * @dev Differences
 *      fun_locateCurrentAmount vs fun_locateCurrentAmount_22788
 *        - og rounds down, 22788 rounds up
 *        - can bytecode optimize add(sum, type(uint256).max) to sub(sum, 1)
 *        - could make righthand side of mul a separate param and pass that in?
 *      
 *      fun_locateCurrentAmount vs fun_locateCurrentAmount_40135
 *        - same as 22788 but different name
 */

function fun_locateCurrentAmount(var_startAmount, var_endAmount, var_startTime, var_endTime) -> var_amount
{
    if  iszero(eq(var_startAmount, var_endAmount))
    {
        let expr :=  sub( var_endTime, var_startTime)
        let expr_1 :=  sub( timestamp(),  var_startTime)
        let expr_2 := checked_mul_uint256(var_startAmount,  sub( expr, expr_1))
        let sum := add(expr_2, /** @src 17:2762:2781  "endAmount * elapsed" */ checked_mul_uint256(var_endAmount, expr_1))
        if gt(expr_2, sum) { panic_error_0x11() }
        var_amount :=  mul(iszero(iszero(sum)), div(sum, expr))
        leave
    }
    var_amount := var_endAmount
}

function fun_locateCurrentAmount_22788(var_startAmount, var_endAmount, var_startTime, var_endTime) -> var_amount
{
    if  iszero(eq(var_startAmount, var_endAmount))
    {
        let expr :=  sub( var_endTime, var_startTime)
        let expr_1 :=  sub( timestamp(),  var_startTime)
        let expr_2 := checked_mul_uint256(var_startAmount,  sub( expr, expr_1))
        let sum := add(expr_2, /** @src 17:2762:2781  "endAmount * elapsed" */ checked_mul_uint256(var_endAmount, expr_1))
        if gt(expr_2, sum) { panic_error_0x11() }
        var_amount :=  mul(iszero(iszero(sum)), add(div(add(sum, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), expr),  1))
        leave
    }
    var_amount := var_endAmount
}

function fun_locateCurrentAmount_40135(var_startAmount, var_endAmount, var_startTime, var_endTime) -> var_amount
{
    if  iszero(eq(var_startAmount, var_endAmount))
    {
        let expr :=  sub( var_endTime, var_startTime)
        let expr_1 :=  sub( timestamp(),  var_startTime)
        let expr_2 := checked_mul_uint256(var_startAmount,  sub( expr, expr_1))
        let sum := add(expr_2, /** @src 17:2762:2781  "endAmount * elapsed" */ checked_mul_uint256(var_endAmount, expr_1))
        if gt(expr_2, sum) { panic_error_0x11() }
        var_amount :=  mul(iszero(iszero(sum)), add(div(add(sum, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), expr),  0x01))
        leave
    }
    var_amount := var_endAmount
}

validateOrderAndUpdateStatus.sol

/**
 * @dev differences
 *      22567 vs og
 *        - fun_verifyTime vs fun_verifyTime_52219 (revert vs non-reverting)
 *        - fun_verifyOrderStatus_39751 vs fun_verifyOrderStatus (reverting vs non-reverting)
 *        - weird shuffling of var_filledNumerator_1 and var_filledNumerator
 *
 *      22567 vs 39742
 *        - fun_getGeneratedOrder_39750 vs fun_getGeneratedOrder
 *          - known dupe
 *        - weird shuffling of var_filledNumerator_1 and var_filledNumerator
 *
 *      og vs 39742
 *        - fun_getGeneratedOrder_52220 vs og
 *        - fun_verifyOrderStatus vs fun_verifyOrderStatus_39751
 */

function fun_validateOrderAndUpdateStatus_22567(var_advancedOrder_mpos) -> var_orderHash, var_newNumerator, var_newDenominator
{
    let _mpos := mload(var_advancedOrder_mpos)
    let _1 := mload( add(_mpos, 160))
    if  cleanup_bool(iszero( fun_verifyTime(_1,  mload( add(_mpos, 192)))))
    {
        var_orderHash :=  0
        var_newNumerator :=  0
        var_newDenominator :=  0
        leave
    }
    let _2 := add(_mpos, 128)
    let _3 := mload( _2)
    validator_assert_enum_OrderType(_3)
    validator_assert_enum_OrderType(_3)
    if  eq(_3,  4)
    {
        let expr_component, expr_component_1, expr_component_2 := fun_getGeneratedOrder_39750(_mpos,  mload(add(var_advancedOrder_mpos,  128)))
        var_orderHash := expr_component
        var_newNumerator := expr_component_1
        var_newDenominator := expr_component_2
        leave
    }
    let var_numerator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 32))))
    let var_denominator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 64))))
    let expr :=  gt(var_numerator, var_denominator)
    if iszero(expr)
    {
        expr :=  iszero(var_numerator)
    }
    if expr { fun_revertBadFraction() }
    let expr_1 :=  lt(var_numerator, var_denominator)
    if expr_1
    {
        let _4 := mload( _2)
        validator_assert_enum_OrderType(_4)
        expr_1 :=  iszero(and( _4,  0x01))
    }
    if expr_1
    {
        fun_revertPartialFillsNotEnabledForOrder()
    }
    var_orderHash :=  fun_assertConsiderationLengthAndGetOrderHash(_mpos)
    let _5 := mapping_index_access_mapping_bytes32_struct_OrderStatus_storage_of_bytes32(var_orderHash)
    if  cleanup_bool(iszero( fun_verifyOrderStatus_39751(var_orderHash, _5)))
    {
        var_orderHash := var_orderHash
        var_newNumerator :=  0
        var_newDenominator :=  0
        leave
    }
    let _6 := sload( _5)
    if  iszero( and(_6, 0xff))
    {
        let _7 :=  cleanup_address(mload( _mpos))
        fun_verifySignature(_7, var_orderHash, mload(add(var_advancedOrder_mpos, 96)))
    }
    let _8 := 0xffffffffffffffffffffffffffffff
    let var_filledNumerator :=  and(shr(16, _6), _8)
    let _9 := shr(136, _6)
    switch  iszero(iszero(_9))
    case  0 {
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_numerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    default 
    {
        switch  eq(var_denominator,  0x01)
        case  0 {
            if  iszero(eq(_9, var_denominator))
            {
                var_filledNumerator := checked_mul_uint256(var_filledNumerator, var_denominator)
                var_numerator := checked_mul_uint256(var_numerator, _9)
                var_denominator := checked_mul_uint256(var_denominator, _9)
            }
        }
        default 
        {
            var_numerator := _9
            var_denominator := _9
        }
        if  gt( checked_add_uint256(var_filledNumerator, var_numerator),  var_denominator)
        {
            var_numerator :=  sub( var_denominator, var_filledNumerator)
        }
        var_filledNumerator := checked_add_uint256(var_filledNumerator, var_numerator)
        if or(gt(var_filledNumerator,  _8),  gt(var_denominator,  _8))
        {
            let usr$scaleDown := usr$gcd(var_numerator, usr$gcd(var_filledNumerator, var_denominator))
            let usr$safeScaleDown := add(usr$scaleDown, iszero(usr$scaleDown))
            var_numerator := div(var_numerator, usr$safeScaleDown)
            var_filledNumerator := div(var_filledNumerator, usr$safeScaleDown)
            var_denominator := div(var_denominator, usr$safeScaleDown)
            if or(gt(var_filledNumerator,  _8),  gt(var_denominator,  _8))
            {
                mstore( 0,  1313373041)
                mstore( 32,  17)
                revert(0x1c, 36)
            }
        }
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_filledNumerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    var_orderHash := var_orderHash
    var_newNumerator := var_numerator
    var_newDenominator := var_denominator
}

function fun_validateOrderAndUpdateStatus(var_advancedOrder_mpos) -> var_orderHash, var_newNumerator, var_newDenominator
{
    let _mpos := mload(var_advancedOrder_mpos)
    let _1 := mload( add(_mpos, 160))
    if  cleanup_bool(iszero( fun_verifyTime_52219(_1,  mload( add(_mpos, 192)))))
    {
        var_orderHash :=  0x00
        var_newNumerator :=  0x00
        var_newDenominator :=  0x00
        leave
    }
    let _2 := add(_mpos, 128)
    let _3 := mload( _2)
    validator_assert_enum_OrderType(_3)
    validator_assert_enum_OrderType(_3)
    if  eq(_3,  4)
    {
        let expr_component, expr_component_1, expr_component_2 := fun_getGeneratedOrder_52220(_mpos,  mload(add(var_advancedOrder_mpos,  128)))
        var_orderHash := expr_component
        var_newNumerator := expr_component_1
        var_newDenominator := expr_component_2
        leave
    }
    let var_numerator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 32))))
    let var_denominator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 64))))
    let expr :=  gt(var_numerator, var_denominator)
    if iszero(expr)
    {
        expr :=  iszero(var_numerator)
    }
    if expr { fun_revertBadFraction() }
    let expr_1 :=  lt(var_numerator, var_denominator)
    if expr_1
    {
        let _4 := mload( _2)
        validator_assert_enum_OrderType(_4)
        expr_1 :=  iszero(and( _4,  1))
    }
    if expr_1
    {
        fun_revertPartialFillsNotEnabledForOrder()
    }
    var_orderHash :=  fun_assertConsiderationLengthAndGetOrderHash(_mpos)
    let _5 := mapping_index_access_mapping_bytes32_struct_OrderStatus_storage_of_bytes32(var_orderHash)
    if  cleanup_bool(iszero( fun_verifyOrderStatus(var_orderHash, _5)))
    {
        var_orderHash := var_orderHash
        var_newNumerator :=  0x00
        var_newDenominator :=  0x00
        leave
    }
    let _6 := sload( _5)
    if  iszero( and(_6, 0xff))
    {
        let _7 :=  cleanup_address(mload( _mpos))
        fun_verifySignature(_7, var_orderHash, mload(add(var_advancedOrder_mpos, 96)))
    }
    let _8 := 0xffffffffffffffffffffffffffffff
    let var_filledNumerator :=  and(shr(16, _6), _8)
    let _9 := shr(136, _6)
    switch  iszero(iszero(_9))
    case  0 {
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_numerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    default 
    {
        switch  eq(var_denominator,  0x01)
        case  0 {
            if  iszero(eq(_9, var_denominator))
            {
                var_filledNumerator := checked_mul_uint256(var_filledNumerator, var_denominator)
                var_numerator := checked_mul_uint256(var_numerator, _9)
                var_denominator := checked_mul_uint256(var_denominator, _9)
            }
        }
        default 
        {
            var_numerator := _9
            var_denominator := _9
        }
        if  gt( checked_add_uint256(var_filledNumerator, var_numerator),  var_denominator)
        {
            var_numerator :=  sub( var_denominator, var_filledNumerator)
        }
        let expr_2 := checked_add_uint256(var_filledNumerator, var_numerator)
        let var_filledNumerator_1 := expr_2
        var_filledNumerator := expr_2
        if or(gt(var_filledNumerator_1,  _8),  gt(var_denominator,  _8))
        {
            let usr$scaleDown := usr$gcd(var_numerator, usr$gcd(var_filledNumerator_1, var_denominator))
            let usr$safeScaleDown := add(usr$scaleDown, iszero(usr$scaleDown))
            var_numerator := div(var_numerator, usr$safeScaleDown)
            var_filledNumerator := div(var_filledNumerator_1, usr$safeScaleDown)
            var_denominator := div(var_denominator, usr$safeScaleDown)
            if or(gt(var_filledNumerator,  _8),  gt(var_denominator,  _8))
            {
                mstore( 0x00,  1313373041)
                mstore( 32,  17)
                revert(0x1c, 36)
            }
        }
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_filledNumerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    var_orderHash := var_orderHash
    var_newNumerator := var_numerator
    var_newDenominator := var_denominator
}

function fun_validateOrderAndUpdateStatus_39742(var_advancedOrder_mpos) -> var_orderHash, var_newNumerator, var_newDenominator
{
    let _mpos := mload(var_advancedOrder_mpos)
    let _1 := mload( add(_mpos, 160))
    if  cleanup_bool(iszero( fun_verifyTime(_1,  mload( add(_mpos, 192)))))
    {
        var_orderHash :=  0
        var_newNumerator :=  0
        var_newDenominator :=  0
        leave
    }
    let _2 := add(_mpos, 128)
    let _3 := mload( _2)
    validator_assert_enum_OrderType(_3)
    validator_assert_enum_OrderType(_3)
    if  eq(_3,  4)
    {
        let expr_component, expr_component_1, expr_component_2 := fun_getGeneratedOrder(_mpos,  mload(add(var_advancedOrder_mpos,  128)))
        var_orderHash := expr_component
        var_newNumerator := expr_component_1
        var_newDenominator := expr_component_2
        leave
    }
    let var_numerator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 32))))
    let var_denominator :=  cleanup_uint120( cleanup_uint120(mload( add(var_advancedOrder_mpos, 64))))
    let expr :=  gt(var_numerator, var_denominator)
    if iszero(expr)
    {
        expr :=  iszero(var_numerator)
    }
    if expr { fun_revertBadFraction() }
    let expr_1 :=  lt(var_numerator, var_denominator)
    if expr_1
    {
        let _4 := mload( _2)
        validator_assert_enum_OrderType(_4)
        expr_1 :=  iszero(and( _4,  0x01))
    }
    if expr_1
    {
        fun_revertPartialFillsNotEnabledForOrder()
    }
    var_orderHash :=  fun_assertConsiderationLengthAndGetOrderHash(_mpos)
    let _5 := mapping_index_access_mapping_bytes32_struct_OrderStatus_storage_of_bytes32(var_orderHash)
    if  cleanup_bool(iszero( fun_verifyOrderStatus_39751(var_orderHash, _5)))
    {
        var_orderHash := var_orderHash
        var_newNumerator :=  0
        var_newDenominator :=  0
        leave
    }
    let _6 := sload( _5)
    if  iszero( and(_6, 0xff))
    {
        let _7 :=  cleanup_address(mload( _mpos))
        fun_verifySignature(_7, var_orderHash, mload(add(var_advancedOrder_mpos, 96)))
    }
    let _8 := 0xffffffffffffffffffffffffffffff
    let var_filledNumerator :=  and(shr(16, _6), _8)
    let _9 := shr(136, _6)
    switch  iszero(iszero(_9))
    case  0 {
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_numerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    default 
    {
        switch  eq(var_denominator,  0x01)
        case  0 {
            if  iszero(eq(_9, var_denominator))
            {
                var_filledNumerator := checked_mul_uint256(var_filledNumerator, var_denominator)
                var_numerator := checked_mul_uint256(var_numerator, _9)
                var_denominator := checked_mul_uint256(var_denominator, _9)
            }
        }
        default 
        {
            var_numerator := _9
            var_denominator := _9
        }
        if  gt( checked_add_uint256(var_filledNumerator, var_numerator),  var_denominator)
        {
            var_numerator :=  sub( var_denominator, var_filledNumerator)
        }
        let expr_2 := checked_add_uint256(var_filledNumerator, var_numerator)
        let var_filledNumerator_1 := expr_2
        var_filledNumerator := expr_2
        if or(gt(var_filledNumerator_1,  _8),  gt(var_denominator,  _8))
        {
            let usr$scaleDown := usr$gcd(var_numerator, usr$gcd(var_filledNumerator_1, var_denominator))
            let usr$safeScaleDown := add(usr$scaleDown, iszero(usr$scaleDown))
            var_numerator := div(var_numerator, usr$safeScaleDown)
            var_filledNumerator := div(var_filledNumerator_1, usr$safeScaleDown)
            var_denominator := div(var_denominator, usr$safeScaleDown)
            if or(gt(var_filledNumerator,  _8),  gt(var_denominator,  _8))
            {
                mstore( 0,  1313373041)
                mstore( 32,  17)
                revert(0x1c, 36)
            }
        }
        update_storage_value_offsett_bool_to_bool_22589(_5)
        update_storage_value_offsett_bool_to_bool(_5)
        update_storage_value_offsett_uint120_to_uint120(_5,  and( var_filledNumerator,  _8))
        update_storage_value_offsett_uint120_to_t_uint120(_5,  and( var_denominator,  _8))
    }
    var_orderHash := var_orderHash
    var_newNumerator := var_numerator
    var_newDenominator := var_denominator
}

validateOrdersAndPrepareToFulfill.sol

/**
 * @dev Only differences (besides storing constants in variables for some reason) are: 
 *      - fun_validateOrderAndUpdateStatus_40131 vs fun_validateOrderAndUpdateStatus
 *      - fun_emitOrderFulfilledEvent_40132 vs fun_emitOrderFulfilledEvent
 */

function  fun_validateOrdersAndPrepareToFulfill(var_advancedOrders_mpos, var_criteriaResolvers_mpos, var_maximumFulfilled, var_recipient) -> var_orderHashes_mpos
{
    fun_setReentrancyGuard()
    let expr :=  mload( var_advancedOrders_mpos)
    var_orderHashes_mpos :=  allocate_and_zero_memory_array_array_bytes32_dyn(expr)
    let var_invalidNativeOfferItemErrorBuffer :=  0x00
    var_invalidNativeOfferItemErrorBuffer := shl(1, gt(mod(shr(224, calldataload( var_invalidNativeOfferItemErrorBuffer)),  69), 29))
    let var_i :=  0x00
    for { }
     lt(var_i, expr)
    {
        var_i :=  add( var_i,  1)
    }
    {
        let _mpos := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_advancedOrders_mpos, var_i))
        if  iszero(var_maximumFulfilled)
        {
            mstore( add(_mpos, 32),  0x00)
            continue
        }
        let expr_component, expr_component_1, expr_component_2 := fun_validateOrderAndUpdateStatus(_mpos)
        if  iszero(expr_component_1)
        {
            mstore( add(_mpos, 32),  0x00)
            continue
        }
        mstore( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i),  expr_component)
        var_maximumFulfilled :=  add( var_maximumFulfilled,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
        let _mpos_1 := mload(_mpos)
        let _1 := mload( add(_mpos_1, 160))
        let _2 := mload( add(_mpos_1, 192))
        let _mpos_2 := mload(add(_mpos_1, 64))
        let expr_1 :=  mload( _mpos_2)
        let var_j :=  0x00
        for { }
         lt(var_j, expr_1)
        {
            var_j :=  add( var_j,  1)
        }
        {
            let _mpos_3 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_2, var_j))
            var_invalidNativeOfferItemErrorBuffer := or(var_invalidNativeOfferItemErrorBuffer, iszero(mload(_mpos_3)))
            let _3 := add(_mpos_3, 128)
            let expr_2 := fun_getFraction(expr_component_1, expr_component_2,  mload( _3))
            let _4 := add(_mpos_3, 96)
            let _5 := mload( _4)
            switch  eq(_5,  mload( _3))
            case  0 {
                mstore(_4,  fun_getFraction(expr_component_1, expr_component_2,  _5))
            }
            default 
            {
                mstore(_4, expr_2)
            }
            let expr_3 := fun_locateCurrentAmount( mload( _4),  expr_2, _1, _2)
            mstore(_4, expr_3)
            mstore(_3, expr_3)
        }
        let _mpos_4 := mload(add( mload(_mpos),  96))
        let expr_4 :=  mload( _mpos_4)
        let var_j_1 :=  0x00
        for { }
         lt(var_j_1, expr_4)
        {
            var_j_1 :=  add( var_j_1,  1)
        }
        {
            let _mpos_5 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_4, var_j_1))
            let _6 := add(_mpos_5,  128)
            let expr_5 := fun_getFraction(expr_component_1, expr_component_2,  mload( _6))
            let _7 := add(_mpos_5,  96)
            let _8 := mload( _7)
            switch  eq(_8,  mload( _6))
            case  0 {
                mstore(_7,  fun_getFraction(expr_component_1, expr_component_2,  _8))
            }
            default 
            {
                mstore(_7, expr_5)
            }
            let _9 := fun_locateCurrentAmount_22788( mload( _7),  expr_5, _1, _2)
            mstore(_7, _9)
            let _10 := add(_mpos_5,  160)
            mstore(_6, mload(_10))
            mstore(_10, _9)
        }
    }
    if  eq(var_invalidNativeOfferItemErrorBuffer,  0x03)
    {
        fun_revertInvalidNativeOfferItem()
    }
    fun_applyCriteriaResolvers(var_advancedOrders_mpos, var_criteriaResolvers_mpos)
    let var_i_1 :=  0x00
    for { }
     lt(var_i_1, expr)
    {
        var_i_1 :=  add( var_i_1,  1)
    }
    {
        if  iszero( mload( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i_1)))
        {
            continue
        }
        let _mpos_6 := mload( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_advancedOrders_mpos, var_i_1)))
        let _11 := mload( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i_1))
        let _12 :=  cleanup_address(mload( _mpos_6))
        let _13 :=  cleanup_address(mload( add(_mpos_6, 32)))
        let _mpos_7 := mload(add(_mpos_6,  64))
        fun_emitOrderFulfilledEvent(_11, _12, _13, var_recipient, _mpos_7, mload(add(_mpos_6,  96)))
    }
}

function  fun_validateOrdersAndPrepareToFulfill_22804(var_advancedOrders_mpos, var_criteriaResolvers_mpos, var_maximumFulfilled) -> var_orderHashes_mpos
{
    fun_setReentrancyGuard()
    let expr :=  mload( var_advancedOrders_mpos)
    var_orderHashes_mpos :=  allocate_and_zero_memory_array_array_bytes32_dyn(expr)
    let var_invalidNativeOfferItemErrorBuffer :=  0
    let _1 := 0x01
    var_invalidNativeOfferItemErrorBuffer := shl( _1,  gt(mod(shr(224, calldataload( var_invalidNativeOfferItemErrorBuffer)),  69), 29))
    let var_i :=  0
    for { }
     lt(var_i, expr)
    {
        var_i :=  add( var_i,  _1)
    }
    {
        let _mpos := mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_advancedOrders_mpos, var_i))
        if  iszero(var_maximumFulfilled)
        {
            mstore( add(_mpos, 32),  0)
            continue
        }
        let expr_component, expr_component_1, expr_component_2 := fun_validateOrderAndUpdateStatus_40131(_mpos)
        if  iszero(expr_component_1)
        {
            mstore( add(_mpos, 32),  0)
            continue
        }
        mstore( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i),  expr_component)
        var_maximumFulfilled :=  add( var_maximumFulfilled,  0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
        let _mpos_1 := mload(_mpos)
        let _2 := 160
        let _3 := mload( add(_mpos_1, _2))
        let _4 := mload( add(_mpos_1, 192))
        let _mpos_2 := mload(add(_mpos_1, 64))
        let expr_1 :=  mload( _mpos_2)
        let var_j :=  0
        for { }
         lt(var_j, expr_1)
        {
            var_j :=  add( var_j,  _1)
        }
        {
            let _mpos_3 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_2, var_j))
            var_invalidNativeOfferItemErrorBuffer := or(var_invalidNativeOfferItemErrorBuffer, iszero(mload(_mpos_3)))
            let _5 := add(_mpos_3, 128)
            let expr_2 := fun_getFraction(expr_component_1, expr_component_2,  mload( _5))
            let _6 := add(_mpos_3, 96)
            let _7 := mload( _6)
            switch  eq(_7,  mload( _5))
            case  0 {
                mstore(_6,  fun_getFraction(expr_component_1, expr_component_2,  _7))
            }
            default 
            {
                mstore(_6, expr_2)
            }
            let expr_3 := fun_locateCurrentAmount( mload( _6),  expr_2, _3, _4)
            mstore(_6, expr_3)
            mstore(_5, expr_3)
        }
        let _8 := 96
        let _mpos_4 := mload(add( mload(_mpos),  _8))
        let expr_4 :=  mload( _mpos_4)
        let var_j_1 :=  0
        for { }
         lt(var_j_1, expr_4)
        {
            var_j_1 :=  add( var_j_1,  _1)
        }
        {
            let _mpos_5 := mload(memory_array_index_access_struct_AdvancedOrder_dyn(_mpos_4, var_j_1))
            let _9 := add(_mpos_5,  128)
            let expr_5 := fun_getFraction(expr_component_1, expr_component_2,  mload( _9))
            let _10 := add(_mpos_5,  _8)
            let _11 := mload( _10)
            switch  eq(_11,  mload( _9))
            case  0 {
                mstore(_10,  fun_getFraction(expr_component_1, expr_component_2,  _11))
            }
            default 
            {
                mstore(_10, expr_5)
            }
            let _12 := fun_locateCurrentAmount_22788( mload( _10),  expr_5, _3, _4)
            mstore(_10, _12)
            let _13 := add(_mpos_5,  _2)
            mstore(_9, mload(_13))
            mstore(_13, _12)
        }
    }
    if  eq(var_invalidNativeOfferItemErrorBuffer,  0x03)
    {
        fun_revertInvalidNativeOfferItem()
    }
    fun_applyCriteriaResolvers(var_advancedOrders_mpos, var_criteriaResolvers_mpos)
    let var_i_1 :=  0
    for { }
     lt(var_i_1, expr)
    {
        var_i_1 :=  add( var_i_1,  _1)
    }
    {
        if  iszero( mload( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i_1)))
        {
            continue
        }
        let _mpos_6 := mload( mload(memory_array_index_access_struct_AdvancedOrder_dyn(var_advancedOrders_mpos, var_i_1)))
        let _14 := mload( memory_array_index_access_struct_AdvancedOrder_dyn(var_orderHashes_mpos, var_i_1))
        let _15 :=  cleanup_address(mload( _mpos_6))
        let _16 :=  cleanup_address(mload( add(_mpos_6, 32)))
        let _mpos_7 := mload(add(_mpos_6,  64))
        fun_emitOrderFulfilledEvent_40132(_14, _15, _16, _mpos_7, mload(add(_mpos_6,  96)))
    }
}

verifyOrderStatus.sol

/**
 * @dev 
 *     fun_verifyOrderStatus_22485 vs fun_verifyOrderStatus_39751
 *     - name
 *     - valid is set to 1 vs 0x01 :|
 * 
 *     fun_verifyOrderStatus_22485 vs fun_verifyOrderStatus
 *     - short-circuits on invalid orders, only reverts if var_revertOnInvalid is true - but it is **always** false?
 */

function fun_verifyOrderStatus_22485(var_orderHash, var_orderStatus_slot) -> var_valid
{
    let _1 := sload( var_orderStatus_slot)
    if  and(shr(8, _1), 0xff)
    {
        mstore( 0,  441537908)
        mstore(32, var_orderHash)
        revert(28, 36)
    }
    let _2 := and(shr(16, _1), 0xffffffffffffffffffffffffffffff)
    if  iszero(iszero(_2))
    {
        if  iszero(lt(_2,  shr(136, _1)))
        {
            fun_revertOrderAlreadyFilled(var_orderHash)
        }
    }
    var_valid :=  1
}

function  fun_verifyOrderStatus_39751(var_orderHash, var_orderStatus_slot) -> var_valid
{
    let _1 := sload( var_orderStatus_slot)
    if  and(shr(8, _1), 0xff)
    {
        mstore( 0,  441537908)
        mstore(32, var_orderHash)
        revert(28, 36)
    }
    let _2 := and(shr(16, _1), 0xffffffffffffffffffffffffffffff)
    if  iszero(iszero(_2))
    {
        if  iszero(lt(_2,  shr(136, _1)))
        {
            fun_revertOrderAlreadyFilled(var_orderHash)
        }
    }
    var_valid :=  0x01
}

function  fun_verifyOrderStatus(var_orderHash, var_orderStatus_slot) -> var_valid
{
    let 
    var_revertOnInvalid :=  0x00
    let _1 := sload( var_orderStatus_slot)
    if  and(shr(8, _1), 0xff)
    {
        var_revertOnInvalid :=  var_revertOnInvalid
        var_valid :=  0x00
        leave
    }
    let _2 := and(shr(16, _1), 0xffffffffffffffffffffffffffffff)
    if  iszero(iszero(_2))
    {
        if  iszero(lt(_2,  shr(136, _1)))
        {
            if var_revertOnInvalid
            {
                fun_revertOrderAlreadyFilled(var_orderHash)
            }
            var_valid :=  0x00
            leave
        }
    }
    var_valid :=  0x01
}

verifyTime.sol

/**
 * @dev og reverts - 52219 does not
 */
function fun_verifyTime(var_startTime, var_endTime) -> var_valid
{
    var_valid := and(iszero(gt(var_startTime, timestamp())), gt(var_endTime, timestamp()))
    if  iszero(var_valid)
    {
        mstore(0, 1870572582)
        revert(28, 4)
    }
}
function fun_verifyTime_52219(var_startTime, var_endTime) -> var_valid
{
    var_valid := and(iszero(gt(var_startTime, timestamp())), gt(var_endTime, timestamp()))
}