-- name: Character Movesets
-- incompatible: moveset
-- description: Gives each character unique abilities and stats.\n\nContributors: djoslin0, TheGag96, Draco, steven.

ANGLE_QUEUE_SIZE = 9
SPIN_TIMER_SUCCESSFUL_INPUT = 4

gEventTable = {}

gStateExtras = {}
for i = 0, (MAX_PLAYERS - 1) do
    gStateExtras[i] = {}
    local m = gMarioStates[i]
    local e = gStateExtras[i]
    e.prevPos = {}
    e.prevPos.x = 0
    e.prevPos.y = 0
    e.prevPos.z = 0
    e.angleDeltaQueue = {}
    for j = 0, (ANGLE_QUEUE_SIZE - 1) do e.angleDeltaQueue[j] = 0 end
    e.lastAction = m.action
    e.animFrame = 0
    e.animArg = 0
    e.scuttle = 0
    e.averageForwardVel = 0
    e.boostTimer = 0
    e.rotAngle = 0
    e.lastHurtCounter = 0
    e.stickLastAngle = 0
    e.spinDirection = 0
    e.spinBufferTimer = 0
    e.spinInput = 0
    e.lastIntendedMag = 0
    e.swims = 0
end

local charmov = 1

-----------
-- mario --
-----------
ACT_HANDSTAND_MOVING           = allocate_mario_action(ACT_GROUP_MOVING | ACT_FLAG_MOVING)
ACT_HANDSTAND_IDLE             = allocate_mario_action(ACT_GROUP_STATIONARY | ACT_FLAG_STATIONARY | ACT_FLAG_IDLE)
ACT_HANDSTAND_JUMP             = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)
ACT_HANDSTAND_JUMP_LAND        = allocate_mario_action(ACT_GROUP_STATIONARY | ACT_FLAG_STATIONARY)
ACT_HANDSTAND_SECOND_JUMP_LAND = allocate_mario_action(ACT_GROUP_STATIONARY | ACT_FLAG_STATIONARY)

function act_handstand_idle(m)
    if (m.quicksandDepth > 30.0) then
        return drop_and_set_mario_action(m, ACT_IN_QUICKSAND, 0)
    end

    if (m.input & INPUT_NONZERO_ANALOG) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_MOVING, 0)
    end

	if (m.input & INPUT_A_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_JUMP, 1)
    end

    if (m.input & INPUT_Z_DOWN) == 0 then
        return set_mario_action(m, ACT_STOP_CROUCHING, 0)
    end

    if (m.input & INPUT_ABOVE_SLIDE) ~= 0 then
        return set_mario_action(m, ACT_BEGIN_SLIDING, 0)
    end

    stationary_ground_step(m)
    set_character_animation(m, CHAR_ANIM_IDLE_WITH_LIGHT_OBJ)
    smlua_anim_util_set_animation(m.marioObj, "MARIO_ANIM_HANDSTAND_IDLE")
    return false
end

function act_handstand_jump(m)
    local e = gStateExtras[m.playerIndex]
	local animation = MARIO_ANIM_DOUBLE_JUMP_RISE
	local landAction = ACT_HANDSTAND_JUMP_LAND
	local voiceline = ACT_HANDSTAND_JUMP_LAND
	
	if m.actionArg == 0 then
	    animation = MARIO_ANIM_DOUBLE_JUMP_RISE
	    landAction = ACT_HANDSTAND_JUMP_LAND
	    voiceline = CHAR_SOUND_YAH_WAH_HOO
        smlua_anim_util_set_animation(m.marioObj, "MARIO_ANIM_HANDSTAND_JUMP_1")
	elseif m.actionArg == 1 then
	    animation = MARIO_ANIM_DOUBLE_JUMP_RISE
	    landAction = ACT_HANDSTAND_SECOND_JUMP_LAND
        smlua_anim_util_set_animation(m.marioObj, "MARIO_ANIM_HANDSTAND_JUMP_2")
	    voiceline = CHAR_SOUND_HOOHOO
	elseif m.actionArg == 2 then
	    animation = MARIO_ANIM_FORWARD_SPINNING
	    voiceline = CHAR_SOUND_YAHOO_WAHA_YIPPEE
	    landAction = ACT_TRIPLE_JUMP_LAND
		play_flip_sounds(m, 4, 4, 4)
    end
	
    if m.actionTimer == 0 then
        play_character_sound(m, voiceline)
        m.faceAngle.y = m.intendedYaw
    end

    local stepResult = common_air_action_step(m, ACT_HANDSTAND_JUMP_LAND, animation, 
                                                                AIR_STEP_CHECK_LEDGE_GRAB | AIR_STEP_CHECK_HANG)

    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_GROUND_POUND, 0)
    end
    
    if stepResult == AIR_STEP_LANDED then
        if should_get_stuck_in_ground(m) ~= 0 then
            queue_rumble_data_mario(m, 5, 80)
            play_sound(SOUND_MARIO_OOOF2, m.marioObj.header.gfx.cameraToObject)
            m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
            set_mario_action(m, ACT_FEET_STUCK_IN_GROUND, 0)
        else
            play_sound(SOUND_ACTION_TERRAIN_LANDING, m.marioObj.header.gfx.cameraToObject)
            set_mario_action(m, landAction, 0)
        end
    end
	
	if m.forwardVel > 16 then mario_set_forward_vel(m, 16) end
    
    m.actionTimer = m.actionTimer + 1
    return 0
end

function act_handstand_jump_land(m)
    landing_step(m, CHAR_ANIM_LAND_FROM_DOUBLE_JUMP, ACT_HANDSTAND_IDLE)

    if (m.input & INPUT_ABOVE_SLIDE) ~= 0 then
        return set_mario_action(m, ACT_BEGIN_SLIDING, 0)
    end

    smlua_anim_util_set_animation(m.marioObj, "MARIO_ANIM_HANDSTAND_LAND")
	if (m.input & INPUT_A_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_JUMP, 1)
    end

    return false
end

function act_handstand_second_jump_land(m)
    landing_step(m, CHAR_ANIM_LAND_FROM_DOUBLE_JUMP, ACT_IDLE)

    if (m.input & INPUT_ABOVE_SLIDE) ~= 0 then
        return set_mario_action(m, ACT_BEGIN_SLIDING, 0)
    end

	if (m.input & INPUT_A_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_JUMP, 2)
    end

    return false
end

function act_handstand_moving(m)
    local val04

    if (should_begin_sliding(m)) ~= 0 then
        return set_mario_action(m, ACT_BEGIN_SLIDING, 0)
    end

    if (m.input & INPUT_FIRST_PERSON) ~= 0 then
        return set_mario_action(m, ACT_STOP_CROUCHING, 0)
    end

    if (m.input & INPUT_ZERO_MOVEMENT) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_IDLE, 0)
    end

    if (m.input & INPUT_Z_DOWN) == 0 then
        return set_mario_action(m, ACT_STOP_CROUCHING, 0)
    end

	if (m.input & INPUT_A_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_HANDSTAND_JUMP, 1)
    end

    m.intendedMag = m.intendedMag * 0.3

    update_walking_speed(m)

    local stepResult = perform_ground_step(m)

    if stepResult == GROUND_STEP_LEFT_GROUND then
        set_mario_action(m, ACT_FREEFALL, 0)

    elseif stepResult ==  GROUND_STEP_HIT_WALL then
        if (m.forwardVel > 10.0) then
            mario_set_forward_vel(m, 10.0)
        end

    elseif stepResult == GROUND_STEP_NONE then
        align_with_floor(m)
    end

    val04 = (m.intendedMag * 0x5000)
    set_character_anim_with_accel(m, CHAR_ANIM_CRAWLING, val04)
    smlua_anim_util_set_animation(m.marioObj, "MARIO_ANIM_HANDSTAND_WALK")
    play_step_sound(m, 20, 40)
    return false
end

function mario_on_set_action(m)
    if m.action == ACT_HANDSTAND_JUMP then
        if m.actionArg == 0 then
            m.vel.y = 50
        elseif m.actionArg == 1 then
            m.vel.y = 70
        elseif m.actionArg == 2 then
            m.vel.y = 90
        end
    end

    if m.action == ACT_JUMP and m.prevAction == ACT_CRAWLING then
        set_mario_action(m, ACT_HANDSTAND_JUMP, 0)
    end
end

function mario_update(m)
end

gEventTable[CT_MARIO] = {
    before_phys_step = nil,
    on_set_action    = mario_on_set_action,
    update           = mario_update,
}
-----------
-- luigi --
-----------

ACT_SPIN_POUND_LAND = allocate_mario_action(ACT_GROUP_STATIONARY | ACT_FLAG_STATIONARY | ACT_FLAG_ATTACKING)
ACT_SPIN_POUND      = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ATTACKING)

function act_spin_pound(m)
    local e = gStateExtras[m.playerIndex]
    if m.actionTimer == 0 then
        m.actionState = m.actionArg
    end

    local spinDirFactor = 1  -- negative for clockwise, positive for counter-clockwise
    if m.actionState == 1 then spinDirFactor = -1 end

    set_mario_animation(m, MARIO_ANIM_TWIRL)

    m.particleFlags = m.particleFlags | PARTICLE_DUST

    if (m.controller.buttonDown & Z_TRIG) == 0 then
        set_mario_action(m, ACT_TWIRLING, 5)
    end

    local stepResult = perform_air_step(m, 0)
    if stepResult == AIR_STEP_LANDED then
        if should_get_stuck_in_ground(m) ~= 0 then
            queue_rumble_data_mario(m, 5, 80)
            play_character_sound(m, CHAR_SOUND_OOOF2)
            m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
            set_mario_action(m, ACT_BUTT_STUCK_IN_GROUND, 0)
        else
            play_mario_heavy_landing_sound(m, SOUND_ACTION_TERRAIN_HEAVY_LANDING)
            if check_fall_damage(m, ACT_HARD_BACKWARD_GROUND_KB) == 0 then
                m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE | PARTICLE_HORIZONTAL_STAR
                set_mario_action(m, ACT_SPIN_POUND_LAND, 0)
            end
        end
        set_camera_shake_from_hit(SHAKE_GROUND_POUND)
    elseif stepResult == AIR_STEP_HIT_WALL then
        mario_set_forward_vel(m, -16.0)
        if m.vel.y > 0.0 then
            m.vel.y = 0.0
        end

        m.particleFlags = m.particleFlags | PARTICLE_VERTICAL_STAR
        set_mario_action(m, ACT_BACKWARD_AIR_KB, 0)
    end

    -- set facing direction
    -- not part of original Extended Moveset
    local yawDiff = m.faceAngle.y - m.intendedYaw
    e.rotAngle = e.rotAngle + yawDiff
    m.faceAngle.y = m.intendedYaw

    e.rotAngle = e.rotAngle + 0x3053
    if e.rotAngle >  0x10000 then e.rotAngle = e.rotAngle - 0x10000 end
    if e.rotAngle < -0x10000 then e.rotAngle = e.rotAngle + 0x10000 end
    m.marioObj.header.gfx.angle.y = m.marioObj.header.gfx.angle.y + e.rotAngle * spinDirFactor
    m.marioBodyState.handState = MARIO_HAND_OPEN

    m.actionTimer = m.actionTimer + 1

    return 0
end

function act_spin_pound_land(m)
    m.actionState = 1

    if m.actionTimer <= 8 then
        if (m.input & INPUT_UNKNOWN_10) ~= 0 then
            return drop_and_set_mario_action(m, ACT_SHOCKWAVE_BOUNCE, 0)
        end

        if (m.input & INPUT_OFF_FLOOR) ~= 0 then
            return set_mario_action(m, ACT_FREEFALL, 0)
        end

        if (m.input & INPUT_ABOVE_SLIDE) ~= 0 then
            return set_mario_action(m, ACT_BUTT_SLIDE, 0)
        end

        stationary_ground_step(m)
        set_mario_animation(m, MARIO_ANIM_LAND_FROM_DOUBLE_JUMP)
    else
        if (m.input & INPUT_UNKNOWN_10) ~= 0 then
            return set_mario_action(m, ACT_SHOCKWAVE_BOUNCE, 0)
        end

        if (m.input & (INPUT_NONZERO_ANALOG | INPUT_A_PRESSED | INPUT_OFF_FLOOR | INPUT_ABOVE_SLIDE)) ~= 0 then
            return check_common_action_exits(m)
        end

        stopping_step(m, MARIO_ANIM_LAND_FROM_DOUBLE_JUMP, ACT_IDLE)
    end

    m.actionTimer = m.actionTimer + 1

    return 0
end

function luigi_before_phys_step(m)
    local e = gStateExtras[m.playerIndex]

    local floorClass = mario_get_floor_class(m)
    local hScale = 1.0
    local vScale = 1.0

    -- faster swimming
    if (m.action & ACT_FLAG_SWIMMING) ~= 0 then
        if m.action ~= ACT_BACKWARD_WATER_KB and m.action ~= ACT_FORWARD_WATER_KB then
            hScale = hScale * 1.5
            if m.action ~= ACT_WATER_PLUNGE then
                vScale = vScale * 1.5
            end
        end
    end

    -- slower holding item
    if m.heldObj ~= nil then
        m.vel.y = m.vel.y - 1.0
        hScale = hScale * 0.9
        if (m.action & ACT_FLAG_AIR) ~= 0 then
            hScale = hScale * 0.9
        end
    end

    -- acceleration
    if (m.action == ACT_WALKING) then
        if (floorClass == 19 or floorClass == 20) then
            hScale = -(m.forwardVel / 64) + 1.5
        else
            hScale = (m.forwardVel / 64) + 0.5
        end
    end

    -- friction
    if (m.action == ACT_BRAKING or m.action == ACT_TURNING_AROUND) then
        if (floorClass == 19 or floorClass == 20) then
            m.forwardVel = m.forwardVel - 3
        elseif (floorClass == 21) then
            hScale = hScale * 1.5
            m.forwardVel = m.forwardVel + (hScale * 2)
        else
            hScale = hScale * 1.4
            m.forwardVel = m.forwardVel + hScale
        end
        if (m.forwardVel < 0) then
            m.forwardVel = 0
        end
    end

    m.vel.x = m.vel.x * hScale
    m.vel.y = m.vel.y * vScale
    m.vel.z = m.vel.z * hScale
end

function luigi_on_set_action(m)
    local e = gStateExtras[m.playerIndex]

    -- extra height to the backflip
    if m.action == ACT_BACKFLIP then
        m.vel.y = m.vel.y + 18

    -- nerf wall kicks
    elseif m.action == ACT_WALL_KICK_AIR and m.prevAction ~= ACT_HOLDING_POLE and m.prevAction ~= ACT_CLIMBING_POLE then
        if m.vel.y > 56 then m.vel.y = 56 end
        return

    -- turn dive into kick when holding jump
    elseif m.action == ACT_DIVE and (m.controller.buttonDown & A_BUTTON) ~= 0 and e.scuttle > 0 then
        return set_mario_action(m, ACT_JUMP_KICK, 0)

    -- extra height on jumps
    elseif m.action == ACT_JUMP or m.action == ACT_DOUBLE_JUMP or m.action == ACT_TRIPLE_JUMP or m.action == ACT_SPECIAL_TRIPLE_JUMP or m.action == ACT_STEEP_JUMP or m.action == ACT_SIDE_FLIP or m.action == ACT_RIDING_SHELL_JUMP then
        m.vel.y = m.vel.y + 6

    end

    e.lastAction = action
end

function luigi_update(m)
    local e = gStateExtras[m.playerIndex]

    -- increase player damage
    if (m.hurtCounter > e.lastHurtCounter) then
        m.hurtCounter = m.hurtCounter + 4
    end
    e.lastHurtCounter = m.hurtCounter

    -- air scuttle
    e.scuttle = 0
    local shouldScuttle = (m.action == ACT_JUMP or m.action == ACT_DOUBLE_JUMP or m.action == ACT_HOLD_JUMP) and ((m.controller.buttonDown & A_BUTTON) ~= 0 and m.vel.y < -5)
    if shouldScuttle then
        -- prevent wing flutter from glitching out while scuttling
        if m.marioBodyState.wingFlutter == 1 then
            m.vel.y = m.vel.y + 1
        else
            m.vel.y = m.vel.y + 3
            set_mario_animation(m, MARIO_ANIM_RUNNING_UNUSED)
            if m.action == ACT_HOLD_JUMP then
                smlua_anim_util_set_animation(m.marioObj, "LUIGI_ANIM_FLUTTER_HOLD")
            else
                smlua_anim_util_set_animation(m.marioObj, "LUIGI_ANIM_FLUTTER")
            end
            set_anim_to_frame(m, e.animFrame)
            e.animFrame = e.animFrame + 4
            if e.animFrame >= m.marioObj.header.gfx.animInfo.curAnim.loopEnd then
                e.animFrame = e.animFrame - m.marioObj.header.gfx.animInfo.curAnim.loopEnd
            end
            e.scuttle = 1
        end
    end

    -- twirl pound
    if m.action == ACT_TWIRLING and (m.controller.buttonDown & Z_TRIG) ~= 0 then
        set_mario_action(m, ACT_SPIN_POUND, 0)
    end

    -- backflip turns into twirl
    if m.action == ACT_BACKFLIP and m.marioObj.header.gfx.animInfo.animFrame > 18 then
        m.angleVel.y = 0x1800
        set_mario_action(m, ACT_TWIRLING, 1)
    end
end

gEventTable[CT_LUIGI] = {
    before_phys_step = luigi_before_phys_step,
    on_set_action    = luigi_on_set_action,
    update           = luigi_update,
}

-----------
-- toad --
-----------

function toad_before_phys_step(m)
    local e = gStateExtras[m.playerIndex]

    local hScale = 1.0
    local vScale = 1.0

    -- faster ground movement
    if (m.action & ACT_FLAG_MOVING) ~= 0 then
        hScale = hScale * 1.19
    end

    -- slower holding item
    if m.heldObj ~= nil then
        m.vel.y = m.vel.y - 2.0
        hScale = hScale * 0.9
        if (m.action & ACT_FLAG_AIR) ~= 0 then
            hScale = hScale * 0.9
        end
    end

    m.vel.x = m.vel.x * hScale
    m.vel.y = m.vel.y * vScale
    m.vel.z = m.vel.z * hScale
end

function toad_on_set_action(m)
    local e = gStateExtras[m.playerIndex]

    -- wall kick height based on how fast toad is going
    if m.action == ACT_WALL_KICK_AIR and m.prevAction ~= ACT_HOLDING_POLE and m.prevAction ~= ACT_CLIMBING_POLE then
        m.vel.y = m.vel.y * 0.5
        m.vel.y = m.vel.y + e.averageForwardVel * 0.7
        return
    end

    -- more distance on dive and long jump
    if m.action == ACT_DIVE or m.action == ACT_LONG_JUMP then
        m.forwardVel = m.forwardVel * 1.35
    end

    -- less height on jumps
    if m.action == ACT_JUMP or m.action == ACT_DOUBLE_JUMP or m.action == ACT_TRIPLE_JUMP or m.action == ACT_SPECIAL_TRIPLE_JUMP or m.action == ACT_STEEP_JUMP or m.action == ACT_RIDING_SHELL_JUMP or m.action == ACT_BACKFLIP or m.action == ACT_WALL_KICK_AIR  or m.action == ACT_LONG_JUMP then
        m.vel.y = m.vel.y * 0.8

        -- prevent from getting stuck on platform
        if m.marioObj.platform ~= nil then
            m.pos.y = m.pos.y + 10
        end
    elseif m.action == ACT_SIDE_FLIP then
        m.vel.y = m.vel.y * 0.86

        -- prevent from getting stuck on platform
        if m.marioObj.platform ~= nil then
            m.pos.y = m.pos.y + 10
        end
    end

    e.lastAction = action
end

function toad_update(m)
    local e = gStateExtras[m.playerIndex]

    -- track average forward velocity
    if e.averageForwardVel > m.forwardVel then
        e.averageForwardVel = e.averageForwardVel * 0.93 + m.forwardVel * 0.07
    else
        e.averageForwardVel = m.forwardVel
    end
    
    -- keep your momentum for a while
    if m.action == ACT_WALKING and m.forwardVel > 30 then
        mario_set_forward_vel(m, m.forwardVel + 0.8)
    end

    -- faster flip during ground pound
    if m.action == ACT_GROUND_POUND then
        if m.actionTimer < 10 then
            m.actionTimer = m.actionTimer + 1
        end
    end

    -- ground pound jump
    if m.action == ACT_GROUND_POUND_LAND and (m.input & INPUT_A_PRESSED) ~= 0 then
        set_mario_action(m, ACT_TRIPLE_JUMP, 0)
        m.vel.y = m.vel.y + 18
        m.forwardVel = m.forwardVel + 10
    end

end

gEventTable[CT_TOAD] = {
    before_phys_step = toad_before_phys_step,
    on_set_action    = toad_on_set_action,
    update           = toad_update,
}

-------------
-- waluigi --
-------------

ACT_WALL_SLIDE       = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_MOVING | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)
ACT_ELEGANT_JUMP     = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION | ACT_FLAG_CONTROL_JUMP_HEIGHT)
ACT_WALUIGI_AIR_SWIM = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_MOVING | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)

function act_wall_slide(m)
    if (m.input & INPUT_A_PRESSED) ~= 0 then
        local rc = set_mario_action(m, ACT_TRIPLE_JUMP, 0)
        m.vel.y = 72.0

        if m.forwardVel < 20.0 then
            m.forwardVel = 20.0
        end
        m.wallKickTimer = 0
        return rc
    end

    -- attempt to stick to the wall a bit. if it's 0, sometimes you'll get kicked off of slightly sloped walls
    mario_set_forward_vel(m, -1.0)

    m.particleFlags = m.particleFlags | PARTICLE_DUST

    play_sound(SOUND_MOVING_TERRAIN_SLIDE + m.terrainSoundAddend, m.marioObj.header.gfx.cameraToObject)
    set_mario_animation(m, MARIO_ANIM_START_WALLKICK)

    if perform_air_step(m, 0) == AIR_STEP_LANDED then
        mario_set_forward_vel(m, 0.0)
        if check_fall_damage_or_get_stuck(m, ACT_HARD_BACKWARD_GROUND_KB) == 0 then
            return set_mario_action(m, ACT_FREEFALL_LAND, 0)
        end
    end

    m.actionTimer = m.actionTimer + 1
    if m.wall == nil and m.actionTimer > 2 then
        mario_set_forward_vel(m, 0.0)
        return set_mario_action(m, ACT_FREEFALL, 0)
    end

    -- gravity
    m.vel.y = m.vel.y + 2

    return 0
end

function act_elegant_jump(m)
    local e = gStateExtras[m.playerIndex]
    if m.actionTimer == 0 then
        m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
        e.animFrame = 68
        play_character_sound(m, CHAR_SOUND_HAHA)
        e.rotAngle = m.faceAngle.y
        e.animArg = math.floor(math.random(1,2))
    end
    local stepResult = common_air_action_step(m, ACT_DOUBLE_JUMP_LAND, MARIO_ANIM_RUNNING_UNUSED, 
                                                                AIR_STEP_CHECK_LEDGE_GRAB | AIR_STEP_CHECK_HANG)
    smlua_anim_util_set_animation(m.marioObj, "WALUIGI_ANIM_ELEGANT_JUMP_" .. tostring(e.animArg))
    m.particleFlags = m.particleFlags | PARTICLE_SPARKLES
    m.marioBodyState.eyeState = MARIO_EYES_CLOSED
    m.faceAngle.y = m.intendedYaw
    
    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_GROUND_POUND, 0)
    end
    
    if (m.input & INPUT_NONZERO_ANALOG) ~= 0 then
        mario_set_forward_vel(m, math.abs(m.forwardVel))
    end
    
    if stepResult == AIR_STEP_LANDED then
        if should_get_stuck_in_ground(m) ~= 0 then
            queue_rumble_data_mario(m, 5, 80)
            play_sound(SOUND_MARIO_OOOF2, m.marioObj.header.gfx.cameraToObject)
            m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
            set_mario_action(m, ACT_FEET_STUCK_IN_GROUND, 0)
        else
            play_sound(SOUND_ACTION_TERRAIN_LANDING, m.marioObj.header.gfx.cameraToObject)
            set_mario_action(m, ACT_DOUBLE_JUMP_LAND, 0)
        end
    end
    
    e.rotAngle = e.rotAngle + 0x2000
    m.marioObj.header.gfx.angle.y = e.rotAngle
    
    m.actionTimer = m.actionTimer + 1
    return 0
end

function act_waluigi_air_swim(m)
    local e = gStateExtras[m.playerIndex]
    
    if m.actionTimer == 0 then
        e.animFrame = 0
        play_sound(SOUND_ACTION_SWIM_FAST, m.marioObj.header.gfx.cameraToObject)
        if m.forwardVel <= 40 then 
            mario_set_forward_vel(m, 40)
        else
            mario_set_forward_vel(m, m.forwardVel + 5)
        end
    end
    
    if m.actionTimer >= 20 then
        set_mario_action(m, ACT_DIVE, 0)
        m.vel.y = 0
        m.faceAngle.x = 0
        mario_set_forward_vel(m, 0)
    end
    
    if m.actionTimer > 10 and (m.controller.buttonPressed & B_BUTTON) ~= 0 and e.swims > 0 then
        e.swims = e.swims - 1
        return set_mario_action(m, ACT_WALUIGI_AIR_SWIM, 0)
    end
    
    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_GROUND_POUND, 0)
    end
    
    m.vel.y = 0
    
    if e.animFrame >= m.marioObj.header.gfx.animInfo.curAnim.loopEnd then
        e.animFrame = m.marioObj.header.gfx.animInfo.curAnim.loopEnd
    end
    
    set_mario_animation(m, MARIO_ANIM_SWIM_PART1)
    set_anim_to_frame(m, e.animFrame)
    
    local stepResult = perform_air_step(m, 0)
    if stepResult == AIR_STEP_LANDED then
        if should_get_stuck_in_ground(m) ~= 0 then
            queue_rumble_data_mario(m, 5, 80)
            play_character_sound(m, CHAR_SOUND_OOOF2)
            set_mario_action(m, ACT_FEET_STUCK_IN_GROUND, 0)
        else
            if check_fall_damage(m, ACT_SQUISHED) == 0 then
                set_mario_action(m, ACT_DIVE_SLIDE, 0)
            end
        end
    elseif stepResult == AIR_STEP_HIT_WALL then
        set_mario_action(m, ACT_SOFT_BONK, 0)
    end
    
    if m.forwardVel > 4 then mario_set_forward_vel(m, m.forwardVel - 2) end
    e.animFrame = e.animFrame + 1
    m.actionTimer = m.actionTimer + 1
    m.faceAngle.y = m.intendedYaw - approach_s32(convert_s16(m.intendedYaw - m.faceAngle.y), 0, 0x200, 0x200)
    return 0
end

function waluigi_before_phys_step(m)
    local e = gStateExtras[m.playerIndex]

    local hScale = 1.0
    local vScale = 1.0

    -- faster ground movement
    if (m.action & ACT_FLAG_MOVING) ~= 0 then
        hScale = hScale * 1.09
    end

    m.vel.x = m.vel.x * hScale
    m.vel.y = m.vel.y * vScale
    m.vel.z = m.vel.z * hScale

    if m.action == ACT_TRIPLE_JUMP and m.prevAction == ACT_DOUBLE_JUMP and m.actionTimer < 6 then
        m.particleFlags = m.particleFlags | PARTICLE_DUST
        m.actionTimer = m.actionTimer + 1
    end
end

function waluigi_on_set_action(m)
    local e = gStateExtras[m.playerIndex]

    -- wall slide
    if m.action == ACT_SOFT_BONK then
        m.faceAngle.y = m.faceAngle.y + 0x8000
        set_mario_action(m, ACT_WALL_SLIDE, 0)
        m.vel.x = 0
        m.vel.y = 0
        m.vel.z = 0

    -- turn wall kick into flip
    elseif m.action == ACT_WALL_KICK_AIR and m.prevAction ~= ACT_HOLDING_POLE and m.prevAction ~= ACT_CLIMBING_POLE then
        local rc = set_mario_action(m, ACT_TRIPLE_JUMP, 0)
        m.vel.y = 60.0

        if m.forwardVel < 20.0 then
            m.forwardVel = 20.0
        end
        m.wallKickTimer = 0
        return rc

    -- less height on jumps
    elseif m.action == ACT_JUMP or m.action == ACT_DOUBLE_JUMP or m.action == ACT_TRIPLE_JUMP or m.action == ACT_SPECIAL_TRIPLE_JUMP or m.action == ACT_STEEP_JUMP or m.action == ACT_SIDE_FLIP or m.action == ACT_RIDING_SHELL_JUMP or m.action == ACT_BACKFLIP or m.action == ACT_WALL_KICK_AIR  or m.action == ACT_LONG_JUMP then
        m.vel.y = m.vel.y * 0.9
    end

    -- more height on triple jump
    if m.action == ACT_TRIPLE_JUMP or m.action == ACT_SPECIAL_TRIPLE_JUMP then
        m.vel.y = m.vel.y * 1.25
    end
    
    if m.action == ACT_ELEGANT_JUMP then
        m.vel.y = 60
    end

    e.lastAction = action
end

function waluigi_update(m)
    local e = gStateExtras[m.playerIndex]

    -- increase player damage (go easy on the capless players)
    if m.hurtCounter > e.lastHurtCounter then
        if m.flags & (MARIO_NORMAL_CAP | MARIO_CAP_ON_HEAD) == 0 then
            m.hurtCounter = m.hurtCounter + 6
        else
            m.hurtCounter = m.hurtCounter + 8
        end
    end
    e.lastHurtCounter = m.hurtCounter

    -- double jump
    local shouldDoubleJump = (m.action == ACT_DOUBLE_JUMP or m.action == ACT_JUMP or m.action == ACT_SIDE_FLIP or m.action == ACT_BACKFLIP or m.action == ACT_FREEFALL)
    
    if shouldDoubleJump and m.actionTimer > 0 and (m.controller.buttonPressed & A_BUTTON) ~= 0 then
        return set_mario_action(m, ACT_ELEGANT_JUMP, 0)
    end
    if shouldDoubleJump then
        m.actionTimer = m.actionTimer + 1
    end

    -- swim mid-air
    if m.action == ACT_DIVE and m.actionTimer > 0 and (m.controller.buttonPressed & B_BUTTON) ~= 0 and e.swims > 0 then
        e.swims = e.swims - 1
        return set_mario_action(m, ACT_WALUIGI_AIR_SWIM, 0)
    end
    if (m.action & ACT_GROUP_AIRBORNE) == 0  then
        e.swims = 3
    end

    if m.action == ACT_DIVE then
        m.actionTimer = m.actionTimer + 1
        if m.prevAction == ACT_WALUIGI_AIR_SWIM then
            set_mario_animation(m, MARIO_ANIM_SWIM_PART1)
            set_anim_to_frame(m, 30)
        end
    end
end

gEventTable[CT_WALUIGI] = {
    before_phys_step = waluigi_before_phys_step,
    on_set_action    = waluigi_on_set_action,
    update           = waluigi_update,
}

-----------
-- wario --
-----------

ACT_WARIO_DASH             = allocate_mario_action(ACT_GROUP_MOVING | ACT_FLAG_MOVING | ACT_FLAG_ATTACKING)
ACT_WARIO_AIR_DASH         = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ATTACKING)
ACT_WARIO_DASH_REBOUND     = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR)
ACT_PILEDRIVER             = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ATTACKING | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)
ACT_PILEDRIVER_LAND        = allocate_mario_action(ACT_GROUP_MOVING | ACT_FLAG_MOVING | ACT_FLAG_ATTACKING)
ACT_WARIO_HOLD_JUMP        = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)
ACT_WARIO_HOLD_FREEFALL    = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION)
ACT_CORKSCREW_CONK         = allocate_mario_action(ACT_GROUP_AIRBORNE | ACT_FLAG_AIR | ACT_FLAG_ATTACKING | ACT_FLAG_ALLOW_VERTICAL_WIND_ACTION | ACT_FLAG_CONTROL_JUMP_HEIGHT)
ACT_WARIO_SPINNING_OBJ     = allocate_mario_action(ACT_GROUP_OBJECT | ACT_FLAG_STATIONARY)

function act_corkscrew_conk(m)
    local e = gStateExtras[m.playerIndex]

    -- visuals
    m.particleFlags = m.particleFlags | PARTICLE_DUST

    -- physics
    common_air_action_step(m, ACT_JUMP_LAND, MARIO_ANIM_FORWARD_SPINNING, AIR_STEP_NONE)

    -- animation
    set_anim_to_frame(m, e.animFrame)
    if e.animFrame >= m.marioObj.header.gfx.animInfo.curAnim.loopEnd then
        e.animFrame = e.animFrame - m.marioObj.header.gfx.animInfo.curAnim.loopEnd
    end

    -- fast ground pound out of it
    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        local rc = set_mario_action(m, ACT_GROUND_POUND, 0)
        m.actionTimer = 5
        return rc
    end

    -- timers
    m.actionTimer = m.actionTimer + 1
    e.animFrame = e.animFrame + 1

    return 0
end

function act_wario_dash(m)
    local e = gStateExtras[m.playerIndex]
    m.marioBodyState.eyeState = 5

    -- make sound
    if m.actionTimer == 0 then
        m.actionState = m.actionArg
        play_character_sound(m, CHAR_SOUND_WAH2)
    end

    -- walk once dash is up
    if m.actionTimer > 30 then
        return set_mario_action(m, ACT_WALKING, 0)
    end

    -- physics
    local stepResult = perform_ground_step(m)
    if stepResult == GROUND_STEP_HIT_WALL then
        if m.wall.object == nil or m.wall.object.oInteractType & (INTERACT_BREAKABLE) == 0 then
            return wario_rebound(m, -40, 30)
        end
    elseif stepResult == GROUND_STEP_LEFT_GROUND then
        m.action = ACT_WARIO_AIR_DASH
    end
        
    set_mario_anim_with_accel(m, MARIO_ANIM_RUNNING_UNUSED, m.forwardVel / 5 * 0x10000)
    smlua_anim_util_set_animation(m.marioObj, "WARIO_ANIM_SHOULDER_BASH")
    play_step_sound(m, 15, 35)

    -- set dash speed
    local speed = 50
    if m.actionTimer > 8 then
        speed = speed - (m.actionTimer - 8)
    end
    mario_set_forward_vel(m, speed)

    -- corkscrew conk
    if (m.input & INPUT_A_PRESSED) ~= 0 then
        set_jumping_action(m, ACT_CORKSCREW_CONK, 0)
        play_character_sound(m, CHAR_SOUND_YAHOO_WAHA_YIPPEE)
    end

    -- slide kick
    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_SLIDE_KICK, 0)
    end
    
    m.faceAngle.y = m.intendedYaw - approach_s32(convert_s16(m.intendedYaw - m.faceAngle.y), 0, 0x400, 0x400)

    m.actionTimer = m.actionTimer + 1
    return 0
end

function act_wario_air_dash(m)
    local e = gStateExtras[m.playerIndex]
    m.marioBodyState.eyeState = 5

    -- fall once dash is up
    if m.actionTimer > 30 * 5 then
        return set_mario_action(m, ACT_FREEFALL, 0)
    end

    -- physics
    local stepResult = perform_air_step(m, 0)
    update_air_without_turn(m)
    set_mario_animation(m, MARIO_ANIM_FIRST_PUNCH)
    smlua_anim_util_set_animation(m.marioObj, "WARIO_ANIM_SHOULDER_BASH_AIR")
    if stepResult == AIR_STEP_HIT_WALL then
        if m.wall.object ~= nil and m.wall.object.oInteractType & (INTERACT_BREAKABLE) == 0 then
            return wario_rebound(m, -40, 15)
        end
    elseif stepResult == AIR_STEP_LANDED then
        if check_fall_damage_or_get_stuck(m, ACT_HARD_BACKWARD_GROUND_KB) == 0 then
            if m.actionTimer < 1 then
                m.action = ACT_WARIO_DASH
            else
                set_mario_action(m, ACT_WALKING, 0)
            end
        end
    end

    -- corkscrew conk
    if (m.input & INPUT_A_PRESSED) ~= 0 then
        m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
        set_jumping_action(m, ACT_CORKSCREW_CONK, 0)
        play_character_sound(m, CHAR_SOUND_YAHOO)
    end

    -- slide kick
    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_SLIDE_KICK, 0)
    end
    
    m.faceAngle.y = m.intendedYaw - approach_s32(convert_s16(m.intendedYaw - m.faceAngle.y), 0, 0x400, 0x400)

    m.actionTimer = m.actionTimer + 1
    return 0
end

function act_wario_dash_rebound(m)
    local e = gStateExtras[m.playerIndex]
    m.marioBodyState.eyeState = 5


    -- physics
    local stepResult = perform_air_step(m, 0)
    update_air_without_turn(m)
    set_mario_animation(m, MARIO_ANIM_FIRST_PUNCH)
    smlua_anim_util_set_animation(m.marioObj, "WARIO_ANIM_SHOULDER_BASH_AIR")
    if stepResult == AIR_STEP_LANDED then
        if check_fall_damage_or_get_stuck(m, ACT_HARD_BACKWARD_GROUND_KB) == 0 then
            return set_mario_action(m, ACT_FREEFALL_LAND, 0)
        end
    end
    return 0
end

function wario_rebound(m, VelF, VelY)
    mario_set_forward_vel(m, VelF)
    set_camera_shake_from_point(SHAKE_POS_SMALL, m.pos.x, m.pos.y, m.pos.z)
    m.vel.y = VelY
    set_mario_action(m, ACT_WARIO_DASH_REBOUND, 0)
    m.particleFlags = m.particleFlags | PARTICLE_VERTICAL_STAR
    play_sound(SOUND_ACTION_BOUNCE_OFF_OBJECT, m.marioObj.header.gfx.cameraToObject)
    return 0
end

function act_wario_spinning_obj(m)
    local spin = 0

    -- throw object
    if m.playerIndex == 0 and (m.input & INPUT_B_PRESSED) ~= 0 then
        play_character_sound_if_no_flag(m, CHAR_SOUND_WAH2, MARIO_MARIO_SOUND_PLAYED)
        play_sound_if_no_flag(m, SOUND_ACTION_THROW, MARIO_ACTION_SOUND_PLAYED)
        return set_mario_action(m, ACT_RELEASING_BOWSER, 0)
    end

    -- set animation
    if m.playerIndex == 0 and m.angleVel.y == 0 then
        m.actionTimer = m.actionTimer + 1
        if m.actionTimer > 120 then
            return set_mario_action(m, ACT_RELEASING_BOWSER, 1)
        end

        set_mario_animation(m, MARIO_ANIM_HOLDING_BOWSER)
    else
        m.actionTimer = 0
        set_mario_animation(m, MARIO_ANIM_SWINGING_BOWSER)
    end

    -- spin
    if m.intendedMag > 20.0 then
        -- spin = acceleration
        spin = (m.intendedYaw - m.twirlYaw) / 0x20

        if spin < -0x80 then
            spin = -0x80
        end
        if spin > 0x80 then
            spin = 0x80
        end

        m.twirlYaw = m.intendedYaw
        m.angleVel.y = m.angleVel.y + spin

        if m.angleVel.y > 0x1000 then
            m.angleVel.y = 0x1000
        end
        if m.angleVel.y < -0x1000 then
            m.angleVel.y = -0x1000
        end
    elseif m.angleVel.y > -0x750 and m.angleVel.y < 0x750 then
        -- go back to walking
        if m.forwardVel ~= 0 then m.faceAngle.y = atan2s(m.vel.z, m.vel.x) end
        return set_mario_action(m, ACT_HOLD_WALKING, 0)
    else
        -- slow down spin
        m.angleVel.y = approach_s32(m.angleVel.y, 0, 128, 128);
    end

    -- apply spin
    spin = m.faceAngle.y
    m.faceAngle.y = m.faceAngle.y + m.angleVel.y

    -- play sound on overflow
    if m.angleVel.y <= -0x100 and spin < m.faceAngle.y then
        queue_rumble_data_mario(m, 4, 20)
        play_sound(SOUND_OBJ_BOWSER_SPINNING, m.marioObj.header.gfx.cameraToObject)
    end
    if m.angleVel.y >= 0x100 and spin > m.faceAngle.y then
        queue_rumble_data_mario(m, 4, 20)
        play_sound(SOUND_OBJ_BOWSER_SPINNING, m.marioObj.header.gfx.cameraToObject)
    end

    perform_ground_step(m)
    
    apply_slope_decel(m, 0.1)

    if m.angleVel.y >= 0 then
        m.marioObj.header.gfx.angle.x = -m.angleVel.y
    else
        m.marioObj.header.gfx.angle.x = m.angleVel.y
    end

    return false
end

function wario_update_spin_input(m)
    local e = gStateExtras[m.playerIndex]
    local rawAngle = atan2s(-m.controller.stickY, m.controller.stickX)

    -- prevent issues due to the frame going out of the dead zone registering the last angle as 0
    if e.lastIntendedMag > 0.5 and m.intendedMag > 0.5 then
        local angleOverFrames = 0
        local thisFrameDelta = 0
        local i = 0

        local newDirection = e.spinDirection
        local signedOverflow = 0

        if rawAngle < e.stickLastAngle then
            if (e.stickLastAngle - rawAngle) > 0x8000 then
                signedOverflow = 1
            end
            if signedOverflow ~= 0 then
                newDirection = 1
            else
                newDirection = -1
            end
        elseif rawAngle > e.stickLastAngle then
            if (rawAngle - e.stickLastAngle) > 0x8000 then
                signedOverflow = 1
            end
            if signedOverflow ~= 0 then
                newDirection = -1
            else
                newDirection = 1
            end
        end

        if e.spinDirection ~= newDirection then
            for i = 0, (ANGLE_QUEUE_SIZE - 1) do
                e.angleDeltaQueue[i] = 0
            end
            e.spinDirection = newDirection
        else
            for i = (ANGLE_QUEUE_SIZE - 1), 1, -1 do
                e.angleDeltaQueue[i] = e.angleDeltaQueue[i-1]
                angleOverFrames = angleOverFrames + e.angleDeltaQueue[i]
            end
        end

        if e.spinDirection < 0 then
            if signedOverflow ~= 0 then
                thisFrameDelta = math.floor((1.0*e.stickLastAngle + 0x10000) - rawAngle)
            else
                thisFrameDelta = e.stickLastAngle - rawAngle
            end
        elseif e.spinDirection > 0 then
            if signedOverflow ~= 0 then
                thisFrameDelta = math.floor(1.0 * rawAngle + 0x10000 - e.stickLastAngle)
            else
                thisFrameDelta = rawAngle - e.stickLastAngle
            end
        end

        e.angleDeltaQueue[0] = thisFrameDelta
        angleOverFrames = angleOverFrames + thisFrameDelta

        if angleOverFrames >= 0xA000 then
            e.spinBufferTimer = SPIN_TIMER_SUCCESSFUL_INPUT
        end


        -- allow a buffer after a successful input so that you can switch directions
        if e.spinBufferTimer > 0 then
            e.spinInput = e.spinInput + 1
            e.spinBufferTimer = e.spinBufferTimer - 1
        end
    else
        e.spinDirection = 0
        e.spinBufferTimer = 0
        e.spinInput = 0
    end

    e.stickLastAngle = rawAngle
    e.lastIntendedMag = m.intendedMag
end

-- patch wario's hold jump for piledriver
function act_wario_hold_jump(m)
    if (m.marioObj.oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) ~= 0 then
        return drop_and_set_mario_action(m, ACT_FREEFALL, 0)
    end

    if (m.input & INPUT_B_PRESSED) ~= 0 and (m.heldObj ~= nil and (m.heldObj.oInteractionSubtype & INT_SUBTYPE_HOLDABLE_NPC) ~= nil) then
        return set_mario_action(m, ACT_AIR_THROW, 0)
    end

    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_PILEDRIVER, 0)
    end

    play_mario_sound(m, SOUND_ACTION_TERRAIN_JUMP, 0)
    common_air_action_step(m, ACT_HOLD_JUMP_LAND, MARIO_ANIM_JUMP_WITH_LIGHT_OBJ,
                           AIR_STEP_CHECK_LEDGE_GRAB)
    return false
end

function act_wario_hold_freefall(m)
    local animation = CHAR_ANIM_FALL_WITH_LIGHT_OBJ
    if (m.actionArg == 0) then
        animation = CHAR_ANIM_FALL_WITH_LIGHT_OBJ
    else
        animation = CHAR_ANIM_FALL_FROM_SLIDING_WITH_LIGHT_OBJ
    end

    if (m.marioObj.oInteractStatus & INT_STATUS_MARIO_DROP_OBJECT) ~= 0 then
        return drop_and_set_mario_action(m, ACT_FREEFALL, 0)
    end

    if (m.input & INPUT_B_PRESSED) ~= 0 and (m.heldObj ~= nil and (m.heldObj.oInteractionSubtype & INT_SUBTYPE_HOLDABLE_NPC) ~= nil) then
        return set_mario_action(m, ACT_AIR_THROW, 0)
    end

    if (m.input & INPUT_Z_PRESSED) ~= 0 then
        return set_mario_action(m, ACT_PILEDRIVER, 0)
    end

    common_air_action_step(m, ACT_HOLD_FREEFALL_LAND, animation, AIR_STEP_CHECK_LEDGE_GRAB)
    return false
end

function act_piledriver(m)
    local e = gStateExtras[m.playerIndex]
    if m.actionTimer == 0 then
        play_sound(SOUND_ACTION_SPIN, m.marioObj.header.gfx.cameraToObject)
        play_character_sound(m, CHAR_SOUND_SO_LONGA_BOWSER)
    end
    set_mario_animation(m, MARIO_ANIM_GRAB_BOWSER)

    local stepResult = perform_air_step(m, 0)
    update_air_without_turn(m)
    if stepResult == AIR_STEP_LANDED then
        if should_get_stuck_in_ground(m) ~= 0 then
            queue_rumble_data_mario(m, 5, 80)
            play_sound(SOUND_MARIO_OOOF2, m.marioObj.header.gfx.cameraToObject)
            m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE
            set_mario_action(m, ACT_BUTT_STUCK_IN_GROUND, 0)
        else
            play_mario_heavy_landing_sound(m, SOUND_ACTION_TERRAIN_HEAVY_LANDING)
            if check_fall_damage(m, ACT_HARD_BACKWARD_GROUND_KB) == 0 then
                m.particleFlags = m.particleFlags | PARTICLE_MIST_CIRCLE | PARTICLE_HORIZONTAL_STAR
                -- set facing direction
                -- not part of original Extended Moveset
                m.faceAngle.y = m.intendedYaw
                return set_mario_action(m, ACT_PILEDRIVER_LAND, 0)
            end
        end
    end

    if m.vel.y >= 0 then
        m.marioObj.header.gfx.angle.y = m.faceAngle.y
        e.rotAngle = 0x000
    else
        m.marioObj.header.gfx.angle.y = m.marioObj.header.gfx.angle.y + e.rotAngle
        e.rotAngle = e.rotAngle + math.abs(m.vel.y) * 0x100
        m.particleFlags = m.particleFlags | PARTICLE_DUST
    end
    m.actionTimer = m.actionTimer + 1
    return 0
end

function act_piledriver_land(m)    
    set_mario_animation(m, MARIO_ANIM_SWINGING_BOWSER)
    
    local stepResult = perform_ground_step(m)
    
    if stepResult == GROUND_STEP_LEFT_GROUND then
        m.action = ACT_PILEDRIVER
    end
    
    -- A debuff so that players can't just bounce up slides.
    if (m.input & INPUT_ABOVE_SLIDE) ~= 0 then
        return set_mario_action(m, ACT_BUTT_SLIDE, 0)
    end
    
    if (m.input & INPUT_UNKNOWN_10) ~= 0 then
        return drop_and_set_mario_action(m, ACT_SHOCKWAVE_BOUNCE, 0)
    end
        
    if m.actionTimer > 2 then return set_mario_action(m, ACT_RELEASING_BOWSER, 0) end
    
	m.actionTimer = m.actionTimer + 1
end

function wario_before_phys_step(m)
    local e = gStateExtras[m.playerIndex]

    local hScale = 1.0
    local vScale = 1.0

    -- slower on ground
    if (m.action & ACT_FLAG_MOVING) ~= 0 then
        hScale = hScale * 0.9
    end

    -- fixes the momentum bug
    if (m.action == ACT_HOLD_WATER_JUMP) then
        return
    end

    -- faster holding item
    if m.action == ACT_HOLD_WALKING then
        hScale = hScale * 2
    end

    -- make wario sink
    if (m.action & ACT_FLAG_SWIMMING) ~= 0 then
        if m.action ~= ACT_BACKWARD_WATER_KB and
           m.action ~= ACT_FORWARD_WATER_KB and
           m.action ~= ACT_WATER_PLUNGE then
            m.vel.y = m.vel.y - 3
        end
    end

    m.vel.x = m.vel.x * hScale
    m.vel.z = m.vel.z * hScale
end

function wario_on_set_action(m)
    local e = gStateExtras[m.playerIndex]

    -- air dash
    if m.action == ACT_MOVE_PUNCHING and m.prevAction == ACT_WARIO_DASH then
        local actionTimer = m.actionTimer
        set_mario_action(m, ACT_WARIO_AIR_DASH, 0)
        m.actionTimer = actionTimer
        m.vel.x = 0
        m.vel.y = 0
        m.vel.z = 0
        return
    end

    -- slow down when dash/conk ends
    if (m.prevAction == ACT_WARIO_DASH) or (m.prevAction == ACT_WARIO_AIR_DASH) or (m.prevAction == ACT_CORKSCREW_CONK) then
        if m.action == ACT_CORKSCREW_CONK then
            m.vel.x = 0
            -- nerf the conk when executed in the air
            if (m.prevAction == ACT_WARIO_DASH) then
                set_mario_y_vel_based_on_fspeed(m, 30 , 0.6)
            elseif (m.prevAction == ACT_WARIO_AIR_DASH) then
                m.vel.y = 60.0
            end
        elseif m.action == ACT_SLIDE_KICK then
            mario_set_forward_vel(m, 40)
            m.vel.y = 30.0
        elseif m.forwardVel > 20 then
            mario_set_forward_vel(m, 20)
        end
    end

    if m.action == ACT_PILEDRIVER then
        if m.vel.y < 50 then m.vel.y = 50 end
    end
    
    -- patch wario's hold jump for piledriver
    if m.action == ACT_HOLD_JUMP then
        m.action = ACT_WARIO_HOLD_JUMP
    end

    if m.action == ACT_HOLD_FREEFALL then
        m.action = ACT_WARIO_HOLD_FREEFALL
    end

    -- less height on other jumps
    if m.action == ACT_JUMP or
       m.action == ACT_DOUBLE_JUMP or
       m.action == ACT_STEEP_JUMP or
       m.action == ACT_RIDING_SHELL_JUMP or
       m.action == ACT_BACKFLIP or
       m.action == ACT_LONG_JUMP or
       m.action == ACT_SIDE_FLIP then

        m.vel.y = m.vel.y * 0.9

        -- prevent from getting stuck on platform
        if m.marioObj.platform ~= nil then
            m.pos.y = m.pos.y + 10
        end
    end
    e.lastAction = action
end

function wario_update(m)
    local hScale = 1.0
    local e = gStateExtras[m.playerIndex]

    wario_update_spin_input(m)

    -- spin around objects
    if m.action == ACT_HOLD_IDLE or m.action == ACT_HOLD_WALKING then
        if e.spinInput > 30 then
            m.twirlYaw = m.intendedYaw
            if e.spinDirection == 1 then
                m.angleVel.y = 3000
            else
                m.angleVel.y = -3000
            end
            m.intendedMag = 21
            return set_mario_action(m, ACT_WARIO_SPINNING_OBJ, 1)
        end
    end

    -- turn heavy objects into light
    if m.action == ACT_HOLD_HEAVY_IDLE then
        return set_mario_action(m, ACT_HOLD_IDLE, 0)
    end

    -- turn dive into dash
    if m.action == ACT_DIVE and m.prevAction == ACT_WALKING then
        if (m.controller.buttonPressed & B_BUTTON) ~= 0 then
            m.actionTimer = 0
            return set_mario_action(m, ACT_WARIO_DASH, 0)
        end
    end

    -- shake camera
    if m.action == ACT_GROUND_POUND_LAND then
        set_camera_shake_from_point(SHAKE_POS_MEDIUM, m.pos.x, m.pos.y, m.pos.z)
        m.squishTimer = 5
    end

    -- faster ground pound
    if m.action == ACT_GROUND_POUND then
        m.vel.y = m.vel.y * 1.3
    end

    -- decrease player damage
    if m.hurtCounter > e.lastHurtCounter and m.action ~= ACT_LAVA_BOOST then
        m.hurtCounter = math.max(3, m.hurtCounter - 4)
    end
    e.lastHurtCounter = m.hurtCounter

    m.vel.x = m.vel.x * hScale
    m.vel.z = m.vel.z * hScale

    e.prevPos.x = m.pos.x
    e.prevPos.y = m.pos.y
    e.prevPos.z = m.pos.z
end

gEventTable[CT_WARIO] = {
    before_phys_step = wario_before_phys_step,
    on_set_action    = wario_on_set_action,
    update           = wario_update,
}

----------
-- main --
----------

function char_before_phys_step(m)
    if charmov == 0 then
        return
    end

    if m.action == ACT_BUBBLED then
        return
    end

    if gEventTable[m.character.type] == nil then
        return
    end

    if gEventTable[m.character.type].before_phys_step == nil then
        return
    end

    gEventTable[m.character.type].before_phys_step(m)
end

function char_on_set_action(m)
    if charmov == 0 then
        return
    end

    if m.action == ACT_BUBBLED then
        return
    end

    if gEventTable[m.character.type] == nil then
        return
    end

    if gEventTable[m.character.type].on_set_action == nil then
        return
    end

    gEventTable[m.character.type].on_set_action(m)
end

function char_update(m)
    if charmov == 0 then
        return
    end

    if m.action == ACT_BUBBLED then
        return
    end

    if gEventTable[m.character.type] == nil then
        return
    end

    if gEventTable[m.character.type].update == nil then
        return
    end

    gEventTable[m.character.type].update(m)
end

-- shoulder bash interactions
function dash_attacks(m, o, intType)
    if obj_has_behavior_id(o, id_bhvKingBobomb) ~= 0 and o.oAction ~= 0 then
        o.oMoveAngleYaw = m.faceAngle.y
        o.oAction = 4
        o.oVelY = 50
        o.oForwardVel = 20
    end

    if obj_has_behavior_id(o, id_bhvBreakableBoxSmall) ~= 0 then
        o.oMoveAngleYaw = m.faceAngle.y
        o.oVelY = 30
        o.oForwardVel = 40
    end

    if obj_has_behavior_id(o, id_bhvChuckya) ~= 0 then
        o.oMoveAngleYaw = m.faceAngle.y
        o.oAction = 2
        o.oVelY = 30
        o.oForwardVel = 40
    end

    if obj_has_behavior_id(o, id_bhvMrBlizzard) ~= 0 then
        o.oFaceAngleRoll = 0x3000
        o.oMrBlizzardHeldObj = nil
        o.prevObj = o.oMrBlizzardHeldObj
        o.oAction = MR_BLIZZARD_ACT_DEATH
    end

    if obj_has_behavior_id(o, id_bhvHeaveHo) ~= 0 then
        obj_mark_for_deletion(o)
        spawn_triangle_break_particles(30, 138, 3.0, 4)
        spawn_non_sync_object(
            id_bhvBlueCoinJumping,
            E_MODEL_BLUE_COIN,
            o.oPosX, o.oPosY, o.oPosZ,
            function (coin)
                coin.oVelY = math.random(20, 40)
                coin.oForwardVel = 0
            end)
    end
    
    if (intType & INTERACT_BULLY) ~= 0 then
        o.oVelY = 30
        o.oForwardVel = 50
    end
end

function on_interact(m, o, intType)
    local damagableTypes = (INTERACT_BOUNCE_TOP | INTERACT_BOUNCE_TOP2 | INTERACT_HIT_FROM_BELOW | 2097152 | INTERACT_KOOPA | 
    INTERACT_BREAKABLE | INTERACT_GRABBABLE | INTERACT_BULLY)
    
    -- rebound from bash and interact

    if m.action == ACT_WARIO_DASH and (intType & damagableTypes) ~= 0 then
        dash_attacks(m, o, intType)
        
        wario_rebound(m, -40, 30)
        return false
    end

    if m.action == ACT_WARIO_AIR_DASH and (intType & damagableTypes) ~= 0 then
        dash_attacks(m, o, intType)
        
        wario_rebound(m, -40, 15)
        return false
    end
end

function on_pvp_attack(a, v)
    if a.action == ACT_WARIO_DASH then
        wario_rebound(a, -40, 30)
    end

    if a.action == ACT_WARIO_AIR_DASH then
        wario_rebound(a, -40, 15)
    end
end

function character_movesets_command(msg)
	if msg == "" then
        if charmov == 0 then
            djui_popup_create("Character Movesets is \\#00C7FF\\on\\#ffffff\\!", 1)
            charmov = 1
        elseif charmov == 1 then
            djui_popup_create("Character Movesets is \\#A02200\\off\\#ffffff\\!", 1)
            charmov = 0
        end

        return true
    end

    return false
end

function convert_s16(num)
    local min = -32768
    local max = 32767
    while (num < min) do
        num = max + (num - min)
    end
    while (num > max) do
        num = min + (num - max)
    end
    return num
end

-----------
-- hooks --
-----------

hook_event(HOOK_MARIO_UPDATE, char_update)
hook_event(HOOK_ON_SET_MARIO_ACTION, char_on_set_action)
hook_event(HOOK_BEFORE_PHYS_STEP, char_before_phys_step)
hook_event(HOOK_ON_INTERACT, on_interact)
hook_event(HOOK_ON_PVP_ATTACK, on_pvp_attack)

hook_mario_action(ACT_WALL_SLIDE,                 { every_frame = act_wall_slide })
hook_mario_action(ACT_ELEGANT_JUMP,               { every_frame = act_elegant_jump })
hook_mario_action(ACT_WALUIGI_AIR_SWIM,           { every_frame = act_waluigi_air_swim })
hook_mario_action(ACT_HANDSTAND_IDLE,             { every_frame = act_handstand_idle })
hook_mario_action(ACT_HANDSTAND_MOVING,           { every_frame = act_handstand_moving })
hook_mario_action(ACT_HANDSTAND_JUMP,             { every_frame = act_handstand_jump })
hook_mario_action(ACT_HANDSTAND_JUMP_LAND,        { every_frame = act_handstand_jump_land })
hook_mario_action(ACT_HANDSTAND_SECOND_JUMP_LAND, { every_frame = act_handstand_second_jump_land })
hook_mario_action(ACT_SPIN_POUND,                 { every_frame = act_spin_pound },      INT_GROUND_POUND_OR_TWIRL)
hook_mario_action(ACT_SPIN_POUND_LAND,            { every_frame = act_spin_pound_land }, INT_GROUND_POUND_OR_TWIRL)
hook_mario_action(ACT_WARIO_DASH,                 { every_frame = act_wario_dash },      INT_KICK)
hook_mario_action(ACT_WARIO_AIR_DASH,             { every_frame = act_wario_air_dash },  INT_KICK)
hook_mario_action(ACT_WARIO_DASH_REBOUND,         { every_frame = act_wario_dash_rebound })
hook_mario_action(ACT_CORKSCREW_CONK,             { every_frame = act_corkscrew_conk },  INT_FAST_ATTACK_OR_SHELL)
hook_mario_action(ACT_WARIO_SPINNING_OBJ,         { every_frame = act_wario_spinning_obj })
hook_mario_action(ACT_PILEDRIVER,                 { every_frame = act_piledriver})
hook_mario_action(ACT_PILEDRIVER_LAND,            { every_frame = act_piledriver_land},  INT_GROUND_POUND_OR_TWIRL)
hook_mario_action(ACT_WARIO_HOLD_JUMP,            { every_frame = act_wario_hold_jump})
hook_mario_action(ACT_WARIO_HOLD_FREEFALL,        { every_frame = act_wario_hold_freefall})

hook_chat_command(
"char-mov",
"Toggle Character Movesets.",
character_movesets_command
)

----------------
-- animations --
----------------
smlua_anim_util_register_animation("LUIGI_ANIM_FLUTTER",
    0,
    0,
    0,
    0,
    20,
    {
    0x0000, 0x00BD, 0x0000, 0xFFFF, 0x3FFF, 0xFFFF, 0xFFFF, 0x0000, 0x2FA8, 
    0x0DC4, 0x0CFF, 0x0AEA, 0x07D7, 0x041C, 0x000D, 0xFBFC, 0xF841, 0xF52F, 
    0xF319, 0xF254, 0xF319, 0xF52F, 0xF841, 0xFBFC, 0x000D, 0x041C, 0x07D7, 
    0x0AEA, 0x0CFF, 0x0DC4, 0xF964, 0xF9C0, 0xFABA, 0xFC2A, 0xFDE9, 0xFFCF, 
    0x01B6, 0x0375, 0x04E5, 0x05DE, 0x063A, 0x05DE, 0x04E5, 0x0375, 0x01B6, 
    0xFFCF, 0xFDE9, 0xFC2A, 0xFABA, 0xF9C0, 0xF964, 0x05E8, 0x05E9, 0x05EB, 
    0x05EF, 0x05F4, 0x05F9, 0x05FE, 0x0603, 0x0607, 0x0609, 0x060A, 0x0609, 
    0x0607, 0x0603, 0x05FE, 0x05F9, 0x05F4, 0x05EF, 0x05EB, 0x05E9, 0x05E8, 
    0xF5F7, 0xF686, 0xF80C, 0xFA4A, 0xFD03, 0xFFF9, 0x02F1, 0x05AA, 0x07E8, 
    0x096E, 0x09FD, 0x096E, 0x07E8, 0x05AA, 0x02F1, 0xFFF9, 0xFD03, 0xFA4A, 
    0xF80C, 0xF686, 0xF5F7, 0x0ADA, 0x0A3A, 0x088A, 0x060C, 0x0305, 0xFFBA, 
    0xFC6F, 0xF968, 0xF6EB, 0xF53A, 0xF49A, 0xF53A, 0xF6EB, 0xF968, 0xFC6F, 
    0xFFBA, 0x0305, 0x060C, 0x088A, 0x0A3A, 0x0ADA, 0x1019, 0x1017, 0x1012, 
    0x100A, 0x1001, 0x0FF7, 0x0FED, 0x0FE3, 0x0FDC, 0x0FD6, 0x0FD4, 0x0FD6, 
    0x0FDC, 0x0FE3, 0x0FED, 0x0FF7, 0x1001, 0x100A, 0x1012, 0x1017, 0x1019, 
    0x0CD4, 0x0C4B, 0x0AD7, 0x08B3, 0x061A, 0x0346, 0x0072, 0xFDD8, 0xFBB4, 
    0xFA41, 0xF9B8, 0xFA41, 0xFBB4, 0xFDD8, 0x0072, 0x0346, 0x061A, 0x08B3, 
    0x0AD7, 0x0C4B, 0x0CD4, 0x0204, 0x01EF, 0x01B4, 0x015E, 0x00F5, 0x0083, 
    0x0011, 0xFFA7, 0xFF51, 0xFF16, 0xFF01, 0xFF16, 0xFF51, 0xFFA7, 0x0011, 
    0x0083, 0x00F5, 0x015E, 0x01B4, 0x01EF, 0x0204, 0xC1C2, 0xC1C0, 0xC1BC, 
    0xC1B5, 0xC1AC, 0xC1A3, 0xC19A, 0xC191, 0xC18A, 0xC186, 0xC184, 0xC186, 
    0xC18A, 0xC191, 0xC19A, 0xC1A3, 0xC1AC, 0xC1B5, 0xC1BC, 0xC1C0, 0xC1C2, 
    0xBFFF, 0xBEFD, 0xBCC6, 0xBA8E, 0xB98D, 0xBA07, 0xBB38, 0xBCC6, 0xBE53, 
    0xBF85, 0xBFFF, 0xBEFD, 0xBCC6, 0xBA8E, 0xB98C, 0xBA06, 0xBB38, 0xBCC6, 
    0xBE53, 0xBF85, 0xBFFF, 0xBFFF, 0xC39B, 0xCB8B, 0xD37C, 0xD717, 0xD607, 
    0xD32D, 0xCF0B, 0xCA22, 0xC4F3, 0xBFFF, 0xBBBD, 0xB86E, 0xB649, 0xB586, 
    0xB64D, 0xB83D, 0xBAC3, 0xBD48, 0xBF39, 0xBFFF, 0x0000, 0x0102, 0x033A, 
    0x0571, 0x0673, 0x05F9, 0x04C7, 0x033A, 0x01AC, 0x007A, 0x0000, 0x0102, 
    0x0339, 0x0571, 0x0673, 0x05F9, 0x04C7, 0x0339, 0x01AC, 0x007A, 0x0000, 
    0xFF95, 0xFF8F, 0xFF7D, 0xFF61, 0xFF3D, 0xFF11, 0xFEE0, 0xFEAB, 0xFE7B, 
    0xFE58, 0xFE4B, 0xFE54, 0xFE6D, 0xFE92, 0xFEBF, 0xFEF0, 0xFF21, 0xFF4E, 
    0xFF73, 0xFF8C, 0xFF95, 0xFE45, 0xFE45, 0xFE47, 0xFE4D, 0xFE59, 0xFE6D, 
    0xFE8A, 0xFEBC, 0xFEFD, 0xFF35, 0xFF4D, 0xFF45, 0xFF31, 0xFF14, 0xFEF0, 
    0xFEC9, 0xFEA2, 0xFE7E, 0xFE60, 0xFE4C, 0xFE45, 0xD6A0, 0xD6FD, 0xD82C, 
    0xDA4F, 0xDD8A, 0xE200, 0xE7D2, 0xEEDD, 0xF5D5, 0xFB2B, 0xFD4B, 0xFC36, 
    0xF946, 0xF4F1, 0xEFAF, 0xE9F6, 0xE43D, 0xDEFA, 0xDAA6, 0xD7B5, 0xD6A0, 
    0xFF89, 0xF97F, 0xF06E, 0x0402, 0x0525, 0x07A6, 0x0A27, 0x0B4A, 0x0AB6, 
    0x0923, 0x06D2, 0x0402, 0x00F2, 0xFDE1, 0xFB11, 0xF8C0, 0xF72E, 0xF699, 
    0xF798, 0xFA13, 0xFD4D, 0x0088, 0x0304, 0x0402, 0x00A2, 0x00D0, 0x0135, 
    0x019A, 0x01C8, 0x01B1, 0x0171, 0x0114, 0x00A2, 0x0026, 0xFFAA, 0xFF38, 
    0xFEDB, 0xFE9B, 0xFE84, 0xFEAC, 0xFF10, 0xFF92, 0x0016, 0x007A, 0x00A2, 
    0xC1A9, 0xC1AA, 0xC1AC, 0xC1AF, 0xC1B0, 0xC1AF, 0xC1AE, 0xC1AC, 0xC1A9, 
    0xC1A6, 0xC1A3, 0xC1A0, 0xC19E, 0xC19D, 0xC19C, 0xC19D, 0xC1A0, 0xC1A3, 
    0xC1A6, 0xC1A8, 0xC1A9, 0x44C7, 0x4408, 0x4263, 0x40BF, 0x4000, 0x4102, 
    0x4339, 0x4571, 0x4673, 0x45F8, 0x44C7, 0x4339, 0x41AC, 0x407A, 0x4000, 
    0x4102, 0x4339, 0x4571, 0x4673, 0x459D, 0x44C7, 0x2D2D, 0x2F16, 0x33D7, 
    0x39F8, 0x4000, 0x44BA, 0x47FB, 0x49DD, 0x4A79, 0x4A64, 0x4A15, 0x4962, 
    0x47D4, 0x44E1, 0x4000, 0x3913, 0x31AB, 0x2BC4, 0x295C, 0x2B44, 0x2D2D, 
    0x04C7, 0x0408, 0x0263, 0x00BF, 0x0000, 0x0102, 0x033A, 0x0571, 0x0673, 
    0x05F9, 0x04C7, 0x033A, 0x01AC, 0x007A, 0x0000, 0x0102, 0x0339, 0x0571, 
    0x0673, 0x059D, 0x04C7, 0x0218, 0x0214, 0x020C, 0x0204, 0x0200, 0x0209, 
    0x0222, 0x0241, 0x0260, 0x0278, 0x0282, 0x0280, 0x027A, 0x0271, 0x0265, 
    0x0255, 0x0244, 0x0233, 0x0225, 0x021B, 0x0218, 0x009F, 0x00C0, 0x0107, 
    0x014E, 0x016F, 0x016A, 0x015B, 0x013D, 0x010E, 0x00CC, 0x0073, 0x0005, 
    0xFF96, 0xFF42, 0xFF20, 0xFF3C, 0xFF83, 0xFFDF, 0x003C, 0x0083, 0x009F, 
    0xE3D8, 0xE1AB, 0xDCE2, 0xD819, 0xD5ED, 0xD658, 0xD7AB, 0xDA00, 0xDD70, 
    0xE215, 0xE808, 0xEF1D, 0xF611, 0xFB5D, 0xFD78, 0xFB92, 0xF6D3, 0xF0A8, 
    0xEA7D, 0xE5BE, 0xE3D8, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
    0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
    0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
    0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 
    0xED8B, 0xFBD3, 0x0941, 0xBEE4, 0x0040, 0x0055, 0x0055, 0x0056, 0x0056, 
    0x0056, 0x0056, 0x0056, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 0x0057, 
    0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0055, 0xA4C4, 0xA690, 
    0xAB71, 0xB2A2, 0xBB5D, 0xC4DE, 0xCE5E, 0xD71A, 0xDE4B, 0xE32C, 0xE4F8, 
    0xE2FC, 0xDDA8, 0xD5EF, 0xCCC1, 0xC311, 0xB9C0, 0xB177, 0xAACF, 0xA660, 
    0xA4C4, 0x0000, 0xFFFF, 0xFFFD, 0xFFFC, 0xFFFA, 0xFFF8, 0xFFF5, 0xFFF3, 
    0xFFF2, 0xFFF1, 0xFFF0, 0xFFF7, 0x0009, 0x001C, 0x002D, 0x0034, 0x002E, 
    0x0021, 0x0012, 0x0005, 0x0000, 0xFFFF, 0x0002, 0x0009, 0x0014, 0x0022, 
    0x0032, 0x0043, 0x0055, 0x0067, 0x0078, 0x0088, 0x0096, 0x00A1, 0x00A9, 
    0x00AE, 0x00B0, 0x009D, 0x0072, 0x003E, 0x0012, 0xFFFF, 0x054B, 0x0639, 
    0x08D8, 0x0CEB, 0x1230, 0x186A, 0x1F59, 0x26BF, 0x2E5B, 0x35EF, 0x3D3B, 
    0x43FD, 0x49DD, 0x4E80, 0x518B, 0x52A3, 0x4A98, 0x3769, 0x2085, 0x0D56, 
    0x054B, 0x0095, 0x0095, 0x0095, 0x0096, 0x0096, 0x0097, 0x0098, 0x0098, 
    0x0098, 0x0099, 0x0099, 0x008E, 0x0073, 0x0053, 0x0039, 0x002E, 0x0038, 
    0x0052, 0x0071, 0x008A, 0x0095, 0xFF08, 0xFF08, 0xFF08, 0xFF08, 0xFF08, 
    0xFF08, 0xFF09, 0xFF09, 0xFF09, 0xFF0A, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0C, 
    0xFF0D, 0xFF0D, 0xFF0C, 0xFF0B, 0xFF0A, 0xFF09, 0xFF08, 0xCC41, 0xCC35, 
    0xCC14, 0xCBE4, 0xCBA9, 0xCB69, 0xCB29, 0xCAEF, 0xCABE, 0xCA9D, 0xCA91, 
    0xCE45, 0xD717, 0xE1A0, 0xEA73, 0xEE26, 0xEAA0, 0xE238, 0xD82F, 0xCFC8, 
    0xCC41, 0x0657, 0xF244, 0xBE49, 0xFEE8, 0xFF3F, 0xFF3F, 0xFF3F, 0xFF3E, 
    0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3D, 0xFF3E, 0xFF3E, 
    0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3F, 0xE429, 0xE1CC, 0xDB94, 0xD2D2, 
    0xC8D9, 0xBEF9, 0xB652, 0xAF46, 0xAA02, 0xA6B7, 0xA593, 0xA754, 0xAC15, 
    0xB318, 0xBB9B, 0xC4DE, 0xCE22, 0xD6A5, 0xDDA7, 0xE269, 0xE429, 0xFFB4, 
    0xFF96, 0xFF4D, 0xFEF6, 0xFEAE, 0xFE8F, 0xFEB6, 0xFF14, 0xFF83, 0xFFE0, 
    0x0008, 0x0006, 0xFFFF, 0xFFF5, 0xFFEA, 0xFFDE, 0xFFD1, 0xFFC6, 0xFFBD, 
    0xFFB7, 0xFFB4, 0xFE72, 0xFE6A, 0xFE57, 0xFE40, 0xFE2D, 0xFE25, 0xFE55, 
    0xFEC6, 0xFF4D, 0xFFBE, 0xFFED, 0xFFE2, 0xFFC5, 0xFF9B, 0xFF67, 0xFF2F, 
    0xFEF7, 0xFEC4, 0xFE99, 0xFE7C, 0xFE72, 0x3A64, 0x3DEE, 0x465C, 0x506D, 
    0x58DB, 0x5C65, 0x53AF, 0x3EE9, 0x261F, 0x1159, 0x08A4, 0x0A08, 0x0DD0, 
    0x1363, 0x1A27, 0x2184, 0x28E1, 0x2FA5, 0x3538, 0x3900, 0x3A64, 0x001B, 
    0x003B, 0x0086, 0x00E1, 0x012C, 0x014C, 0x0132, 0x00F2, 0x00A4, 0x0060, 
    0x003D, 0x0034, 0x002C, 0x0027, 0x0022, 0x001F, 0x001D, 0x001C, 0x001B, 
    0x025B, 0x024F, 0x0234, 0x0213, 0x01F7, 0x01EB, 0x01F2, 0x0204, 0x021A, 
    0x022F, 0x023D, 0x0245, 0x024C, 0x0251, 0x0255, 0x0257, 0x0259, 0x025A, 
    0x025B, 0xCB24, 0xCF10, 0xD86A, 0xE393, 0xECED, 0xF0D9, 0xED9D, 0xE5D2, 
    0xDC53, 0xD3FD, 0xCFAB, 0xCE71, 0xCD75, 0xCCB2, 0xCC1E, 0xCBB5, 0xCB6E, 
    0xCB43, 0xCB2D, 0xCB25, 0xCB24, 
    },
    {
    0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0002, 0x0001, 0x0003, 0x0001, 
    0x0004, 0x0001, 0x0005, 0x0001, 0x0006, 0x0001, 0x0007, 0x0001, 0x0008, 
    0x0015, 0x0009, 0x0015, 0x001E, 0x0015, 0x0033, 0x0015, 0x0048, 0x0015, 
    0x005D, 0x0015, 0x0072, 0x0015, 0x0087, 0x0015, 0x009C, 0x0015, 0x00B1, 
    0x0015, 0x00C6, 0x0015, 0x00DB, 0x0015, 0x00F0, 0x0015, 0x0105, 0x0015, 
    0x011A, 0x0015, 0x012F, 0x0001, 0x0144, 0x0001, 0x0145, 0x0001, 0x0146, 
    0x0015, 0x0147, 0x0015, 0x015C, 0x0015, 0x0171, 0x0015, 0x0186, 0x0015, 
    0x019B, 0x0015, 0x01B0, 0x0015, 0x01C5, 0x0015, 0x01DA, 0x0015, 0x01EF, 
    0x0015, 0x0204, 0x0015, 0x0219, 0x0001, 0x022E, 0x0001, 0x022F, 0x0001, 
    0x0230, 0x0001, 0x0231, 0x0001, 0x0232, 0x0014, 0x0233, 0x0015, 0x0247, 
    0x0015, 0x025C, 0x0015, 0x0271, 0x0015, 0x0286, 0x0015, 0x029B, 0x0015, 
    0x02B0, 0x0015, 0x02C5, 0x0001, 0x02DA, 0x0001, 0x02DB, 0x0001, 0x02DC, 
    0x0001, 0x02DD, 0x0012, 0x02DE, 0x0015, 0x02F0, 0x0015, 0x0305, 0x0015, 
    0x031A, 0x0015, 0x032F, 0x0013, 0x0344, 0x0013, 0x0357, 0x0015, 0x036A, 
})

smlua_anim_util_register_animation("LUIGI_ANIM_FLUTTER_HOLD",
    0,
    0,
    0,
    0,
    20,
    {
    0x0000, 0x00BD, 0x0000, 0xFFFF, 0x3FFF, 0xFFFF, 0xFFFF, 0x0000, 0x2FA8, 
    0xFFFF, 0xFFFF, 0x06BA, 0xFFFF, 0xFFFF, 0x0FC8, 0x05FC, 0xE690, 0xBF81, 
    0xEBA3, 0xE5B5, 0x94F6, 0x0000, 0x0000, 0xF084, 0xFF89, 0xF97F, 0xF06E, 
    0xFFFE, 0x0001, 0xC170, 0x12B1, 0x01C7, 0x92BF, 0xFFFF, 0x0000, 0xF3C6, 
    0xFFFF, 0xFFFF, 0xED8B, 0xFBD3, 0x0941, 0xBEE4, 0x0040, 0x0055, 0x0055, 
    0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0057, 0x0057, 0x0057, 0x0057, 
    0x0057, 0x0057, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0055, 
    0xA4C4, 0xA690, 0xAB71, 0xB2A2, 0xBB5D, 0xC4DE, 0xCE5E, 0xD71A, 0xDE4B, 
    0xE32C, 0xE4F8, 0xE2FC, 0xDDA8, 0xD5EF, 0xCCC1, 0xC311, 0xB9C0, 0xB177, 
    0xAACF, 0xA660, 0xA4C4, 0x0000, 0xFFFF, 0xFFFD, 0xFFFC, 0xFFFA, 0xFFF8, 
    0xFFF5, 0xFFF3, 0xFFF2, 0xFFF1, 0xFFF0, 0xFFF7, 0x0009, 0x001C, 0x002D, 
    0x0034, 0x002E, 0x0021, 0x0012, 0x0005, 0x0000, 0xFFFF, 0x0002, 0x0009, 
    0x0014, 0x0022, 0x0032, 0x0043, 0x0055, 0x0067, 0x0078, 0x0088, 0x0096, 
    0x00A1, 0x00A9, 0x00AE, 0x00B0, 0x009D, 0x0072, 0x003E, 0x0012, 0xFFFF, 
    0x054B, 0x0639, 0x08D8, 0x0CEB, 0x1230, 0x186A, 0x1F59, 0x26BF, 0x2E5B, 
    0x35EF, 0x3D3B, 0x43FD, 0x49DD, 0x4E80, 0x518B, 0x52A3, 0x4A98, 0x3769, 
    0x2085, 0x0D56, 0x054B, 0x0095, 0x0095, 0x0095, 0x0096, 0x0096, 0x0097, 
    0x0098, 0x0098, 0x0098, 0x0099, 0x0099, 0x008E, 0x0073, 0x0053, 0x0039, 
    0x002E, 0x0038, 0x0052, 0x0071, 0x008A, 0x0095, 0xFF08, 0xFF08, 0xFF08, 
    0xFF08, 0xFF08, 0xFF08, 0xFF09, 0xFF09, 0xFF09, 0xFF0A, 0xFF0A, 0xFF0B, 
    0xFF0C, 0xFF0C, 0xFF0D, 0xFF0D, 0xFF0C, 0xFF0B, 0xFF0A, 0xFF09, 0xFF08, 
    0xCC41, 0xCC35, 0xCC14, 0xCBE4, 0xCBA9, 0xCB69, 0xCB29, 0xCAEF, 0xCABE, 
    0xCA9D, 0xCA91, 0xCE45, 0xD717, 0xE1A0, 0xEA73, 0xEE26, 0xEAA0, 0xE238, 
    0xD82F, 0xCFC8, 0xCC41, 0x0657, 0xF244, 0xBE49, 0xFEE8, 0xFF3F, 0xFF3F, 
    0xFF3F, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3D, 
    0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3F, 0xE429, 0xE1CC, 
    0xDB94, 0xD2D2, 0xC8D9, 0xBEF9, 0xB652, 0xAF46, 0xAA02, 0xA6B7, 0xA593, 
    0xA754, 0xAC15, 0xB318, 0xBB9B, 0xC4DE, 0xCE22, 0xD6A5, 0xDDA7, 0xE269, 
    0xE429, 0xFFB4, 0xFF96, 0xFF4D, 0xFEF6, 0xFEAE, 0xFE8F, 0xFEB6, 0xFF14, 
    0xFF83, 0xFFE0, 0x0008, 0x0006, 0xFFFF, 0xFFF5, 0xFFEA, 0xFFDE, 0xFFD1, 
    0xFFC6, 0xFFBD, 0xFFB7, 0xFFB4, 0xFE72, 0xFE6A, 0xFE57, 0xFE40, 0xFE2D, 
    0xFE25, 0xFE55, 0xFEC6, 0xFF4D, 0xFFBE, 0xFFED, 0xFFE2, 0xFFC5, 0xFF9B, 
    0xFF67, 0xFF2F, 0xFEF7, 0xFEC4, 0xFE99, 0xFE7C, 0xFE72, 0x3A64, 0x3DEE, 
    0x465C, 0x506D, 0x58DB, 0x5C65, 0x53AF, 0x3EE9, 0x261F, 0x1159, 0x08A4, 
    0x0A08, 0x0DD0, 0x1363, 0x1A27, 0x2184, 0x28E1, 0x2FA5, 0x3538, 0x3900, 
    0x3A64, 0x001B, 0x003B, 0x0086, 0x00E1, 0x012C, 0x014C, 0x0132, 0x00F2, 
    0x00A4, 0x0060, 0x003D, 0x0034, 0x002C, 0x0027, 0x0022, 0x001F, 0x001D, 
    0x001C, 0x001B, 0x025B, 0x024F, 0x0234, 0x0213, 0x01F7, 0x01EB, 0x01F2, 
    0x0204, 0x021A, 0x022F, 0x023D, 0x0245, 0x024C, 0x0251, 0x0255, 0x0257, 
    0x0259, 0x025A, 0x025B, 0xCB24, 0xCF10, 0xD86A, 0xE393, 0xECED, 0xF0D9, 
    0xED9D, 0xE5D2, 0xDC53, 0xD3FD, 0xCFAB, 0xCE71, 0xCD75, 0xCCB2, 0xCC1E, 
    0xCBB5, 0xCB6E, 0xCB43, 0xCB2D, 0xCB25, 0xCB24, 
    },
    {
    0x0001, 0x0000, 0x0001, 0x0001, 0x0001, 0x0002, 0x0001, 0x0003, 0x0001, 
    0x0004, 0x0001, 0x0005, 0x0001, 0x0006, 0x0001, 0x0007, 0x0001, 0x0008, 
    0x0001, 0x0009, 0x0001, 0x000A, 0x0001, 0x000B, 0x0001, 0x000C, 0x0001, 
    0x000D, 0x0001, 0x000E, 0x0001, 0x000F, 0x0001, 0x0010, 0x0001, 0x0011, 
    0x0001, 0x0012, 0x0001, 0x0013, 0x0001, 0x0014, 0x0001, 0x0015, 0x0001, 
    0x0016, 0x0001, 0x0017, 0x0001, 0x0018, 0x0001, 0x0019, 0x0001, 0x001A, 
    0x0001, 0x001B, 0x0001, 0x001C, 0x0001, 0x001D, 0x0001, 0x001E, 0x0001, 
    0x001F, 0x0001, 0x0020, 0x0001, 0x0021, 0x0001, 0x0022, 0x0001, 0x0023, 
    0x0001, 0x0024, 0x0001, 0x0025, 0x0001, 0x0026, 0x0001, 0x0027, 0x0001, 
    0x0028, 0x0001, 0x0029, 0x0001, 0x002A, 0x0014, 0x002B, 0x0015, 0x003F, 
    0x0015, 0x0054, 0x0015, 0x0069, 0x0015, 0x007E, 0x0015, 0x0093, 0x0015, 
    0x00A8, 0x0015, 0x00BD, 0x0001, 0x00D2, 0x0001, 0x00D3, 0x0001, 0x00D4, 
    0x0001, 0x00D5, 0x0012, 0x00D6, 0x0015, 0x00E8, 0x0015, 0x00FD, 0x0015, 
    0x0112, 0x0015, 0x0127, 0x0013, 0x013C, 0x0013, 0x014F, 0x0015, 0x0162, 
})

smlua_anim_util_register_animation("WARIO_ANIM_SHOULDER_BASH",
    0,
    0,
    0,
    0,
    40,
    {
    0x0000, 0x00D9, 0x00D4, 0x00CF, 0x00CA, 0x00C5, 0x00C0, 0x00C3, 0x00C6, 
    0x00C9, 0x00CB, 0x00CE, 0x00CE, 0x00CE, 0x00CE, 0x00CE, 0x00CE, 0x00D0, 
    0x00D2, 0x00D4, 0x00D7, 0x00D9, 0x00D4, 0x00CF, 0x00CA, 0x00C5, 0x00C0, 
    0x00C3, 0x00C6, 0x00C9, 0x00CB, 0x00CE, 0x00CE, 0x00CE, 0x00CE, 0x00CE, 
    0x00CE, 0x00D0, 0x00D2, 0x00D4, 0x00D7, 0x00D9, 0x0000, 0xFFFF, 0x3FFF, 
    0xFFFF, 0xF633, 0xFAB3, 0xFF33, 0x03B3, 0x0833, 0x0CB3, 0x100A, 0x1361, 
    0x16B8, 0x1A0F, 0x1D66, 0x1B32, 0x18FE, 0x16CA, 0x1496, 0x1262, 0x1120, 
    0x0FDE, 0x0E9D, 0x0D5B, 0x0C19, 0x05A9, 0xFF38, 0xF8C8, 0xF257, 0xEBE7, 
    0xEA2B, 0xE86F, 0xE6B3, 0xE4F7, 0xE33A, 0xE535, 0xE730, 0xE92B, 0xEB26, 
    0xED21, 0xEEF1, 0xF0C2, 0xF292, 0xF463, 0xF633, 0xF856, 0xF872, 0xF88E, 
    0xF8AA, 0xF8C6, 0xF8E2, 0xF9A0, 0xFA5E, 0xFB1C, 0xFBD9, 0xFC97, 0xFC89, 
    0xFC7A, 0xFC6B, 0xFC5D, 0xFC4E, 0xFE57, 0x0060, 0x0268, 0x0470, 0x0678, 
    0x08A6, 0x0AD4, 0x0D01, 0x0F2F, 0x115C, 0x115E, 0x115F, 0x1160, 0x1161, 
    0x1162, 0x0F94, 0x0DC5, 0x0BF7, 0x0A29, 0x085A, 0x0527, 0x01F3, 0xFEBE, 
    0xFB8A, 0xF856, 0x4E2F, 0x4DC1, 0x4D54, 0x4CE6, 0x4C78, 0x4C0B, 0x4D36, 
    0x4E62, 0x4F8D, 0x50B9, 0x51E4, 0x5235, 0x5286, 0x52D7, 0x5328, 0x5379, 
    0x532F, 0x52E6, 0x529D, 0x5254, 0x520B, 0x5013, 0x4E1B, 0x4C24, 0x4A2C, 
    0x4834, 0x4AD4, 0x4D73, 0x5013, 0x52B2, 0x5551, 0x53F2, 0x5292, 0x5132, 
    0x4FD2, 0x4E72, 0x4E65, 0x4E58, 0x4E4A, 0x4E3D, 0x4E2F, 0xE20E, 0xDCE9, 
    0xD7C4, 0xD2A0, 0xCD7B, 0xC856, 0xC493, 0xC0CF, 0xBD0B, 0xB948, 0xB584, 
    0xB917, 0xBCA9, 0xC03C, 0xC3CE, 0xC761, 0xC739, 0xC711, 0xC6E8, 0xC6C0, 
    0xC698, 0xCAF2, 0xCF4C, 0xD3A6, 0xD801, 0xDC5B, 0xDF1F, 0xE1E4, 0xE4A9, 
    0xE76E, 0xEA32, 0xE8F6, 0xE7BA, 0xE67E, 0xE542, 0xE406, 0xE3A1, 0xE33C, 
    0xE2D7, 0xE273, 0xE20E, 0x0FF0, 0x115F, 0x12CF, 0x143E, 0x15AE, 0x171E, 
    0x17A7, 0x1831, 0x18BB, 0x1944, 0x19CE, 0x1989, 0x1945, 0x1901, 0x18BD, 
    0x1878, 0x1603, 0x138D, 0x1118, 0x0EA2, 0x0C2D, 0x079D, 0x030E, 0xFE7D, 
    0xF9EE, 0xF55F, 0xF553, 0xF547, 0xF53B, 0xF52F, 0xF524, 0xF6A9, 0xF82F, 
    0xF9B4, 0xFB3A, 0xFCBF, 0x0096, 0x046D, 0x0843, 0x0C19, 0x0FF0, 0x18D2, 
    0x1643, 0x13B5, 0x1126, 0x0E98, 0x0C09, 0x0A16, 0x0823, 0x0630, 0x043D, 
    0x024A, 0x03F1, 0x0598, 0x073F, 0x08E6, 0x0A8D, 0x0AC0, 0x0AF4, 0x0B27, 
    0x0B5B, 0x0B8F, 0x0D70, 0x0F52, 0x1133, 0x1315, 0x14F7, 0x12D1, 0x10AB, 
    0x0E85, 0x0C5F, 0x0A39, 0x0D07, 0x0FD5, 0x12A3, 0x1571, 0x183F, 0x185C, 
    0x187A, 0x1897, 0x18B4, 0x18D2, 0x1107, 0x1148, 0x1189, 0x11CA, 0x120B, 
    0x124C, 0x128D, 0x12CE, 0x1310, 0x1351, 0x1392, 0x1351, 0x1310, 0x12CE, 
    0x128D, 0x124C, 0x120B, 0x11CA, 0x1189, 0x1148, 0x1107, 0x1107, 0x1107, 
    0x1107, 0x1107, 0x1107, 0x1189, 0x120B, 0x128D, 0x1310, 0x1392, 0x1351, 
    0x1310, 0x12CE, 0x128D, 0x124C, 0x120B, 0x11CA, 0x1189, 0x1148, 0x1107, 
    0x1743, 0x16BE, 0x1639, 0x15B4, 0x1530, 0x14AB, 0x1426, 0x13A2, 0x131D, 
    0x1298, 0x1213, 0x1298, 0x131D, 0x13A2, 0x1426, 0x14AB, 0x1530, 0x15B4, 
    0x1639, 0x16BE, 0x1743, 0x1743, 0x1743, 0x1743, 0x1743, 0x1743, 0x1639, 
    0x1530, 0x1426, 0x131D, 0x1213, 0x1298, 0x131D, 0x13A2, 0x1426, 0x14AB, 
    0x1530, 0x15B4, 0x1639, 0x16BE, 0x1743, 0xF8AB, 0xF972, 0xFA39, 0xFAFF, 
    0xFBC6, 0xFC8D, 0xFD54, 0xFE1A, 0xFEE1, 0xFFA8, 0x0070, 0xFFA8, 0xFEE1, 
    0xFE1A, 0xFD54, 0xFC8D, 0xFBC6, 0xFAFF, 0xFA39, 0xF972, 0xF8AB, 0xF8AB, 
    0xF8AB, 0xF8AB, 0xF8AB, 0xF8AB, 0xFA39, 0xFBC6, 0xFD54, 0xFEE1, 0x0070, 
    0xFFA8, 0xFEE1, 0xFE1A, 0xFD54, 0xFC8D, 0xFBC6, 0xFAFF, 0xFA39, 0xF972, 
    0xF8AB, 0xFFFE, 0x0001, 0xC170, 0xC6AC, 0xC682, 0xC657, 0xC62D, 0xC603, 
    0xC5D8, 0xC5AE, 0xC584, 0xC559, 0xC52F, 0xC504, 0xC52F, 0xC559, 0xC584, 
    0xC5AE, 0xC5D8, 0xC603, 0xC62D, 0xC657, 0xC682, 0xC6AC, 0xC6AC, 0xC6AC, 
    0xC6AC, 0xC6AC, 0xC6AC, 0xC657, 0xC603, 0xC5AE, 0xC559, 0xC504, 0xC52F, 
    0xC559, 0xC584, 0xC5AE, 0xC5D8, 0xC603, 0xC62D, 0xC657, 0xC682, 0xC6AC, 
    0x89B7, 0x899A, 0x897E, 0x8962, 0x8945, 0x8929, 0x890C, 0x88F0, 0x88D3, 
    0x88B7, 0x889A, 0x88B7, 0x88D3, 0x88F0, 0x890C, 0x8929, 0x8945, 0x8962, 
    0x897E, 0x899A, 0x89B7, 0x89B7, 0x89B7, 0x89B7, 0x89B7, 0x89B7, 0x897E, 
    0x8945, 0x890C, 0x88D3, 0x889A, 0x88B7, 0x88D3, 0x88F0, 0x890C, 0x8929, 
    0x8945, 0x8962, 0x897E, 0x899A, 0x89B7, 0x00C3, 0x00CA, 0x00D1, 0x00D8, 
    0x00DF, 0x00E6, 0x00EC, 0x00F3, 0x00FA, 0x0101, 0x0108, 0x0101, 0x00FA, 
    0x00F3, 0x00EC, 0x00E6, 0x00DF, 0x00D8, 0x00D1, 0x00CA, 0x00C3, 0x00C3, 
    0x00C3, 0x00C3, 0x00C3, 0x00C3, 0x00D1, 0x00DF, 0x00EC, 0x00FA, 0x0108, 
    0x0101, 0x00FA, 0x00F3, 0x00EC, 0x00E6, 0x00DF, 0x00D8, 0x00D1, 0x00CA, 
    0x00C3, 0x0938, 0xFB79, 0xCE23, 0xFF89, 0xF97F, 0xF06E, 0xFFFE, 0x0001, 
    0xC170, 0x2875, 0x2810, 0x27AB, 0x2746, 0x26E1, 0x267C, 0x2617, 0x25B2, 
    0x254D, 0x24E8, 0x2483, 0x25E0, 0x273D, 0x289A, 0x29F7, 0x2B54, 0x2AC1, 
    0x2A2E, 0x299B, 0x2908, 0x2875, 0x2810, 0x27AB, 0x2746, 0x26E1, 0x267C, 
    0x2617, 0x25B2, 0x254D, 0x24E8, 0x2483, 0x25E0, 0x273D, 0x289A, 0x29F7, 
    0x2B54, 0x2AC1, 0x2A2E, 0x299B, 0x2908, 0x2875, 0xFC13, 0xFDDE, 0xFFA9, 
    0x0174, 0x033F, 0x050A, 0x06D5, 0x089F, 0x0A6A, 0x0C35, 0x0E00, 0x0A9A, 
    0x0734, 0x03CE, 0x0068, 0xFD01, 0xFCD1, 0xFCA2, 0xFC72, 0xFC43, 0xFC13, 
    0xFDDE, 0xFFA9, 0x0174, 0x033F, 0x050A, 0x06D5, 0x089F, 0x0A6A, 0x0C35, 
    0x0E00, 0x0A9A, 0x0734, 0x03CE, 0x0068, 0xFD01, 0xFCD1, 0xFCA2, 0xFC72, 
    0xFC43, 0xFC13, 0xE570, 0xE744, 0xE918, 0xEAEC, 0xECC0, 0xEE94, 0xF068, 
    0xF23C, 0xF410, 0xF5E4, 0xF7B8, 0xF45E, 0xF104, 0xEDAA, 0xEA50, 0xE6F7, 
    0xE6A8, 0xE65A, 0xE60C, 0xE5BE, 0xE570, 0xE744, 0xE918, 0xEAEC, 0xECC0, 
    0xEE94, 0xF068, 0xF23C, 0xF410, 0xF5E4, 0xF7B8, 0xF45E, 0xF104, 0xEDAA, 
    0xEA50, 0xE6F7, 0xE6A8, 0xE65A, 0xE60C, 0xE5BE, 0xE570, 0xFFFF, 0xFFFF, 
    0xC734, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
    0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 
    0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
    0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
    0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
    0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 
    0x0000, 0xED8B, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
    0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
    0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 
    0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
    0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
    0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
    0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 
    0x0000, 0x0000, 0xFFFF, 0xBF5E, 0xF4ED, 0xF8D3, 0xFCB9, 0x00A0, 0x0486, 
    0x086C, 0x0889, 0x08A7, 0x08C4, 0x08E1, 0x08FF, 0x085A, 0x07B5, 0x0710, 
    0x066C, 0x05C7, 0x0525, 0x0484, 0x03E2, 0x0340, 0x029F, 0xFD8B, 0xF879, 
    0xF366, 0xEE54, 0xE941, 0xE8DE, 0xE87A, 0xE816, 0xE7B3, 0xE74F, 0xE8CE, 
    0xEA4C, 0xEBCB, 0xED49, 0xEEC8, 0xF003, 0xF13D, 0xF278, 0xF3B3, 0xF4ED, 
    0xFB3F, 0xF9DA, 0xF876, 0xF711, 0xF5AD, 0xF449, 0xF101, 0xEDB9, 0xEA71, 
    0xE729, 0xE3E1, 0xE5BD, 0xE799, 0xE976, 0xEB52, 0xED2F, 0xF3B5, 0xFA3B, 
    0x00C3, 0x0749, 0x0DD0, 0x0952, 0x04D5, 0x0058, 0xFBDA, 0xF75D, 0xF498, 
    0xF1D3, 0xEF0E, 0xEC49, 0xE985, 0xED7B, 0xF171, 0xF567, 0xF95E, 0xFD54, 
    0xFCE9, 0xFC7F, 0xFC14, 0xFBA9, 0xFB3F, 0xCB45, 0xCCBA, 0xCE30, 0xCFA5, 
    0xD11B, 0xD290, 0xD816, 0xDD9C, 0xE322, 0xE8A8, 0xEE2E, 0xE7B6, 0xE13F, 
    0xDAC7, 0xD450, 0xCDD9, 0xC3EE, 0xBA03, 0xB018, 0xA62D, 0x9C42, 0x9D18, 
    0x9DEE, 0x9EC4, 0x9F99, 0xA06F, 0x9C9B, 0x98C6, 0x94F2, 0x911D, 0x8D49, 
    0x97AD, 0xA211, 0xAC75, 0xB6D9, 0xC13D, 0xC33E, 0xC540, 0xC742, 0xC943, 
    0xCB45, 0xFFF7, 0xFFF7, 0xFFF7, 0xFFF7, 0xFFF7, 0xFFF7, 0xFFF2, 0xFFEE, 
    0xFFEA, 0xFFE6, 0xFFE1, 0xFF89, 0xFF32, 0xFEDA, 0xFE82, 0xFE2A, 0xFE87, 
    0xFEE4, 0xFF41, 0xFF9E, 0xFFFB, 0xFFF9, 0xFFF7, 0xFFF5, 0xFFF3, 0xFFF1, 
    0xFFF6, 0xFFFA, 0xFFFF, 0x0004, 0x0009, 0xFF5E, 0xFEB5, 0xFE0B, 0xFD62, 
    0xFCB8, 0xFD5E, 0xFE04, 0xFEAB, 0xFF51, 0xFFF7, 0x0009, 0x0009, 0x0009, 
    0x0009, 0x0009, 0x0009, 0x0012, 0x001B, 0x0024, 0x002D, 0x0035, 0xFEF9, 
    0xFDBE, 0xFC83, 0xFB47, 0xFA0C, 0xFB5B, 0xFCA9, 0xFDF7, 0xFF46, 0x0095, 
    0x0093, 0x0090, 0x008E, 0x008C, 0x0089, 0x006C, 0x004F, 0x0032, 0x0015, 
    0xFFF7, 0x01DA, 0x03BC, 0x059E, 0x0780, 0x0962, 0x0784, 0x05A5, 0x03C6, 
    0x01E8, 0x0009, 0x0A05, 0x0A05, 0x0A05, 0x0A05, 0x0A05, 0x0A05, 0x0DC2, 
    0x117F, 0x153B, 0x18F8, 0x1CB5, 0x208D, 0x2466, 0x283F, 0x2C17, 0x2FF0, 
    0x33DD, 0x37CA, 0x3BB7, 0x3FA4, 0x4391, 0x426A, 0x4144, 0x401E, 0x3EF7, 
    0x3DD1, 0x31A3, 0x2575, 0x1947, 0x0D19, 0x00EA, 0x0083, 0x001B, 0xFFB3, 
    0xFF4B, 0xFEE4, 0x011E, 0x0358, 0x0592, 0x07CC, 0x0A05, 0x00A9, 0x00AC, 
    0x00AF, 0x00B1, 0x00B4, 0x00B6, 0x00B9, 0x00BC, 0x00BF, 0x00C3, 0x00C6, 
    0x0145, 0x01C5, 0x0245, 0x02C4, 0x0344, 0x03EF, 0x049A, 0x0545, 0x0304, 
    0x00C3, 0x00C3, 0x00C3, 0x00C3, 0x00C3, 0x00C3, 0x00BD, 0x00B8, 0x00B2, 
    0x00AC, 0x00A6, 0x001C, 0xFF91, 0xFF08, 0xFE7E, 0xFDF4, 0xFE7F, 0xFF09, 
    0xFF94, 0x001F, 0x00A9, 0xFF16, 0xFF19, 0xFF1C, 0xFF1F, 0xFF21, 0xFF24, 
    0xFF29, 0xFF2E, 0xFF33, 0xFF38, 0xFF3E, 0xFE99, 0xFDF5, 0xFD51, 0xFCAD, 
    0xFC09, 0xF9A3, 0xF73D, 0xF4D8, 0xFA08, 0xFF39, 0xFF39, 0xFF39, 0xFF39, 
    0xFF39, 0xFF39, 0xFF31, 0xFF2A, 0xFF22, 0xFF1B, 0xFF13, 0xFF5F, 0xFFAB, 
    0xFFF7, 0x0043, 0x008F, 0x0044, 0xFFF8, 0xFFAD, 0xFF62, 0xFF16, 0xC2CB, 
    0xC15D, 0xBFF0, 0xBE82, 0xBD15, 0xBBA7, 0xB968, 0xB729, 0xB4EA, 0xB2AB, 
    0xB06C, 0xBAEB, 0xC56A, 0xCFE9, 0xDA67, 0xE4E6, 0xE769, 0xE9EB, 0xEC6E, 
    0xCF62, 0xB257, 0xB257, 0xB257, 0xB257, 0xB257, 0xB257, 0xB602, 0xB9AC, 
    0xBD57, 0xC101, 0xC4AC, 0xC707, 0xC963, 0xCBBF, 0xCE1A, 0xD076, 0xCDBA, 
    0xCAFE, 0xC843, 0xC587, 0xC2CB, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 
    0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 
    0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
    0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 
    0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
    0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
    0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
    0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xBF5E, 0xFF73, 0x016C, 0x0364, 
    0x055B, 0x0753, 0x094B, 0x08B1, 0x0818, 0x077E, 0x06E5, 0x064C, 0x0877, 
    0x0AA1, 0x0CCC, 0x0EF7, 0x1122, 0x101C, 0x0F16, 0x0E0F, 0x0D09, 0x0C03, 
    0x0887, 0x050C, 0x0190, 0xFE14, 0xFA99, 0xFCA0, 0xFEA8, 0x00B1, 0x02B9, 
    0x04C0, 0x0231, 0xFFA0, 0xFD11, 0xFA82, 0xF7F2, 0xF973, 0xFAF3, 0xFC73, 
    0xFDF3, 0xFF73, 0xF2DD, 0xF761, 0xFBE6, 0x006B, 0x04F0, 0x0974, 0x0D2B, 
    0x10E1, 0x1498, 0x184E, 0x1C05, 0x1724, 0x1243, 0x0D62, 0x0881, 0x03A0, 
    0x038B, 0x0376, 0x0361, 0x034C, 0x0337, 0x0793, 0x0BEF, 0x104B, 0x14A7, 
    0x1903, 0x1A58, 0x1BAC, 0x1D00, 0x1E54, 0x1FA8, 0x1D0D, 0x1A72, 0x17D7, 
    0x153C, 0x12A1, 0x0C47, 0x05EC, 0xFF91, 0xF937, 0xF2DD, 0x9A46, 0x977B, 
    0x94B0, 0x91E5, 0x8F1A, 0x8C4F, 0x8B2F, 0x8A10, 0x88F0, 0x87D0, 0x86B1, 
    0x8EC7, 0x96DE, 0x9EF5, 0xA70C, 0xAF22, 0xB461, 0xB99F, 0xBEDD, 0xC41B, 
    0xC95A, 0xCCBA, 0xD01B, 0xD37C, 0xD6DC, 0xDA3D, 0xDE8F, 0xE2E1, 0xE734, 
    0xEB86, 0xEFD8, 0xECB7, 0xE996, 0xE675, 0xE354, 0xE033, 0xD237, 0xC43B, 
    0xB63F, 0xA842, 0x9A46, 0xFF3C, 0xFF53, 0xFF6B, 0xFF82, 0xFF99, 0xFFB0, 
    0xFFC3, 0xFFD6, 0xFFEA, 0xFFFD, 0x0012, 0x0015, 0x0018, 0x001B, 0x001E, 
    0x0021, 0x0018, 0x000E, 0x0005, 0xFFFA, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 
    0xFFF0, 0xFFF0, 0xFFF7, 0xFFFE, 0x0005, 0x000C, 0x0013, 0xFFFE, 0xFFEB, 
    0xFFD7, 0xFFC3, 0xFFB0, 0xFF99, 0xFF82, 0xFF6B, 0xFF54, 0xFF3C, 0xFE2B, 
    0xFE38, 0xFE46, 0xFE53, 0xFE60, 0xFE6E, 0xFEB5, 0xFEFD, 0xFF44, 0xFF8C, 
    0xFFD3, 0xFFB9, 0xFFA0, 0xFF86, 0xFF6C, 0xFF52, 0xFF7A, 0xFFA2, 0xFFCA, 
    0xFFF2, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0x001B, 0xFFE3, 0xFFAC, 
    0xFF74, 0xFF3D, 0xFF06, 0xFEE8, 0xFEC9, 0xFEAB, 0xFE8C, 0xFE6E, 0xFE61, 
    0xFE53, 0xFE46, 0xFE38, 0xFE2B, 0x4B45, 0x480A, 0x44CF, 0x4194, 0x3E59, 
    0x3B1E, 0x31AF, 0x2841, 0x1ED2, 0x1563, 0x0BF5, 0x0F18, 0x123C, 0x155F, 
    0x1883, 0x1BA6, 0x16A2, 0x119D, 0x0C99, 0x0795, 0x0290, 0x0290, 0x0290, 
    0x0290, 0x0290, 0x0290, 0x0974, 0x1058, 0x173C, 0x1E1F, 0x2503, 0x296E, 
    0x2DD8, 0x3242, 0x36AC, 0x3B17, 0x3E53, 0x4190, 0x44CC, 0x4809, 0x4B45, 
    0xFF94, 0xFFA9, 0xFFBD, 0xFFD1, 0xFFE5, 0xFFFA, 0xFFFA, 0xFFFA, 0xFFFA, 
    0xFFFA, 0xFFFA, 0xFFEC, 0xFFDF, 0xFFD1, 0xFFC4, 0xFFB6, 0xFFC0, 0xFFCA, 
    0xFFD3, 0xFFDD, 0xFFE7, 0xFFD3, 0xFFBF, 0xFFAB, 0xFF97, 0xFF83, 0xFF81, 
    0xFF7F, 0xFF7C, 0xFF7A, 0xFF78, 0xFFAD, 0xFFE2, 0x0017, 0x004C, 0x0081, 
    0x00D0, 0x011F, 0x016E, 0x0082, 0xFF94, 0x0223, 0x022D, 0x0237, 0x0240, 
    0x024A, 0x0253, 0x0253, 0x0253, 0x0253, 0x0253, 0x0253, 0x024E, 0x0249, 
    0x0243, 0x023E, 0x0238, 0x023C, 0x0241, 0x0245, 0x0249, 0x024D, 0x0242, 
    0x0237, 0x022C, 0x0221, 0x0216, 0x0214, 0x0213, 0x0211, 0x020F, 0x020D, 
    0x021E, 0x022E, 0x023E, 0x024E, 0x025E, 0x0492, 0x06C5, 0x08F9, 0x058E, 
    0x0223, 0xB992, 0xBC48, 0xBEFE, 0xC1B4, 0xC46A, 0xC721, 0xC721, 0xC721, 
    0xC721, 0xC721, 0xC721, 0xC562, 0xC3A2, 0xC1E3, 0xC024, 0xBE65, 0xBFAA, 
    0xC0EF, 0xC234, 0xC37A, 0xC4BF, 0xC1FA, 0xBF35, 0xBC6F, 0xB9AA, 0xB6E5, 
    0xB693, 0xB641, 0xB5EF, 0xB59D, 0xB54B, 0xBC1F, 0xC2F4, 0xC9C8, 0xD09C, 
    0xD771, 0xD990, 0xDBB0, 0xDDD0, 0xCBB1, 0xB992,
    },
    {
    0x0001, 0x0000, 0x0029, 0x0001, 0x0001, 0x002A, 0x0001, 0x002B, 0x0001, 
    0x002C, 0x0001, 0x002D, 0x0029, 0x002E, 0x0029, 0x0057, 0x0029, 0x0080, 
    0x0029, 0x00A9, 0x0029, 0x00D2, 0x0029, 0x00FB, 0x0029, 0x0124, 0x0029, 
    0x014D, 0x0029, 0x0176, 0x0001, 0x019F, 0x0001, 0x01A0, 0x0001, 0x01A1, 
    0x0029, 0x01A2, 0x0029, 0x01CB, 0x0029, 0x01F4, 0x0001, 0x021D, 0x0001, 
    0x021E, 0x0001, 0x021F, 0x0001, 0x0220, 0x0001, 0x0221, 0x0001, 0x0222, 
    0x0001, 0x0223, 0x0001, 0x0224, 0x0001, 0x0225, 0x0029, 0x0226, 0x0029, 
    0x024F, 0x0029, 0x0278, 0x0001, 0x02A1, 0x0001, 0x02A2, 0x0001, 0x02A3, 
    0x0028, 0x02A4, 0x0029, 0x02CC, 0x0001, 0x02F5, 0x0029, 0x02F6, 0x0029, 
    0x031F, 0x0001, 0x0348, 0x0029, 0x0349, 0x0029, 0x0372, 0x0029, 0x039B, 
    0x0029, 0x03C4, 0x0029, 0x03ED, 0x0029, 0x0416, 0x0029, 0x043F, 0x0029, 
    0x0468, 0x0029, 0x0491, 0x0029, 0x04BA, 0x0029, 0x04E3, 0x0001, 0x050C, 
    0x0029, 0x050D, 0x0029, 0x0536, 0x0029, 0x055F, 0x0029, 0x0588, 0x0029, 
    0x05B1, 0x0029, 0x05DA, 0x0029, 0x0603, 0x0029, 0x062C, 0x0029, 0x0655, 
})

smlua_anim_util_register_animation("WARIO_ANIM_SHOULDER_BASH_AIR",
    1,
    0,
    0,
    0,
    10,
    {
    0x0000, 0x00D9, 0x00D4, 0x00CF, 0x00CA, 0x00C5, 0x00C0, 0x0000, 0x0000, 
    0x3FFF, 0x0000, 0xF633, 0xECCA, 0xE361, 0xD9F8, 0xD08F, 0xC726, 0xC7C2, 
    0xC85D, 0xC8F8, 0xC993, 0xCA2E, 0xF856, 0xFAA9, 0xFCFB, 0xFF4E, 0x01A1, 
    0x03F3, 0x0380, 0x030D, 0x0299, 0x0226, 0x01B2, 0x4E2F, 0x508C, 0x52E9, 
    0x5545, 0x57A2, 0x59FF, 0x5898, 0x5732, 0x55CB, 0x5465, 0x52FE, 0xE20E, 
    0xE966, 0xF0BE, 0xF817, 0xFF6F, 0x06C8, 0x0658, 0x05E9, 0x0579, 0x050A, 
    0x049A, 0x0FF0, 0x0B58, 0x06C0, 0x0229, 0xFD90, 0xF8F9, 0xF7F4, 0xF6EF, 
    0xF5EB, 0xF4E6, 0xF3E2, 0x18D2, 0x1581, 0x1231, 0x0EE0, 0x0B8F, 0x083F, 
    0x0A10, 0x0BE1, 0x0DB2, 0x0F83, 0x1154, 0x1107, 0x10D4, 0x10A1, 0x106E, 
    0x103B, 0x1008, 0x103B, 0x106E, 0x10A1, 0x10D4, 0x1107, 0x1743, 0x1735, 
    0x1728, 0x171A, 0x170D, 0x1700, 0x170D, 0x171A, 0x1728, 0x1735, 0x1743, 
    0xF8AB, 0xF866, 0xF820, 0xF7DB, 0xF795, 0xF750, 0xF795, 0xF7DB, 0xF820, 
    0xF866, 0xF8AB, 0xFFFE, 0x0001, 0xC170, 0xC6AC, 0xC8B8, 0xCAC3, 0xCCCE, 
    0xCEDA, 0xD0E5, 0xCEDA, 0xCCCE, 0xCAC3, 0xC8B8, 0xC6AC, 0x89B7, 0x8A39, 
    0x8ABC, 0x8B3E, 0x8BC0, 0x8C43, 0x8BC0, 0x8B3E, 0x8ABC, 0x8A39, 0x89B7, 
    0x00C3, 0xFF63, 0xFE03, 0xFCA4, 0xFB44, 0xF9E5, 0xFB44, 0xFCA4, 0xFE03, 
    0xFF63, 0x00C3, 0x0938, 0xFB79, 0xCE23, 0xFF89, 0xF97F, 0xF06E, 0xFFFE, 
    0x0001, 0xC170, 0x2875, 0xFC13, 0xE570, 0xFFFF, 0xFFFF, 0xC734, 0x0000, 
    0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
    0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
    0xFFFF, 0x0000, 0xED8B, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xBF5E, 0xF4ED, 0xF499, 
    0xF445, 0xF3F1, 0xF39D, 0xF348, 0xF55A, 0xF76C, 0xF97D, 0xFB8F, 0xFDA0, 
    0xFB3F, 0xF6B1, 0xF223, 0xED95, 0xE907, 0xE479, 0xE57C, 0xE67E, 0xE781, 
    0xE884, 0xE987, 0xCB45, 0xC7D6, 0xC467, 0xC0F9, 0xBD8A, 0xBA1B, 0xB641, 
    0xB266, 0xAE8B, 0xAAB1, 0xA6D6, 0xFFF7, 0x000D, 0x0022, 0x0038, 0x004D, 
    0x0063, 0x0009, 0x001B, 0x002C, 0x003E, 0x004F, 0x0060, 0x0A05, 0x1BB1, 
    0x2D5E, 0x3F0A, 0x50B6, 0x6262, 0x00A9, 0x00AF, 0x00B4, 0x00B9, 0x00BE, 
    0x00C3, 0xFF16, 0xFF1D, 0xFF24, 0xFF2B, 0xFF32, 0xFF39, 0xC2CB, 0xBF81, 
    0xBC36, 0xB8EC, 0xB5A1, 0xB257, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
    0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xBF5E, 0xFF73, 
    0x08BB, 0x1201, 0x1B48, 0x248F, 0x2DD5, 0x2A3D, 0x26A6, 0x230E, 0x1F77, 
    0x1BDF, 0xF2DD, 0xFB98, 0x0454, 0x0D0F, 0x15CB, 0x1E86, 0x21CC, 0x2513, 
    0x2859, 0x2BA0, 0x2EE6, 0x9A46, 0xA26A, 0xAA8F, 0xB2B3, 0xBAD8, 0xC2FC, 
    0xBEB0, 0xBA64, 0xB619, 0xB1CD, 0xAD81, 0xFF3C, 0xFF65, 0xFF8E, 0xFFB6, 
    0xFFDF, 0x0008, 0x000C, 0x0010, 0x0014, 0x0017, 0x001B, 0xFE2B, 0xFE8E, 
    0xFEF2, 0xFF55, 0xFFB9, 0x001D, 0x001A, 0x0017, 0x0014, 0x0011, 0x000E, 
    0x4B45, 0x4310, 0x3ADA, 0x32A4, 0x2A6E, 0x2239, 0x28DF, 0x2F85, 0x362B, 
    0x3CD1, 0x4377, 0xFF94, 0xFFB8, 0xFFDC, 0x0001, 0x0025, 0x0049, 0x006D, 
    0x0092, 0x00B6, 0x00DA, 0x00FE, 0x0223, 0x0222, 0x0222, 0x0221, 0x0220, 
    0x021F, 0x0214, 0x0208, 0x01FD, 0x01F1, 0x01E6, 0xB992, 0xBBFE, 0xBE6A, 
    0xC0D7, 0xC343, 0xC5AF, 0xC885, 0xCB5B, 0xCE31, 0xD107, 0xD3DD, 
    },
    {
    0x0001, 0x0000, 0x0006, 0x0001, 0x0001, 0x0007, 0x0001, 0x0008, 0x0001, 
    0x0009, 0x0001, 0x000A, 0x000B, 0x000B, 0x000B, 0x0016, 0x000B, 0x0021, 
    0x000B, 0x002C, 0x000B, 0x0037, 0x000B, 0x0042, 0x000B, 0x004D, 0x000B, 
    0x0058, 0x000B, 0x0063, 0x0001, 0x006E, 0x0001, 0x006F, 0x0001, 0x0070, 
    0x000B, 0x0071, 0x000B, 0x007C, 0x000B, 0x0087, 0x0001, 0x0092, 0x0001, 
    0x0093, 0x0001, 0x0094, 0x0001, 0x0095, 0x0001, 0x0096, 0x0001, 0x0097, 
    0x0001, 0x0098, 0x0001, 0x0099, 0x0001, 0x009A, 0x0001, 0x009B, 0x0001, 
    0x009C, 0x0001, 0x009D, 0x0001, 0x009E, 0x0001, 0x009F, 0x0001, 0x00A0, 
    0x000A, 0x00A1, 0x000B, 0x00AB, 0x0001, 0x00B6, 0x000A, 0x00B7, 0x000B, 
    0x00C1, 0x0001, 0x00CC, 0x000B, 0x00CD, 0x000B, 0x00D8, 0x000B, 0x00E3, 
    0x0006, 0x00EE, 0x0006, 0x00F4, 0x0006, 0x00FA, 0x0006, 0x0100, 0x0006, 
    0x0106, 0x0006, 0x010C, 0x000A, 0x0112, 0x000B, 0x011C, 0x0001, 0x0127, 
    0x000B, 0x0128, 0x000B, 0x0133, 0x000B, 0x013E, 0x000B, 0x0149, 0x000B, 
    0x0154, 0x000B, 0x015F, 0x000B, 0x016A, 0x000B, 0x0175, 0x000B, 0x0180, 
})

smlua_anim_util_register_animation("WALUIGI_ANIM_ELEGANT_JUMP_1",
    1,
    0,
    0,
    0,
    10,
    {
    0x0000, 0x00E3, 0x00FA, 0x012A, 0x0154, 0x016C, 0x017E, 0x018A, 0x0191, 
    0x0195, 0x0196, 0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 
    0xFFFF, 0xFFFE, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFE, 0x40A1, 0x458C, 
    0x5103, 0x5E0F, 0x68A6, 0x7056, 0x7596, 0x78DE, 0x7AA2, 0x7B5B, 0x7B7E, 
    0xFFFF, 0xFFFE, 0xFFFE, 0xFFFF, 0xFFFF, 0x0000, 0x1942, 0x159F, 0x0D29, 
    0x0386, 0xFBB3, 0xF605, 0xF224, 0xEFB9, 0xEE6B, 0xEDE2, 0xEDC8, 0xFFFF, 
    0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0001, 0x0F37, 0x0B41, 0x020A, 
    0xF78A, 0xEF05, 0xE8D6, 0xE49D, 0xE1FA, 0xE08E, 0xDFFA, 0xDFDE, 0xFFFE, 
    0x0001, 0xC170, 0xD59F, 0xD0D3, 0xC5A5, 0xB8EA, 0xAE96, 0xA716, 0xA1F7, 
    0x9EC4, 0x9D0B, 0x9C57, 0x9C35, 0xDE99, 0xDC4A, 0xD6E9, 0xD0C9, 0xCBD0, 
    0xC834, 0xC5BD, 0xC433, 0xC35F, 0xC308, 0xC2F8, 0xEF50, 0xF059, 0xF2C3, 
    0xF582, 0xF7BC, 0xF95B, 0xFA76, 0xFB26, 0xFB85, 0xFBAC, 0xFBB4, 0xFFFF, 
    0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 
    0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 
    0xFFFF, 0xFFFF, 0x0000, 0xC80A, 0xCC86, 0xD6F8, 0xE2DD, 0xEC84, 0xF386, 
    0xF84F, 0xFB4C, 0xFCE8, 0xFD90, 0xFDB0, 0xFF89, 0xFF52, 0xFED3, 0xFE42, 
    0xFDCD, 0xFD77, 0xFD3D, 0xFD19, 0xFD05, 0xFCFD, 0xFCFC, 0xF97F, 0xF98E, 
    0xF9B2, 0xF9DB, 0xF9FC, 0xFA14, 0xFA24, 0xFA2E, 0xFA34, 0xFA36, 0xFA37, 
    0xF06E, 0xF1D5, 0xF518, 0xF8D0, 0xFBD4, 0xFE04, 0xFF83, 0x0073, 0x00F4, 
    0x0128, 0x0132, 0xFFFE, 0x0001, 0xC170, 0x3101, 0x35FE, 0x419D, 0x4ED9, 
    0x5995, 0x6161, 0x66B4, 0x6A07, 0x6BD1, 0x6C8C, 0x6CB0, 0x218C, 0x23CA, 
    0x2902, 0x2EF4, 0x33C7, 0x3747, 0x39AC, 0x3B2A, 0x3BF8, 0x3C4C, 0x3C5C, 
    0xF057, 0xF18B, 0xF459, 0xF78A, 0xFA21, 0xFC02, 0xFD4B, 0xFE18, 0xFE87, 
    0xFEB4, 0xFEBC, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xCB4C, 0xCFC8, 
    0xDA3A, 0xE61F, 0xEFC6, 0xF6C8, 0xFB91, 0xFE8E, 0x002B, 0x00D3, 0x00F3, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
    0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
    0x0000, 0x0000, 0xFFFF, 0xED8B, 0xEEEE, 0xF229, 0xF5D6, 0xF8D2, 0xFAFC, 
    0xFC77, 0xFD63, 0xFDE3, 0xFE17, 0xFE21, 0x0000, 0x0000, 0x0000, 0x0000, 
    0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0F57, 0x0B5D, 
    0x03FA, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 
    0xBF5E, 0x0040, 0x0055, 0x0055, 0x0056, 0xA21B, 0xA59C, 0xADC5, 0xB710, 
    0xBE9A, 0xC414, 0xC7D1, 0xCA27, 0xCB69, 0xCBED, 0xCC06, 0xFFFC, 0xFFF9, 
    0xFFF4, 0xFFEE, 0xFFE9, 0xFFE5, 0xFFE3, 0xFFE1, 0xFFE0, 0x0096, 0x008F, 
    0x007D, 0x0069, 0x0059, 0x004D, 0x0045, 0x0040, 0x003E, 0x003D, 0x003C, 
    0x4431, 0x411D, 0x39F0, 0x31C5, 0x2B24, 0x2654, 0x230B, 0x20FE, 0x1FE3, 
    0x1F6F, 0x1F59, 0x00CC, 0x00C7, 0x00BD, 0x00B0, 0x00A7, 0x009F, 0x009A, 
    0x0097, 0x0096, 0x0095, 0xFF52, 0xFF4C, 0xFF3E, 0xFF2D, 0xFF20, 0xFF16, 
    0xFF0F, 0xFF0B, 0xFF09, 0xFF08, 0xA837, 0xAB3A, 0xB23F, 0xBA3C, 0xC0B8, 
    0xC56D, 0xC8A4, 0xCAA6, 0xCBBB, 0xCC2C, 0xCC41, 0xFFFF, 0xFFFF, 0xFFFF, 
    0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xF0A8, 
    0xF4A2, 0xFC05, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 
    0xFFFF, 0xBF5E, 0xFEE8, 0xFEEF, 0xFEFE, 0xFF0F, 0xFF1C, 0xFF26, 0xFF2D, 
    0xFF31, 0xFF34, 0xFF35, 0xFF3D, 0xFEEC, 0xFE2E, 0xFD55, 0xFCA6, 0xFC26, 
    0xFBCF, 0xFB99, 0xFB7C, 0xFB70, 0xFB6E, 0xA19A, 0x9F3B, 0x99B5, 0x936C, 
    0x8E52, 0x8A9E, 0x8816, 0x8682, 0x85A8, 0x854F, 0x853E, 0xFF6B, 0xFF78, 
    0xFF94, 0xFFB5, 0xFFD0, 0xFFE3, 0xFFF0, 0xFFF8, 0xFFFD, 0xFFFF, 0x0000, 
    0xFE3F, 0xFE64, 0xFEBB, 0xFF1F, 0xFF70, 0xFFAA, 0xFFD2, 0xFFEB, 0xFFF8, 
    0xFFFE, 0xFFFF, 0x4524, 0x3F8F, 0x328F, 0x23C2, 0x17BF, 0x0F06, 0x0911, 
    0x055A, 0x0358, 0x0287, 0x025F, 0xFF2C, 0xFF58, 0xFFBE, 0x0033, 0x0091, 
    0x00D6, 0x0104, 0x0121, 0x0131, 0x0138, 0x0139, 0x01B5, 0x01BF, 0x01D5, 
    0x01EE, 0x0202, 0x0211, 0x021B, 0x0221, 0x0225, 0x0226, 0xA713, 0xAD1D, 
    0xBB2D, 0xCB30, 0xD82E, 0xE19E, 0xE80F, 0xEC15, 0xEE40, 0xEF22, 0xEF4E,
    },
    {
    0x0001, 0x0000, 0x000A, 0x0001, 0x0001, 0x000B, 0x0001, 0x000C, 0x0001, 
    0x000D, 0x0001, 0x000E, 0x0005, 0x000F, 0x0005, 0x0014, 0x000B, 0x0019, 
    0x0001, 0x0024, 0x0005, 0x0025, 0x000B, 0x002A, 0x0001, 0x0035, 0x0006, 
    0x0036, 0x000B, 0x003C, 0x0001, 0x0047, 0x0001, 0x0048, 0x0001, 0x0049, 
    0x000B, 0x004A, 0x000B, 0x0055, 0x000B, 0x0060, 0x000B, 0x006B, 0x000B, 
    0x0076, 0x000B, 0x0081, 0x000B, 0x008C, 0x000B, 0x0097, 0x000B, 0x00A2, 
    0x0001, 0x00AD, 0x0001, 0x00AE, 0x0001, 0x00AF, 0x000B, 0x00B0, 0x000B, 
    0x00BB, 0x000B, 0x00C6, 0x0003, 0x00D1, 0x000B, 0x00D4, 0x000B, 0x00DF, 
    0x000B, 0x00EA, 0x000A, 0x00F5, 0x000B, 0x00FF, 0x000B, 0x010A, 0x000B, 
    0x0115, 0x0001, 0x0120, 0x0001, 0x0121, 0x0003, 0x0122, 0x000B, 0x0125, 
    0x0009, 0x0130, 0x000B, 0x0139, 0x000B, 0x0144, 0x000A, 0x014F, 0x000A, 
    0x0159, 0x000B, 0x0163, 0x000B, 0x016E, 0x000B, 0x0179, 0x0001, 0x0184, 
    0x000A, 0x0185, 0x000B, 0x018F, 0x000B, 0x019A, 0x000B, 0x01A5, 0x000B, 
    0x01B0, 0x000B, 0x01BB, 0x000B, 0x01C6, 0x000A, 0x01D1, 0x000B, 0x01DB, 
})

smlua_anim_util_register_animation("WALUIGI_ANIM_ELEGANT_JUMP_2",
    1,
    0,
    0,
    0,
    10,
    {
    0x0000, 0x0001, 0x0004, 0x0008, 0x000A, 0x000C, 0x000E, 0x000F, 0x00E3, 
    0x00FA, 0x012A, 0x0157, 0x0174, 0x0189, 0x0197, 0x01A0, 0x01A4, 0x01A6, 
    0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFF, 0x0003, 0x000A, 0x0011, 0x0018, 
    0x001C, 0x001F, 0x0021, 0x0022, 0x0023, 0xFFFF, 0x00BA, 0x026D, 0x045B, 
    0x05EC, 0x070F, 0x07D6, 0x0852, 0x0895, 0x08B0, 0x08B6, 0x40A1, 0x40A1, 
    0x40A2, 0x40A3, 0x40A3, 0x40A4, 0x40A4, 0x40A5, 0xFFFF, 0x0033, 0x00AA, 
    0x0132, 0x01A0, 0x01F0, 0x0226, 0x0248, 0x025B, 0x0262, 0x0264, 0xFFFE, 
    0xFF4B, 0xFDA9, 0xFBCE, 0xFA4C, 0xF934, 0xF875, 0xF7FD, 0xF7BD, 0xF7A3, 
    0xF79E, 0x1942, 0x1624, 0x0EE1, 0x069D, 0xFFE7, 0xFB08, 0xF7B5, 0xF5A1, 
    0xF482, 0xF40E, 0xF3F7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 
    0x0001, 0x0F37, 0x0B5D, 0x0264, 0xF82D, 0xEFE3, 0xE9DF, 0xE5C3, 0xE332, 
    0xE1D0, 0xE140, 0xE124, 0xFFFE, 0x0001, 0xC170, 0xD59F, 0xDE3C, 0xF24A, 
    0x0920, 0x1BA7, 0x291B, 0x324B, 0x3808, 0x3B1F, 0x3C62, 0x3CA0, 0xDE99, 
    0xE0E4, 0xE63C, 0xEC50, 0xF13F, 0xF4D4, 0xF747, 0xF8CE, 0xF9A0, 0xF9F6, 
    0xFA07, 0xEF50, 0xE223, 0xC372, 0xA081, 0x8427, 0x6F91, 0x6181, 0x58BA, 
    0x53FE, 0x5210, 0x51B2, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
    0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 
    0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xC80A, 0xCB6C, 
    0xD34E, 0xDC47, 0xE38F, 0xE8D8, 0xEC75, 0xEEB6, 0xEFED, 0xF06C, 0xF084, 
    0xFF89, 0xFB53, 0xF183, 0xE657, 0xDD46, 0xD6B2, 0xD233, 0xCF64, 0xCDE1, 
    0xCD43, 0xCD25, 0xF97F, 0xF853, 0xF598, 0xF27D, 0xEFF7, 0xEE22, 0xECE2, 
    0xEC1A, 0xEBAF, 0xEB83, 0xEB7A, 0xF06E, 0xED0E, 0xE530, 0xDC3C, 0xD4F8, 
    0xCFB1, 0xCC16, 0xC9D7, 0xC8A0, 0xC821, 0xC809, 0xFFFE, 0x0001, 0xC170, 
    0x3101, 0x2849, 0x13FB, 0xFCDC, 0xEA19, 0xDC7A, 0xD32D, 0xCD5E, 0xCA3C, 
    0xC8F6, 0xC8B7, 0x218C, 0x1EF5, 0x18EF, 0x1212, 0x0C81, 0x0876, 0x05B4, 
    0x03FA, 0x030D, 0x02AB, 0x0299, 0xF057, 0xE313, 0xC42F, 0xA102, 0x8478, 
    0x6FBF, 0x6197, 0x58C2, 0x53FE, 0x520D, 0x51AE, 0xFFFF, 0x0000, 0xFFFF, 
    0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
    0x0000, 0xFFFF, 0x0000, 0xCB4C, 0xCEAE, 0xD690, 0xDF89, 0xE6D1, 0xEC1A, 
    0xEFB7, 0xF1F8, 0xF32F, 0xF3AE, 0xF3C6, 0xFFFF, 0x0460, 0x0E90, 0x1A29, 
    0x2392, 0x2A67, 0x2F12, 0x31FC, 0x338E, 0x3432, 0x3452, 0xFFFF, 0x017B, 
    0x04EE, 0x08DC, 0x0C0C, 0x0E5C, 0x0FF1, 0x10EE, 0x1176, 0x11AD, 0x11B8, 
    0xED8B, 0xEA7E, 0xE363, 0xDB4C, 0xD4BB, 0xCFF7, 0xCCB5, 0xCAAD, 0xC995, 
    0xC922, 0xC90C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
    0x0000, 0x0000, 0x0000, 0xFFFF, 0x0F57, 0x0E0F, 0x0B12, 0x07AC, 0x04E9, 
    0x02E8, 0x018A, 0x00AF, 0x0039, 0x0009, 0xFFFF, 0xBF5E, 0x0040, 0xFF3B, 
    0xFCDB, 0xFA28, 0xF7F7, 0xF660, 0xF54A, 0xF49C, 0xF43E, 0xF418, 0xF411, 
    0x0055, 0x0077, 0x00C5, 0x011E, 0x0166, 0x019B, 0x01BF, 0x01D5, 0x01E1, 
    0x01E6, 0x01E7, 0xA21B, 0xA231, 0xA264, 0xA29F, 0xA2CF, 0xA2F1, 0xA309, 
    0xA318, 0xA320, 0xA323, 0xFFFC, 0xFFE9, 0xFFBD, 0xFF8B, 0xFF63, 0xFF46, 
    0xFF32, 0xFF25, 0xFF1E, 0xFF1C, 0xFF1B, 0x0096, 0x00AC, 0x00DE, 0x0117, 
    0x0145, 0x0167, 0x017E, 0x018C, 0x0194, 0x0197, 0x0198, 0x4431, 0x4451, 
    0x449A, 0x44ED, 0x4531, 0x4562, 0x4584, 0x4599, 0x45A4, 0x45A9, 0x45AA, 
    0x00CC, 0x00C7, 0x00BD, 0x00B0, 0x00A7, 0x009F, 0x009A, 0x0097, 0x0096, 
    0x0095, 0xFF52, 0xFF4C, 0xFF3E, 0xFF2D, 0xFF20, 0xFF16, 0xFF0F, 0xFF0B, 
    0xFF09, 0xFF08, 0xA837, 0xAB3A, 0xB23F, 0xBA3C, 0xC0B8, 0xC56D, 0xC8A4, 
    0xCAA6, 0xCBBB, 0xCC2C, 0xCC41, 0xFFFF, 0xF0A8, 0xF1F0, 0xF4ED, 0xF853, 
    0xFB16, 0xFD17, 0xFE75, 0xFF50, 0xFFC6, 0xFFF6, 0xFFFF, 0xBF5E, 0xFEE8, 
    0xFEC8, 0xFE7E, 0xFE29, 0xFDE5, 0xFDB3, 0xFD91, 0xFD7B, 0xFD70, 0xFD6B, 
    0xFD6A, 0xFF3D, 0xFFC3, 0x00FB, 0x025D, 0x037D, 0x044D, 0x04DC, 0x0535, 
    0x0565, 0x0579, 0x057C, 0xA19A, 0xA38B, 0xA811, 0xAD37, 0xB165, 0xB46E, 
    0xB680, 0xB7CC, 0xB87E, 0xB8C7, 0xB8D5, 0xFF6B, 0xFF78, 0xFF94, 0xFFB5, 
    0xFFD0, 0xFFE3, 0xFFF0, 0xFFF8, 0xFFFD, 0xFFFF, 0xFE3F, 0xFE64, 0xFEBB, 
    0xFF1F, 0xFF70, 0xFFAA, 0xFFD2, 0xFFEB, 0xFFF8, 0xFFFE, 0x0000, 0x4524, 
    0x4053, 0x351A, 0x2853, 0x1DF6, 0x166E, 0x114A, 0x0E15, 0x0C5A, 0x0BA5, 
    0x0B83, 0xFF2C, 0xFF6C, 0x0003, 0x00AD, 0x0137, 0x019B, 0x01E0, 0x020B, 
    0x0222, 0x022B, 0x022D, 0x01B5, 0x01A4, 0x017C, 0x014F, 0x012A, 0x0110, 
    0x00FD, 0x00F2, 0x00EC, 0x00E9, 0xA713, 0xADF1, 0xBDED, 0xD022, 0xDEE7, 
    0xE9A1, 0xF0F4, 0xF586, 0xF7FE, 0xF8FF, 0xF930, 
    },
    {
    0x0008, 0x0000, 0x000A, 0x0008, 0x0001, 0x0012, 0x0001, 0x0013, 0x0001, 
    0x0014, 0x0001, 0x0015, 0x000A, 0x0016, 0x000B, 0x0020, 0x0008, 0x002B, 
    0x000B, 0x0033, 0x000B, 0x003E, 0x000B, 0x0049, 0x0001, 0x0054, 0x0006, 
    0x0055, 0x000B, 0x005B, 0x0001, 0x0066, 0x0001, 0x0067, 0x0001, 0x0068, 
    0x000B, 0x0069, 0x000B, 0x0074, 0x000B, 0x007F, 0x000B, 0x008A, 0x000B, 
    0x0095, 0x000B, 0x00A0, 0x000B, 0x00AB, 0x000B, 0x00B6, 0x000B, 0x00C1, 
    0x0001, 0x00CC, 0x0001, 0x00CD, 0x0001, 0x00CE, 0x000B, 0x00CF, 0x000B, 
    0x00DA, 0x000B, 0x00E5, 0x000B, 0x00F0, 0x0004, 0x00FB, 0x000B, 0x00FF, 
    0x000B, 0x010A, 0x000B, 0x0115, 0x000B, 0x0120, 0x000B, 0x012B, 0x000B, 
    0x0136, 0x0001, 0x0141, 0x000B, 0x0142, 0x000B, 0x014D, 0x000A, 0x0158, 
    0x000B, 0x0162, 0x000B, 0x016D, 0x000B, 0x0178, 0x000A, 0x0183, 0x000A, 
    0x018D, 0x000B, 0x0197, 0x0001, 0x01A2, 0x000B, 0x01A3, 0x0001, 0x01AE, 
    0x000B, 0x01AF, 0x000B, 0x01BA, 0x000B, 0x01C5, 0x000A, 0x01D0, 0x000B, 
    0x01DA, 0x000B, 0x01E5, 0x000B, 0x01F0, 0x000A, 0x01FB, 0x000B, 0x0205, 
})

smlua_anim_util_register_animation("MARIO_ANIM_HANDSTAND_IDLE",
    0,
    0,
    0,
    0,
    40,
    {
    0x0000, 0x0117, 0x0117, 0x0117, 0x0116, 0x0116, 0x0115, 0x0115, 0x0114, 
	0x0114, 0x0114, 0x0114, 0x0114, 0x0114, 0x0115, 0x0115, 0x0116, 0x0116, 
	0x0117, 0x0117, 0x0117, 0x0118, 0x0117, 0x0117, 0x0117, 0x0116, 0x0116, 
	0x0115, 0x0115, 0x0114, 0x0114, 0x0114, 0x0114, 0x0114, 0x0115, 0x0115, 
	0x0116, 0x0116, 0x0117, 0x0117, 0x0117, 0x0118, 0x0000, 0x0001, 0x0002, 
	0x0004, 0x0005, 0x0007, 0x0008, 0x000A, 0x000B, 0x000B, 0x000B, 0x000B, 
	0x000A, 0x0008, 0x0007, 0x0005, 0x0004, 0x0002, 0x0001, 0x0000, 0x0000, 
	0x0000, 0x0001, 0x0002, 0x0004, 0x0005, 0x0007, 0x0008, 0x000A, 0x000B, 
	0x000B, 0x000B, 0x000A, 0x0008, 0x0007, 0x0005, 0x0004, 0x0002, 0x0001, 
	0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFD, 0xFFFF, 0xB4A4, 0xB521, 0xB5DA, 
	0xB6BA, 0xB7AD, 0xB8A1, 0xB981, 0xBA3A, 0xBAB7, 0xBAE5, 0xBAE5, 0xBAB7, 
	0xBA3A, 0xB981, 0xB8A1, 0xB7AD, 0xB6BA, 0xB5DA, 0xB521, 0xB4A4, 0xB476, 
	0xB4A4, 0xB521, 0xB5DA, 0xB6BA, 0xB7AD, 0xB8A1, 0xB981, 0xBA3A, 0xBAB7, 
	0xBAE5, 0xBAB7, 0xBA3A, 0xB981, 0xB8A1, 0xB7AD, 0xB6BA, 0xB5DA, 0xB521, 
	0xB4A4, 0xB476, 0xFFFF, 0x0000, 0xFECD, 0xFE50, 0xFD97, 0xFCB7, 0xFBC3, 
	0xFAD0, 0xF9F0, 0xF937, 0xF8BA, 0xF88C, 0xF88C, 0xF8BA, 0xF937, 0xF9F0, 
	0xFAD0, 0xFBC3, 0xFCB7, 0xFD97, 0xFE50, 0xFECD, 0xFEFB, 0xFECD, 0xFE50, 
	0xFD97, 0xFCB7, 0xFBC3, 0xFAD0, 0xF9F0, 0xF937, 0xF8BA, 0xF88C, 0xF8BA, 
	0xF937, 0xF9F0, 0xFAD0, 0xFBC3, 0xFCB7, 0xFD97, 0xFE50, 0xFECD, 0xFEFB, 
	0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
	0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFE, 
	0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFD, 
	0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 
	0xFFFD, 0xFFFE, 0x0001, 0xAB0D, 0xAADC, 0xAA93, 0xAA3B, 0xA9DC, 0xA97C, 
	0xA924, 0xA8DC, 0xA8AA, 0xA898, 0xA898, 0xA8AA, 0xA8DC, 0xA924, 0xA97C, 
	0xA9DC, 0xAA3B, 0xAA93, 0xAADC, 0xAB0D, 0xAB1F, 0xAB0D, 0xAADC, 0xAA93, 
	0xAA3B, 0xA9DC, 0xA97C, 0xA924, 0xA8DC, 0xA8AA, 0xA898, 0xA8AA, 0xA8DC, 
	0xA924, 0xA97C, 0xA9DC, 0xAA3B, 0xAA93, 0xAADC, 0xAB0D, 0xAB1F, 0xFFFE, 
	0x0001, 0xC170, 0x42EA, 0x4266, 0x41A4, 0x40B8, 0x3FB8, 0x3EB7, 0x3DCB, 
	0x3D09, 0x3C85, 0x3C55, 0x3C55, 0x3C85, 0x3D09, 0x3DCB, 0x3EB7, 0x3FB8, 
	0x40B8, 0x41A4, 0x4266, 0x42EA, 0x431B, 0x42EA, 0x4266, 0x41A4, 0x40B8, 
	0x3FB8, 0x3EB7, 0x3DCB, 0x3D09, 0x3C85, 0x3C55, 0x3C85, 0x3D09, 0x3DCB, 
	0x3EB7, 0x3FB8, 0x40B8, 0x41A4, 0x4266, 0x42EA, 0x431B, 0xEF7F, 0xEEFF, 
	0xEE42, 0xED5D, 0xEC64, 0xEB6B, 0xEA86, 0xE9C9, 0xE949, 0xE91A, 0xE91A, 
	0xE949, 0xE9C9, 0xEA86, 0xEB6B, 0xEC64, 0xED5D, 0xEE42, 0xEEFF, 0xEF7F, 
	0xEFAE, 0xEF7F, 0xEEFF, 0xEE42, 0xED5D, 0xEC64, 0xEB6B, 0xEA86, 0xE9C9, 
	0xE949, 0xE91A, 0xE949, 0xE9C9, 0xEA86, 0xEB6B, 0xEC64, 0xED5D, 0xEE42, 
	0xEEFF, 0xEF7F, 0xEFAE, 0x4376, 0x4366, 0x434E, 0x4331, 0x4311, 0x42F1, 
	0x42D4, 0x42BC, 0x42AB, 0x42A5, 0x42A5, 0x42AB, 0x42BC, 0x42D4, 0x42F1, 
	0x4311, 0x4331, 0x434E, 0x4366, 0x4376, 0x437C, 0x4376, 0x4366, 0x434E, 
	0x4331, 0x4311, 0x42F1, 0x42D4, 0x42BC, 0x42AB, 0x42A5, 0x42AB, 0x42BC, 
	0x42D4, 0x42F1, 0x4311, 0x4331, 0x434E, 0x4366, 0x4376, 0x437C, 0xFFFE, 
	0xFFFB, 0xFFF8, 0xFFF3, 0xFFEE, 0xFFE9, 0xFFE4, 0xFFE0, 0xFFDE, 0xFFDD, 
	0xFFDD, 0xFFDE, 0xFFE0, 0xFFE4, 0xFFE9, 0xFFEE, 0xFFF3, 0xFFF8, 0xFFFB, 
	0xFFFE, 0x0000, 0xFFFE, 0xFFFB, 0xFFF8, 0xFFF3, 0xFFEE, 0xFFE9, 0xFFE4, 
	0xFFE0, 0xFFDE, 0xFFDD, 0xFFDE, 0xFFE0, 0xFFE4, 0xFFE9, 0xFFEE, 0xFFF3, 
	0xFFF8, 0xFFFB, 0xFFFE, 0x0000, 0x0009, 0x0022, 0x0046, 0x0072, 0x00A2, 
	0x00D2, 0x00FE, 0x0123, 0x013B, 0x0145, 0x0145, 0x013B, 0x0123, 0x00FE, 
	0x00D2, 0x00A2, 0x0072, 0x0046, 0x0022, 0x0009, 0x0000, 0x0009, 0x0022, 
	0x0046, 0x0072, 0x00A2, 0x00D2, 0x00FE, 0x0123, 0x013B, 0x0145, 0x013B, 
	0x0123, 0x00FE, 0x00D2, 0x00A2, 0x0072, 0x0046, 0x0022, 0x0009, 0x0000, 
	0xF030, 0xEF4B, 0xEDFA, 0xEC61, 0xEAA3, 0xE8E6, 0xE74D, 0xE5FC, 0xE517, 
	0xE4C3, 0xE4C3, 0xE517, 0xE5FC, 0xE74D, 0xE8E6, 0xEAA3, 0xEC61, 0xEDFA, 
	0xEF4B, 0xF030, 0xF084, 0xF030, 0xEF4B, 0xEDFA, 0xEC61, 0xEAA3, 0xE8E6, 
	0xE74D, 0xE5FC, 0xE517, 0xE4C3, 0xE517, 0xE5FC, 0xE74D, 0xE8E6, 0xEAA3, 
	0xEC61, 0xEDFA, 0xEF4B, 0xF030, 0xF084, 0x0FDF, 0x104F, 0x10F2, 0x11BA, 
	0x1292, 0x136B, 0x1432, 0x14D6, 0x1545, 0x156E, 0x156E, 0x1545, 0x14D6, 
	0x1432, 0x136B, 0x1292, 0x11BA, 0x10F3, 0x104F, 0x0FDF, 0x0FB6, 0x0FDF, 
	0x104F, 0x10F2, 0x11BA, 0x1292, 0x136B, 0x1432, 0x14D6, 0x1545, 0x156E, 
	0x1545, 0x14D6, 0x1432, 0x136B, 0x1292, 0x11BA, 0x10F3, 0x104F, 0x0FDF, 
	0x0FB6, 0xC9A9, 0xCA3C, 0xCB15, 0xCC1C, 0xCD3A, 0xCE59, 0xCF60, 0xD039, 
	0xD0CC, 0xD102, 0xD102, 0xD0CC, 0xD039, 0xCF60, 0xCE59, 0xCD3A, 0xCC1C, 
	0xCB15, 0xCA3C, 0xC9A9, 0xC973, 0xC9A9, 0xCA3C, 0xCB15, 0xCC1C, 0xCD3A, 
	0xCE59, 0xCF60, 0xD039, 0xD0CC, 0xD102, 0xD0CC, 0xD039, 0xCF60, 0xCE59, 
	0xCD3A, 0xCC1C, 0xCB15, 0xCA3C, 0xC9A9, 0xC973, 0xDA19, 0xDA1B, 0xDA1E, 
	0xDA21, 0xDA25, 0xDA29, 0xDA2D, 0xDA30, 0xDA32, 0xDA32, 0xDA32, 0xDA32, 
	0xDA30, 0xDA2D, 0xDA29, 0xDA25, 0xDA21, 0xDA1E, 0xDA1B, 0xDA19, 0xDA18, 
	0xDA19, 0xDA1B, 0xDA1E, 0xDA21, 0xDA25, 0xDA29, 0xDA2D, 0xDA30, 0xDA32, 
	0xDA32, 0xDA32, 0xDA30, 0xDA2D, 0xDA29, 0xDA25, 0xDA21, 0xDA1E, 0xDA1B, 
	0xDA19, 0xDA18, 0xFFFE, 0x0001, 0xC390, 0xBE13, 0xBDDE, 0xBD91, 0xBD33, 
	0xBCCC, 0xBC66, 0xBC08, 0xBBBA, 0xBB86, 0xBB72, 0xBB72, 0xBB86, 0xBBBA, 
	0xBC08, 0xBC66, 0xBCCC, 0xBD33, 0xBD91, 0xBDDE, 0xBE13, 0xBE26, 0xBE13, 
	0xBDDE, 0xBD91, 0xBD33, 0xBCCC, 0xBC66, 0xBC08, 0xBBBA, 0xBB86, 0xBB72, 
	0xBB86, 0xBBBA, 0xBC08, 0xBC66, 0xBCCC, 0xBD33, 0xBD91, 0xBDDE, 0xBE13, 
	0xBE26, 0x0D00, 0x0DB8, 0x0EC6, 0x100F, 0x1175, 0x12DA, 0x1423, 0x1532, 
	0x15E9, 0x162D, 0x162D, 0x15E9, 0x1532, 0x1423, 0x12DA, 0x1175, 0x100F, 
	0x0EC6, 0x0DB8, 0x0D00, 0x0CBC, 0x0D00, 0x0DB8, 0x0EC6, 0x100F, 0x1175, 
	0x12DA, 0x1423, 0x1532, 0x15E9, 0x162D, 0x15E9, 0x1532, 0x1423, 0x12DA, 
	0x1175, 0x100F, 0x0EC6, 0x0DB8, 0x0D00, 0x0CBC, 0x3F1D, 0x3F07, 0x3EE6, 
	0x3EBF, 0x3E94, 0x3E69, 0x3E42, 0x3E22, 0x3E0C, 0x3E03, 0x3E03, 0x3E0C, 
	0x3E22, 0x3E42, 0x3E69, 0x3E94, 0x3EBF, 0x3EE6, 0x3F07, 0x3F1D, 0x3F25, 
	0x3F1D, 0x3F07, 0x3EE6, 0x3EBF, 0x3E94, 0x3E69, 0x3E42, 0x3E22, 0x3E0C, 
	0x3E03, 0x3E0C, 0x3E22, 0x3E42, 0x3E69, 0x3E94, 0x3EBF, 0x3EE6, 0x3F07, 
	0x3F1D, 0x3F25, 0x000E, 0x0034, 0x006C, 0x00B1, 0x00FB, 0x0145, 0x0189, 
	0x01C2, 0x01E8, 0x01F6, 0x01F6, 0x01E8, 0x01C2, 0x0189, 0x0145, 0x00FB, 
	0x00B1, 0x006C, 0x0034, 0x000E, 0x0000, 0x000E, 0x0034, 0x006C, 0x00B1, 
	0x00FB, 0x0145, 0x0189, 0x01C2, 0x01E8, 0x01F6, 0x01E8, 0x01C2, 0x0189, 
	0x0145, 0x00FB, 0x00B1, 0x006C, 0x0034, 0x000E, 0x0000, 0x0007, 0x001A, 
	0x0036, 0x0058, 0x007E, 0x00A3, 0x00C5, 0x00E1, 0x00F4, 0x00FB, 0x00FB, 
	0x00F4, 0x00E1, 0x00C5, 0x00A3, 0x007E, 0x0058, 0x0036, 0x001A, 0x0007, 
	0x0000, 0x0007, 0x001A, 0x0036, 0x0058, 0x007E, 0x00A3, 0x00C5, 0x00E1, 
	0x00F4, 0x00FB, 0x00F4, 0x00E1, 0x00C5, 0x00A3, 0x007E, 0x0058, 0x0036, 
	0x001A, 0x0007, 0x0000, 0xF34F, 0xF20D, 0xF031, 0xEDF0, 0xEB7C, 0xE907, 
	0xE6C6, 0xE4EB, 0xE3A8, 0xE331, 0xE331, 0xE3A8, 0xE4EB, 0xE6C6, 0xE907, 
	0xEB7C, 0xEDF0, 0xF031, 0xF20D, 0xF34F, 0xF3C6, 0xF34F, 0xF20D, 0xF031, 
	0xEDF0, 0xEB7C, 0xE907, 0xE6C6, 0xE4EB, 0xE3A8, 0xE331, 0xE3A8, 0xE4EB, 
	0xE6C6, 0xE907, 0xEB7C, 0xEDF0, 0xF031, 0xF20D, 0xF34F, 0xF3C6, 0xFFA4, 
	0xFEAD, 0xFD42, 0xFB88, 0xF9A7, 0xF7C6, 0xF60D, 0xF4A1, 0xF3AA, 0xF34F, 
	0xF34F, 0xF3AA, 0xF4A1, 0xF60D, 0xF7C6, 0xF9A7, 0xFB88, 0xFD42, 0xFEAD, 
	0xFFA4, 0x0000, 0xFFA4, 0xFEAD, 0xFD42, 0xFB88, 0xF9A7, 0xF7C6, 0xF60D, 
	0xF4A1, 0xF3AA, 0xF34F, 0xF3AA, 0xF4A1, 0xF60D, 0xF7C6, 0xF9A7, 0xFB88, 
	0xFD42, 0xFEAD, 0xFFA4, 0x0000, 0x3CDC, 0x3CC9, 0x3CAE, 0x3C8C, 0x3C68, 
	0x3C44, 0x3C23, 0x3C08, 0x3BF5, 0x3BEE, 0x3BEE, 0x3BF5, 0x3C08, 0x3C23, 
	0x3C44, 0x3C68, 0x3C8D, 0x3CAE, 0x3CC9, 0x3CDC, 0x3CE3, 0x3CDC, 0x3CC9, 
	0x3CAE, 0x3C8C, 0x3C68, 0x3C44, 0x3C23, 0x3C08, 0x3BF5, 0x3BEE, 0x3BF5, 
	0x3C08, 0x3C23, 0x3C44, 0x3C68, 0x3C8D, 0x3CAE, 0x3CC9, 0x3CDC, 0x3CE3, 
	0xED5D, 0xECE0, 0xEC27, 0xEB46, 0xEA52, 0xE95E, 0xE87D, 0xE7C4, 0xE747, 
	0xE719, 0xE719, 0xE747, 0xE7C4, 0xE87D, 0xE95E, 0xEA52, 0xEB46, 0xEC27, 
	0xECE0, 0xED5D, 0xED8B, 0xED5D, 0xECE0, 0xEC27, 0xEB46, 0xEA52, 0xE95E, 
	0xE87D, 0xE7C4, 0xE747, 0xE719, 0xE747, 0xE7C4, 0xE87D, 0xE95E, 0xEA52, 
	0xEB46, 0xEC27, 0xECE0, 0xED5D, 0xED8B, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
	0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
	0xFFFF, 0xBF5E, 0x0040, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 
	0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 
	0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 0x0056, 
	0x0056, 0x0056, 0x0056, 0x0055, 0x0055, 0x0055, 0x0055, 0x0055, 0x0056, 
	0xC82B, 0xC8DA, 0xC966, 0xC9D5, 0xCA2A, 0xCA67, 0xCA91, 0xCAAB, 0xCAB8, 
	0xCABB, 0xCABB, 0xCA74, 0xC9A8, 0xC866, 0xC6BC, 0xC4B8, 0xC268, 0xBFDC, 
	0xBD20, 0xBA43, 0xB754, 0xB462, 0xB17B, 0xAEAF, 0xAC10, 0xA9AC, 0xA794, 
	0xA5D7, 0xA485, 0xA3AF, 0xA364, 0xA44C, 0xA6C7, 0xAA77, 0xAEFD, 0xB3FC, 
	0xB916, 0xBDEE, 0xC224, 0xC55C, 0xC737, 0xFFED, 0xFFEE, 0xFFEF, 0xFFF0, 
	0xFFF1, 0xFFF2, 0xFFF2, 0xFFF3, 0xFFF4, 0xFFF5, 0xFFF3, 0xFFF4, 0xFFF5, 
	0xFFF6, 0xFFF7, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFF9, 0xFFF9, 0xFFFA, 0xFFF9, 
	0xFFF8, 0xFFF6, 0xFFF3, 0xFFF0, 0xFFEE, 0xFFEB, 0xFFE9, 0xFFE8, 0xFFE7, 
	0xFFE7, 0xFFE7, 0xFFE8, 0xFFE8, 0xFFE9, 0xFFE9, 0xFFEA, 0xFFEB, 0xFFEB, 
	0xFFEC, 0x0019, 0x001A, 0x001A, 0x001B, 0x001B, 0x001C, 0x001C, 0x001D, 
	0x001D, 0x001D, 0x001C, 0x001C, 0x001C, 0x001D, 0x001D, 0x001E, 0x001E, 
	0x001E, 0x001E, 0x001E, 0x001E, 0x001E, 0x001D, 0x001C, 0x001B, 0x0019, 
	0x0018, 0x0016, 0x0015, 0x0014, 0x0014, 0x0014, 0x0014, 0x0014, 0x0015, 
	0x0015, 0x0016, 0x0017, 0x0017, 0x0018, 0x0019, 0x126F, 0x13D8, 0x153F, 
	0x16A1, 0x17FE, 0x1952, 0x1A9B, 0x1BD9, 0x1D09, 0x1E28, 0x1AA2, 0x1C12, 
	0x1D7B, 0x1ED4, 0x2018, 0x213E, 0x223F, 0x2314, 0x23B5, 0x241B, 0x243F, 
	0x2373, 0x2148, 0x1E16, 0x1A36, 0x15FD, 0x11C5, 0x0DE4, 0x0AB3, 0x0888, 
	0x07BC, 0x07DE, 0x0840, 0x08DA, 0x09A6, 0x0A9E, 0x0BB9, 0x0CF2, 0x0E41, 
	0x0F9F, 0x1106, 0x0077, 0x0066, 0x0056, 0x0045, 0x0035, 0x0025, 0x0016, 
	0x0008, 0xFFFA, 0xFFEF, 0xFFD2, 0xFFC3, 0xFFB7, 0xFFAC, 0xFFA3, 0xFF9B, 
	0xFF95, 0xFF90, 0xFF8C, 0xFF89, 0xFF87, 0xFF85, 0xFF84, 0xFF84, 0xFF84, 
	0xFF84, 0xFFA9, 0x0002, 0x006B, 0x00C3, 0x00E8, 0x00E7, 0x00E3, 0x00DD, 
	0x00D5, 0x00CC, 0x00C0, 0x00B4, 0x00A6, 0x0097, 0x0087, 0xFEFC, 0xFEF7, 
	0xFEF3, 0xFEF0, 0xFEED, 0xFEEA, 0xFEE8, 0xFEE7, 0xFEE6, 0xFEE5, 0xFEE4, 
	0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE4, 
	0xFEE4, 0xFEE4, 0xFEE5, 0xFEE7, 0xFEEC, 0xFEF9, 0xFF0D, 0xFF25, 0xFF3D, 
	0xFF4F, 0xFF56, 0xFF54, 0xFF4F, 0xFF48, 0xFF3E, 0xFF33, 0xFF28, 0xFF1D, 
	0xFF12, 0xFF09, 0xFF02, 0xD4B1, 0xD75A, 0xD9F2, 0xDC76, 0xDEDF, 0xE127, 
	0xE349, 0xE540, 0xE706, 0xE895, 0xEC6B, 0xEE7B, 0xF038, 0xF1B8, 0xF2FE, 
	0xF411, 0xF4F3, 0xF5AA, 0xF63A, 0xF6A8, 0xF6F9, 0xF731, 0xF754, 0xF767, 
	0xF770, 0xF772, 0xF1A3, 0xE3CA, 0xD343, 0xC56A, 0xBF9B, 0xBFE1, 0xC0A7, 
	0xC1DF, 0xC37A, 0xC569, 0xC79E, 0xCA09, 0xCC9C, 0xCF48, 0xD1FE, 0x0000, 
	0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
	0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 
	0x0000, 0x0000, 0x0000, 0xFFFF, 0xBF5E, 0xFEE8, 0xFF3E, 0xFF3E, 0xFF3E, 
	0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3E, 0xFF3D, 0xFF3D, 0xFF3D, 0xFF3D, 
	0xFF3E, 0xB53F, 0xB23E, 0xAF52, 0xAC8B, 0xA9FE, 0xA7BD, 0xA5DB, 0xA46C, 
	0xA382, 0xA32F, 0xA32F, 0xA414, 0xA684, 0xAA24, 0xAE9A, 0xB38A, 0xB899, 
	0xBD6B, 0xC1A6, 0xC4EE, 0xC6E8, 0xC7FE, 0xC8CA, 0xC96D, 0xC9EC, 0xCA4C, 
	0xCA91, 0xCABF, 0xCADB, 0xCAE8, 0xCAEC, 0xCAAA, 0xC9EF, 0xC8C4, 0xC735, 
	0xC54F, 0xC31D, 0xC0AA, 0xBE01, 0xBB30, 0xB840, 0x0014, 0x0021, 0x0034, 
	0x004B, 0x0065, 0x007E, 0x0095, 0x00A8, 0x00B5, 0x00BA, 0x00BA, 0x00B5, 
	0x00A8, 0x0095, 0x007E, 0x0065, 0x004B, 0x0034, 0x0021, 0x0014, 0x0010, 
	0x0012, 0x0017, 0x001F, 0x0029, 0x0034, 0x003F, 0x0049, 0x0051, 0x0057, 
	0x0059, 0x0057, 0x0051, 0x0049, 0x003F, 0x0034, 0x0029, 0x001F, 0x0017, 
	0x0012, 0x0010, 0xFEFE, 0xFF04, 0xFF0D, 0xFF17, 0xFF23, 0xFF2E, 0xFF39, 
	0xFF42, 0xFF48, 0xFF4A, 0xFF4A, 0xFF48, 0xFF42, 0xFF39, 0xFF2E, 0xFF23, 
	0xFF17, 0xFF0D, 0xFF04, 0xFEFE, 0xFEFC, 0xFEFC, 0xFEFE, 0xFEFF, 0xFF01, 
	0xFF04, 0xFF06, 0xFF08, 0xFF0A, 0xFF0B, 0xFF0B, 0xFF0B, 0xFF0A, 0xFF08, 
	0xFF06, 0xFF04, 0xFF01, 0xFEFF, 0xFEFE, 0xFEFC, 0x2577, 0x232E, 0x1FD1, 
	0x1BBA, 0x1748, 0x12D5, 0x0EBF, 0x0B61, 0x0919, 0x0841, 0x0841, 0x0919, 
	0x0B61, 0x0EBF, 0x12D5, 0x1748, 0x1BBA, 0x1FD1, 0x232E, 0x2577, 0x264F, 
	0x25FA, 0x2515, 0x23C4, 0x222A, 0x206C, 0x1EAD, 0x1D14, 0x1BC2, 0x1ADD, 
	0x1A89, 0x1ADD, 0x1BC2, 0x1D14, 0x1EAD, 0x206C, 0x222A, 0x23C4, 0x2515, 
	0x25FA, 0x264F, 0x01BA, 0x01BB, 0x01BB, 0x01BB, 0x01BC, 0x01A1, 0x0161, 
	0x010F, 0x00C1, 0x008B, 0x008B, 0x0088, 0x0080, 0x0073, 0x0064, 0x0053, 
	0x0043, 0x0033, 0x0027, 0x001E, 0x001B, 0x0025, 0x0040, 0x0069, 0x009A, 
	0x00D1, 0x0108, 0x013B, 0x0167, 0x0188, 0x0198, 0x019F, 0x01A3, 0x01A7, 
	0x01AB, 0x01AE, 0x01B1, 0x01B4, 0x01B6, 0x01B7, 0x01B9, 0x0058, 0x0056, 
	0x0055, 0x0055, 0x0055, 0x0061, 0x0080, 0x00AE, 0x00E4, 0x011D, 0x011D, 
	0x0126, 0x013E, 0x0161, 0x018D, 0x01BC, 0x01EB, 0x0216, 0x023A, 0x0252, 
	0x025B, 0x0254, 0x0241, 0x0223, 0x01FE, 0x01D3, 0x01A5, 0x0175, 0x0148, 
	0x011D, 0x00F9, 0x00DA, 0x00C0, 0x00A9, 0x0096, 0x0086, 0x0079, 0x006E, 
	0x0066, 0x0060, 0x005B, 0xF097, 0xF0AC, 0xF0B8, 0xF0BD, 0xF0BE, 0xEB65, 
	0xDEA4, 0xCF6A, 0xC2A9, 0xBD4F, 0xBD4F, 0xBD6C, 0xBDC4, 0xBE5D, 0xBF3B, 
	0xC064, 0xC1DA, 0xC3A4, 0xC5C6, 0xC845, 0xCB24, 0xCE64, 0xD1EC, 0xD59F, 
	0xD95E, 0xDD0D, 0xE08E, 0xE3C3, 0xE68E, 0xE8D2, 0xEA71, 0xEB9F, 0xEC9B, 
	0xED74, 0xEE2E, 0xEECA, 0xEF4C, 0xEFB4, 0xF008, 0xF047, 0xF076, 
    },
    {
	0x0001, 0x0000, 0x0029, 0x0001, 0x0028, 0x002A, 0x0001, 0x0052, 0x0001, 
	0x0053, 0x0001, 0x0054, 0x0001, 0x0055, 0x0001, 0x0056, 0x0029, 0x0057, 
	0x0001, 0x0080, 0x0001, 0x0081, 0x0029, 0x0082, 0x0026, 0x00AB, 0x0001, 
	0x00D1, 0x0029, 0x00D2, 0x0001, 0x00FB, 0x0001, 0x00FC, 0x0001, 0x00FD, 
	0x0029, 0x00FE, 0x0029, 0x0127, 0x0029, 0x0150, 0x0029, 0x0179, 0x0029, 
	0x01A2, 0x0029, 0x01CB, 0x0029, 0x01F4, 0x0029, 0x021D, 0x0029, 0x0246, 
	0x0001, 0x026F, 0x0001, 0x0270, 0x0001, 0x0271, 0x0029, 0x0272, 0x0029, 
	0x029B, 0x0029, 0x02C4, 0x0029, 0x02ED, 0x0029, 0x0316, 0x0029, 0x033F, 
	0x0029, 0x0368, 0x0029, 0x0391, 0x0029, 0x03BA, 0x0024, 0x03E3, 0x0029, 
	0x0407, 0x0001, 0x0430, 0x0001, 0x0431, 0x0021, 0x0432, 0x0029, 0x0453, 
	0x0029, 0x047C, 0x0029, 0x04A5, 0x0029, 0x04CE, 0x0029, 0x04F7, 0x0029, 
	0x0520, 0x0029, 0x0549, 0x0024, 0x0572, 0x0029, 0x0596, 0x0001, 0x05BF, 
	0x0001, 0x05C0, 0x000D, 0x05C1, 0x0029, 0x05CE, 0x0029, 0x05F7, 0x0028, 
	0x0620, 0x0029, 0x0648, 0x0029, 0x0671, 0x0029, 0x069A, 0x0029, 0x06C3, 
})


smlua_anim_util_register_animation("MARIO_ANIM_HANDSTAND_WALK",
    0,
    0,
    0,
    0,
    40,
    {
    0x0000, 0x0000, 0xFFFF, 0xFFFE, 0xFFFD, 0xFFFC, 0xFFFA, 0xFFF9, 0xFFF8, 
	0xFFF7, 0xFFF7, 0xFFF7, 0xFFF7, 0xFFF8, 0xFFF9, 0xFFF9, 0xFFFA, 0xFFFC, 
	0xFFFD, 0xFFFE, 0x0000, 0x0002, 0x0003, 0x0005, 0x0007, 0x0008, 0x000A, 
	0x000B, 0x000C, 0x000C, 0x000D, 0x000C, 0x000B, 0x000A, 0x0008, 0x0006, 
	0x0004, 0x0003, 0x0001, 0x0000, 0x0117, 0x0118, 0x0119, 0x011A, 0x011B, 
	0x011D, 0x011E, 0x0120, 0x0121, 0x0122, 0x0122, 0x0122, 0x0121, 0x0120, 
	0x011E, 0x011D, 0x011B, 0x011A, 0x0119, 0x0118, 0x0117, 0x0118, 0x0119, 
	0x011A, 0x011C, 0x011D, 0x011F, 0x0121, 0x0122, 0x0123, 0x0123, 0x0123, 
	0x0122, 0x0121, 0x011F, 0x011D, 0x011C, 0x011A, 0x0119, 0x0118, 0x0117, 
	0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFD, 0xFFAA, 0xFEC9, 0xFD7D, 0xFBEB, 
	0xFA35, 0xF87E, 0xF6EC, 0xF5A0, 0xF4BF, 0xF46C, 0xF49D, 0xF527, 0xF5FD, 
	0xF712, 0xF85B, 0xF9C9, 0xFB50, 0xFCE4, 0xFE77, 0xFFFD, 0x016C, 0x02BD, 
	0x03EF, 0x0500, 0x05EE, 0x06B6, 0x0755, 0x07CA, 0x0812, 0x082B, 0x07F0, 
	0x0751, 0x0667, 0x054A, 0x0414, 0x02DF, 0x01C2, 0x00D8, 0x0039, 0xFFFD, 
	0xFFFF, 0xFFC7, 0xFF2F, 0xFE4F, 0xFD3F, 0xFC17, 0xFAEF, 0xF9DF, 0xF8FF, 
	0xF867, 0xF82F, 0xF84B, 0xF89B, 0xF91B, 0xF9C4, 0xFA92, 0xFB7F, 0xFC85, 
	0xFDA1, 0xFECB, 0xFFFF, 0x0138, 0x026D, 0x0399, 0x04B4, 0x05B7, 0x069B, 
	0x0758, 0x07E9, 0x0844, 0x0865, 0x0828, 0x0785, 0x0694, 0x0570, 0x0432, 
	0x02F4, 0x01D0, 0x00DF, 0x003C, 0xFFFF, 0xB4A4, 0xB4C6, 0xB522, 0xB5A9, 
	0xB64E, 0xB701, 0xB7B4, 0xB859, 0xB8E0, 0xB93C, 0xB95E, 0xB93C, 0xB8E0, 
	0xB859, 0xB7B4, 0xB701, 0xB64E, 0xB5A9, 0xB522, 0xB4C6, 0xB4A4, 0xB4B0, 
	0xB4CF, 0xB4FC, 0xB534, 0xB570, 0xB5AD, 0xB5E4, 0xB612, 0xB631, 0xB63C, 
	0xB631, 0xB612, 0xB5E4, 0xB5AD, 0xB570, 0xB534, 0xB4FC, 0xB4CF, 0xB4B0, 
	0xB4A4, 0xFFFF, 0xFFE4, 0xFF9C, 0xFF31, 0xFEAF, 0xFE22, 0xFD94, 0xFD12, 
	0xFCA7, 0xFC5F, 0xFC44, 0xFC53, 0xFC7C, 0xFCBD, 0xFD12, 0xFD78, 0xFDEC, 
	0xFE6A, 0xFEEE, 0xFF77, 0xFFFF, 0x0085, 0x0106, 0x017F, 0x01EE, 0x0252, 
	0x02A9, 0x02F0, 0x0325, 0x0346, 0x0352, 0x033A, 0x02FA, 0x029A, 0x0227, 
	0x01A9, 0x012B, 0x00B8, 0x0058, 0x0018, 0xFFFF, 0x0000, 0x004A, 0x0113, 
	0x023B, 0x03A3, 0x052B, 0x06B2, 0x081A, 0x0942, 0x0A0C, 0x0A56, 0x0A2F, 
	0x09C1, 0x0913, 0x082D, 0x0718, 0x05DB, 0x047F, 0x030C, 0x0189, 0x0000, 
	0xFE76, 0xFCF7, 0xFB87, 0xFA30, 0xF8F8, 0xF7E8, 0xF707, 0xF65D, 0xF5F1, 
	0xF5CB, 0xF614, 0xF6DB, 0xF7FF, 0xF962, 0xFAE5, 0xFC68, 0xFDCB, 0xFEEF, 
	0xFFB6, 0x0000, 0xFECD, 0xFEB6, 0xFE77, 0xFE1C, 0xFDAC, 0xFD33, 0xFCB9, 
	0xFC4A, 0xFBEE, 0xFBB0, 0xFB99, 0xFBB0, 0xFBEE, 0xFC4A, 0xFCB9, 0xFD33, 
	0xFDAC, 0xFE1C, 0xFE77, 0xFEB6, 0xFECD, 0xFECA, 0xFEC2, 0xFEB6, 0xFEA7, 
	0xFE97, 0xFE87, 0xFE79, 0xFE6D, 0xFE64, 0xFE61, 0xFE64, 0xFE6D, 0xFE79, 
	0xFE87, 0xFE97, 0xFEA7, 0xFEB6, 0xFEC2, 0xFECA, 0xFECD, 0xFFFE, 0xFFB9, 
	0xFF01, 0xFDF0, 0xFCA6, 0xFB3E, 0xF9D6, 0xF88C, 0xF77B, 0xF6C3, 0xF67F, 
	0xF6A5, 0xF711, 0xF7BB, 0xF898, 0xF9A0, 0xFAC9, 0xFC09, 0xFD59, 0xFEAD, 
	0xFFFE, 0x0143, 0x0275, 0x0393, 0x0497, 0x057E, 0x0644, 0x06E5, 0x075D, 
	0x07A8, 0x07C2, 0x078A, 0x06F3, 0x0614, 0x0506, 0x03E0, 0x02BA, 0x01AC, 
	0x00CD, 0x0036, 0xFFFE, 0x0001, 0x0041, 0x00F0, 0x01F2, 0x032A, 0x047F, 
	0x05D3, 0x070C, 0x080D, 0x08BC, 0x08FC, 0x08D8, 0x0871, 0x07D1, 0x06FF, 
	0x0606, 0x04ED, 0x03BD, 0x0280, 0x013F, 0x0001, 0xFECE, 0xFDAD, 0xFCA0, 
	0xFBAB, 0xFAD1, 0xFA17, 0xF980, 0xF90F, 0xF8C9, 0xF8B1, 0xF8E5, 0xF973, 
	0xFA45, 0xFB43, 0xFC58, 0xFD6D, 0xFE6C, 0xFF3D, 0xFFCC, 0x0001, 0xAB0D, 
	0xAB12, 0xAB20, 0xAB34, 0xAB4D, 0xAB68, 0xAB83, 0xAB9B, 0xABB0, 0xABBD, 
	0xABC2, 0xABBD, 0xABB0, 0xAB9B, 0xAB83, 0xAB68, 0xAB4D, 0xAB34, 0xAB20, 
	0xAB12, 0xAB0D, 0xAB11, 0xAB1B, 0xAB2B, 0xAB3D, 0xAB52, 0xAB66, 0xAB79, 
	0xAB88, 0xAB92, 0xAB96, 0xAB92, 0xAB88, 0xAB79, 0xAB66, 0xAB52, 0xAB3D, 
	0xAB2B, 0xAB1B, 0xAB11, 0xAB0D, 0xFFFE, 0x0001, 0xC170, 0x42EA, 0x4359, 
	0x4486, 0x4641, 0x485C, 0x4AA6, 0x4CF0, 0x4F0A, 0x50C5, 0x51F2, 0x5261, 
	0x5227, 0x5180, 0x5079, 0x4F20, 0x4D7F, 0x4BA4, 0x499B, 0x4770, 0x4531, 
	0x42E9, 0x40A6, 0x3E71, 0x3C56, 0x3A60, 0x3899, 0x370C, 0x35C5, 0x34CE, 
	0x3432, 0x33FB, 0x3466, 0x3589, 0x3735, 0x393D, 0x3B73, 0x3DA9, 0x3FB1, 
	0x415D, 0x427F, 0x42EA, 0xEF7F, 0xEF71, 0xEF4C, 0xEF15, 0xEED2, 0xEE89, 
	0xEE41, 0xEDFE, 0xEDC7, 0xEDA1, 0xED94, 0xEDA1, 0xEDC7, 0xEDFE, 0xEE41, 
	0xEE89, 0xEED2, 0xEF15, 0xEF4C, 0xEF72, 0xEF7F, 0xEF1F, 0xEE1B, 0xEC9B, 
	0xEAC9, 0xE8CE, 0xE6D3, 0xE501, 0xE381, 0xE27D, 0xE21D, 0xE27D, 0xE381, 
	0xE501, 0xE6D3, 0xE8CE, 0xEAC9, 0xEC9B, 0xEE1B, 0xEF1F, 0xEF7F, 0x357D, 
	0x357F, 0x358E, 0x35B7, 0x3606, 0x3689, 0x374C, 0x385C, 0x39C6, 0x3B97, 
	0x3DDB, 0x40BA, 0x442D, 0x4800, 0x4BFD, 0x4FEE, 0x53A0, 0x56DB, 0x596C, 
	0x5B1E, 0x5BBA, 0x5AA9, 0x57C3, 0x537E, 0x4E4E, 0x48A9, 0x4304, 0x3DD3, 
	0x398B, 0x36A2, 0x358D, 0x3589, 0x3585, 0x3582, 0x3580, 0x357F, 0x357E, 
	0x357D, 0xFFFE, 0x0009, 0xF030, 0x028E, 0x033D, 0x0533, 0x084A, 0x0C5E, 
	0x114C, 0x16F0, 0x1D24, 0x23C5, 0x2AAE, 0x31BC, 0x38C9, 0x3FB2, 0xC653, 
	0xCC87, 0xD22A, 0xD718, 0xDB2D, 0xDE44, 0xE039, 0xE0E8, 0xDEFF, 0xD9C2, 
	0xD1EC, 0xC838, 0x3D62, 0x3226, 0x2740, 0x1D6A, 0x1561, 0x0FDF, 0x0C44, 
	0x0960, 0x0720, 0x056F, 0x0438, 0x0369, 0x02EA, 0x02AA, 0x0292, 0x028E, 
	0xCDA8, 0xCDBB, 0xCDF3, 0xCE4B, 0xCEBF, 0xCF4B, 0xCFEB, 0xD09C, 0xD158, 
	0xD21D, 0xD2E6, 0xD3AE, 0xD473, 0xAACF, 0xAA1F, 0xA97E, 0xA8F2, 0xA87E, 
	0xA826, 0xA7EE, 0xA7DB, 0xA843, 0xA95C, 0xAAFB, 0xACF4, 0xD0E6, 0xCEC2, 
	0xCCCA, 0xCB2A, 0xCA11, 0xC9A9, 0xC9C6, 0xCA13, 0xCA86, 0xCB11, 0xCBA8, 
	0xCC40, 0xCCCB, 0xCD3D, 0xCD8B, 0xCDA8, 0xE68A, 0xE5E5, 0xE40E, 0xE126, 
	0xDD50, 0xD8AD, 0xD360, 0xCD8B, 0xC74F, 0xC0CF, 0xBA2E, 0xB38C, 0xAD0C, 
	0x26D1, 0x20FC, 0x1BAF, 0x170C, 0x1336, 0x104E, 0x0E77, 0x0DD2, 0x0F9F, 
	0x148F, 0x1BF2, 0x2516, 0xAF4B, 0xB9DF, 0xC422, 0xCD63, 0xD4F0, 0xDA19, 
	0xDD78, 0xE02B, 0xE245, 0xE3DA, 0xE4FB, 0xE5BE, 0xE634, 0xE670, 0xE686, 
	0xE68A, 0xFFFE, 0x0001, 0xC390, 0xBE12, 0xBE77, 0xBF8A, 0xC11F, 0xC30A, 
	0xC521, 0xC738, 0xC923, 0xCAB8, 0xCBCA, 0xCC2F, 0xCBF7, 0xCB58, 0xCA5F, 
	0xC919, 0xC793, 0xC5DC, 0xC3FF, 0xC20C, 0xC00E, 0xBE13, 0xBC28, 0xBA54, 
	0xB89D, 0xB70B, 0xB5A5, 0xB471, 0xB375, 0xB2B9, 0xB244, 0xB21B, 0xB271, 
	0xB359, 0xB4B1, 0xB651, 0xB817, 0xB9DC, 0xBB7C, 0xBCD4, 0xBDBC, 0xBE12, 
	0x0D00, 0x0D41, 0x0DF2, 0x0EF7, 0x1034, 0x118D, 0x12E5, 0x1422, 0x1527, 
	0x15D8, 0x1619, 0x15D8, 0x1527, 0x1422, 0x12E5, 0x118D, 0x1034, 0x0EF7, 
	0x0DF2, 0x0D41, 0x0D00, 0x0D0B, 0x0D2A, 0x0D57, 0x0D8E, 0x0DCA, 0x0E05, 
	0x0E3C, 0x0E6A, 0x0E88, 0x0E93, 0x0E88, 0x0E6A, 0x0E3C, 0x0E06, 0x0DCA, 
	0x0D8E, 0x0D57, 0x0D2A, 0x0D0C, 0x0D00, 0x603C, 0x5EF3, 0x5B75, 0x5650, 
	0x5011, 0x4945, 0x4278, 0x3C39, 0x3714, 0x3396, 0x324D, 0x325A, 0x327F, 
	0x32B6, 0x32FC, 0x334B, 0x339F, 0x33F2, 0x3441, 0x3487, 0x34BF, 0x34E6, 
	0x3509, 0x3534, 0x3574, 0x35D8, 0x366D, 0x3740, 0x385F, 0x39D8, 0x3BB7, 
	0x3E6E, 0x4230, 0x46AD, 0x4B95, 0x5097, 0x5563, 0x59AA, 0x5D1B, 0x5F67, 
	0x603C, 0x000E, 0x000E, 0x000E, 0x000E, 0x000E, 0x000F, 0x000F, 0x000F, 
	0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000F, 0x000E, 
	0x0007, 0x0007, 0x0007, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005, 0x0004, 
	0x0004, 0x0004, 0x0004, 0x0004, 0x0005, 0x0005, 0x0006, 0x0006, 0x0006, 
	0x0007, 0xF34F, 0xF388, 0xF424, 0xF509, 0xF61F, 0xF74D, 0xF87C, 0xF992, 
	0xFA77, 0xFB12, 0xFB4B, 0xFB12, 0xFA77, 0xF992, 0xF87C, 0xF74D, 0xF61F, 
	0xF509, 0xF424, 0xF388, 0xF34F, 0x1288, 0x136B, 0x15F7, 0x19FB, 0x1F49, 
	0x25B2, 0x2D06, 0x3516, 0xBDB4, 0xC6B0, 0xCFDB, 0xD906, 0xE202, 0xEA9F, 
	0xF2B0, 0xFA04, 0x006E, 0x05BC, 0x09C0, 0x0C4B, 0x0D2F, 0x0D2C, 0x0D13, 
	0x0CD1, 0x0C51, 0x0B7E, 0x0A42, 0x088A, 0x0641, 0x0350, 0xFFA4, 0xF743, 
	0xE836, 0xD56F, 0xC1DE, 0x3075, 0x2385, 0x1ADF, 0x15B2, 0x1330, 0x1288, 
	0x5EA6, 0x5E7C, 0x5E05, 0x5D4D, 0x5C60, 0x5B48, 0x5A12, 0x58C9, 0x2888, 
	0x29D6, 0x2B15, 0x2C3C, 0x2D4D, 0x2E4D, 0x2F3F, 0x3029, 0x310E, 0x31F4, 
	0x32DE, 0x33D0, 0x34D1, 0x35E0, 0x36F9, 0x3812, 0x3922, 0x3A21, 0x3B05, 
	0x3BC5, 0x3C5A, 0x3CBA, 0x3CDC, 0x3B73, 0x37D7, 0x32F3, 0x2DB0, 0x5705, 
	0x5A74, 0x5CAD, 0x5DF1, 0x5E83, 0x5EA6, 0x025C, 0x033B, 0x05B8, 0x09A7, 
	0x0ED8, 0x151E, 0x1C4A, 0x242E, 0xAC9D, 0xB568, 0xBE61, 0xC75A, 0xD025, 
	0xD894, 0xE078, 0xE7A5, 0xEDEA, 0xF31B, 0xF70A, 0xF987, 0xFA66, 0xFA63, 
	0xFA4C, 0xFA0C, 0xF991, 0xF8C5, 0xF795, 0xF5EE, 0xF3BA, 0xF0E5, 0xED5D, 
	0xE57A, 0xD767, 0xC5C7, 0xB33C, 0x226C, 0x1571, 0x0C49, 0x0669, 0x0348, 
	0x025C, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 
	0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
	0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 
	0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 
	0xFFFF, 0x0000, 0xBF5E, 0x0040, 0x003E, 0x0037, 0x002E, 0x0022, 0x0015, 
	0x0009, 0xFFFC, 0xFFF3, 0xFFEC, 0xFFEA, 0xFFEA, 0xFFEA, 0xFFEC, 0xFFEF, 
	0xFFF4, 0xFFFC, 0x0008, 0x0016, 0x0029, 0x0040, 0x008E, 0x0136, 0x0220, 
	0x0336, 0x0460, 0x0588, 0x0696, 0x0774, 0x080A, 0x0841, 0x0807, 0x076C, 
	0x0686, 0x0570, 0x0440, 0x0311, 0x01FB, 0x0115, 0x0079, 0x0040, 0x0056, 
	0xFFBA, 0xFE15, 0xFBA9, 0xF8B9, 0xF586, 0xF253, 0xEF62, 0xECF6, 0xEB52, 
	0xEAB7, 0xEB2E, 0xEC75, 0xEE64, 0xF0D0, 0xF38E, 0xF674, 0xF959, 0xFC11, 
	0xFE73, 0x0056, 0x01C2, 0x02E5, 0x03C9, 0x0473, 0x04ED, 0x053F, 0x0571, 
	0x058B, 0x0594, 0x0595, 0x0570, 0x050A, 0x0473, 0x03BC, 0x02F6, 0x022F, 
	0x0178, 0x00E2, 0x007B, 0x0056, 0xB53E, 0xB521, 0xB4D3, 0xB45F, 0xB3D3, 
	0xB33B, 0xB2A2, 0xB216, 0xB1A2, 0xB154, 0xB137, 0xB138, 0xB140, 0xB153, 
	0xB179, 0xB1B8, 0xB216, 0xB299, 0xB347, 0xB427, 0xB53E, 0xB6D0, 0xB8FE, 
	0xBB98, 0xBE71, 0xC159, 0xC422, 0xC69E, 0xC89E, 0xC9F3, 0xCA6F, 0xC9D7, 
	0xC83B, 0xC5DB, 0xC2F9, 0xBFD6, 0xBCB4, 0xB9D2, 0xB772, 0xB5D6, 0xB53E, 
	0xFFED, 0xFFED, 0xFFEC, 0xFFEC, 0xFFEB, 0xFFE9, 0xFFE8, 0xFFE7, 0xFFE6, 
	0xFFE6, 0xFFE6, 0xFFE6, 0xFFE6, 0xFFE6, 0xFFE7, 0xFFE7, 0xFFE8, 0xFFE9, 
	0xFFEA, 0xFFEC, 0xFFED, 0xFFEF, 0xFFF1, 0xFFF3, 0xFFF5, 0xFFF6, 0xFFF8, 
	0xFFF9, 0xFFFA, 0xFFFB, 0xFFFB, 0xFFFB, 0xFFFA, 0xFFF8, 0xFFF6, 0xFFF4, 
	0xFFF2, 0xFFF0, 0xFFEF, 0xFFEE, 0xFFED, 0x0019, 0x0019, 0x0018, 0x0018, 
	0x0017, 0x0016, 0x0014, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012, 0x0012, 
	0x0013, 0x0014, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 
	0x001B, 0x001C, 0x001D, 0x001D, 0x001E, 0x001E, 0x001E, 0x001F, 0x001F, 
	0x001F, 0x001E, 0x001E, 0x001D, 0x001C, 0x001B, 0x001A, 0x001A, 0x0019, 
	0x126F, 0x120C, 0x10FF, 0x0F72, 0x0D90, 0x0B83, 0x0977, 0x0795, 0x0608, 
	0x04FB, 0x0497, 0x04BF, 0x0536, 0x05F7, 0x06FF, 0x084D, 0x09DD, 0x0BAB, 
	0x0DB5, 0x0FF7, 0x126F, 0x1516, 0x17D8, 0x1A9F, 0x1D51, 0x1FDA, 0x2221, 
	0x240E, 0x258B, 0x2681, 0x26D8, 0x2646, 0x24B9, 0x2270, 0x1FA9, 0x1CA4, 
	0x199E, 0x16D8, 0x148F, 0x1301, 0x126F, 0x0077, 0x007A, 0x0082, 0x008E, 
	0x009D, 0x00AD, 0x00BD, 0x00CC, 0x00D8, 0x00E0, 0x00E3, 0x00E2, 0x00DD, 
	0x00D5, 0x00CB, 0x00BF, 0x00B2, 0x00A4, 0x0095, 0x0086, 0x0077, 0x0069, 
	0x005C, 0x0050, 0x0045, 0x003B, 0x0033, 0x002C, 0x0027, 0x0024, 0x0023, 
	0x0025, 0x002C, 0x0035, 0x0040, 0x004D, 0x0059, 0x0065, 0x006E, 0x0075, 
	0x0077, 0xFEFC, 0xFEFF, 0xFF05, 0xFF0F, 0xFF1B, 0xFF28, 0xFF35, 0xFF40, 
	0xFF4A, 0xFF51, 0xFF53, 0xFF51, 0xFF4C, 0xFF45, 0xFF3B, 0xFF31, 0xFF25, 
	0xFF19, 0xFF0E, 0xFF04, 0xFEFC, 0xFEF6, 0xFEF0, 0xFEEC, 0xFEE9, 0xFEE7, 
	0xFEE6, 0xFEE5, 0xFEE4, 0xFEE4, 0xFEE4, 0xFEE5, 0xFEE7, 0xFEE9, 0xFEED, 
	0xFEF0, 0xFEF4, 0xFEF7, 0xFEFA, 0xFEFB, 0xFEFC, 0xD4B1, 0xD421, 0xD29A, 
	0xD05A, 0xCD9F, 0xCAA6, 0xC7AD, 0xC4F2, 0xC2B2, 0xC12B, 0xC09B, 0xC0F3, 
	0xC1E9, 0xC367, 0xC553, 0xC797, 0xCA19, 0xCCC1, 0xCF78, 0xD225, 0xD4B1, 
	0xD707, 0xD921, 0xDB00, 0xDCA3, 0xDE07, 0xDF2D, 0xE014, 0xE0B9, 0xE11D, 
	0xE13F, 0xE0E5, 0xDFF1, 0xDE89, 0xDCD4, 0xDAF8, 0xD91C, 0xD767, 0xD5FF, 
	0xD50B, 0xD4B1, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 
	0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
	0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 
	0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0xBF5E, 0xFEE8, 0xFE81, 0xFD6A, 0xFBCF, 0xF9DB, 
	0xF7BC, 0xF59C, 0xF3A9, 0xF20D, 0xF0F6, 0xF08F, 0xF0F6, 0xF20D, 0xF3A9, 
	0xF59C, 0xF7BC, 0xF9DB, 0xFBCF, 0xFD6A, 0xFE81, 0xFEE8, 0xFED2, 0xFE97, 
	0xFE3F, 0xFDD4, 0xFD61, 0xFCED, 0xFC82, 0xFC2B, 0xFBEF, 0xFBD9, 0xFBEF, 
	0xFC2B, 0xFC82, 0xFCED, 0xFD61, 0xFDD4, 0xFE3F, 0xFE97, 0xFED2, 0xFEE8, 
	0xFF3E, 0xFF26, 0xFEE6, 0xFE88, 0xFE15, 0xFD98, 0xFD1B, 0xFCA9, 0xFC4A, 
	0xFC0A, 0xFBF3, 0xFBF4, 0xFBF9, 0xFC09, 0xFC29, 0xFC5C, 0xFCA9, 0xFD14, 
	0xFDA2, 0xFE59, 0xFF3E, 0x0091, 0x0273, 0x04BA, 0x073C, 0x09CF, 0x0C48, 
	0x0E7E, 0x1046, 0x1177, 0x11E6, 0x1160, 0x0FF5, 0x0DDE, 0x0B55, 0x0892, 
	0x05D0, 0x0346, 0x012F, 0xFFC4, 0xFF3E, 0xB53F, 0xB5A4, 0xB6B5, 0xB848, 
	0xBA31, 0xBC45, 0xBE5A, 0xC043, 0xC1D6, 0xC2E7, 0xC34C, 0xC30C, 0xC258, 
	0xC144, 0xBFE2, 0xBE44, 0xBC7D, 0xBAA0, 0xB8C0, 0xB6EE, 0xB53F, 0xB3C0, 
	0xB274, 0xB157, 0xB068, 0xAFA4, 0xAF09, 0xAE94, 0xAE43, 0xAE15, 0xAE06, 
	0xAE3A, 0xAEC6, 0xAF95, 0xB091, 0xB1A2, 0xB2B4, 0xB3AF, 0xB47F, 0xB50B, 
	0xB53F, 0x0089, 0x0086, 0x007F, 0x0073, 0x0066, 0x0057, 0x0048, 0x003A, 
	0x002F, 0x0027, 0x0024, 0x0026, 0x002B, 0x0033, 0x003E, 0x004A, 0x0057, 
	0x0064, 0x0071, 0x007E, 0x0089, 0x0093, 0x009A, 0x00A1, 0x00A6, 0x00A9, 
	0x00AC, 0x00AE, 0x00AF, 0x00AF, 0x00AF, 0x00AE, 0x00AB, 0x00A7, 0x00A2, 
	0x009C, 0x0097, 0x0091, 0x008D, 0x008A, 0x0089, 0xFF25, 0xFF24, 0xFF21, 
	0xFF1D, 0xFF18, 0xFF12, 0xFF0D, 0xFF08, 0xFF04, 0xFF01, 0xFF00, 0xFF00, 
	0xFF02, 0xFF04, 0xFF07, 0xFF0B, 0xFF10, 0xFF14, 0xFF1A, 0xFF1F, 0xFF25, 
	0xFF2B, 0xFF30, 0xFF36, 0xFF3B, 0xFF40, 0xFF44, 0xFF48, 0xFF4A, 0xFF4C, 
	0xFF4C, 0xFF4B, 0xFF48, 0xFF44, 0xFF3F, 0xFF39, 0xFF33, 0xFF2D, 0xFF29, 
	0xFF26, 0xFF25, 0x11CF, 0x124A, 0x1397, 0x1582, 0x17D7, 0x1A60, 0x1CEA, 
	0x1F3E, 0x212A, 0x2277, 0x22F2, 0x22A5, 0x21CC, 0x207E, 0x1ED0, 0x1CDA, 
	0x1AB1, 0x186B, 0x1620, 0x13E4, 0x11CF, 0x0FF2, 0x0E50, 0x0CE6, 0x0BB4, 
	0x0AB5, 0x09EA, 0x094F, 0x08E3, 0x08A3, 0x088F, 0x08D1, 0x0985, 0x0A8E, 
	0x0BD0, 0x0D2F, 0x0E8D, 0x0FCF, 0x10D8, 0x118C, 0x11CF, 0x0118, 0x011C, 
	0x0128, 0x0139, 0x014D, 0x0164, 0x017A, 0x018F, 0x01A0, 0x01AB, 0x01B0, 
	0x01AD, 0x01A7, 0x019D, 0x0190, 0x0181, 0x016E, 0x015A, 0x0145, 0x012F, 
	0x0118, 0x0101, 0x00EB, 0x00D5, 0x00C1, 0x00AE, 0x009E, 0x0090, 0x0086, 
	0x0080, 0x007E, 0x0082, 0x008E, 0x009F, 0x00B4, 0x00CB, 0x00E2, 0x00F7, 
	0x0108, 0x0114, 0x0118, 0x0161, 0x015B, 0x014A, 0x0131, 0x0112, 0x00F1, 
	0x00D0, 0x00B1, 0x0098, 0x0087, 0x0081, 0x0085, 0x0091, 0x00A3, 0x00BA, 
	0x00D4, 0x00F1, 0x010F, 0x012D, 0x0148, 0x0161, 0x0176, 0x0186, 0x0194, 
	0x019E, 0x01A5, 0x01AA, 0x01AE, 0x01B0, 0x01B0, 0x01B1, 0x01AE, 0x01A8, 
	0x019F, 0x0195, 0x0189, 0x017D, 0x0172, 0x0169, 0x0163, 0x0161, 0xD3F2, 
	0xD4A4, 0xD687, 0xD950, 0xDCB1, 0xE05F, 0xE40C, 0xE76D, 0xEA36, 0xEC19, 
	0xECCC, 0xEC60, 0xEB30, 0xE959, 0xE6FA, 0xE42F, 0xE115, 0xDDCC, 0xDA6F, 
	0xD71C, 0xD3F2, 0xD108, 0xCE65, 0xCC0C, 0xC9FD, 0xC83A, 0xC6C5, 0xC5A0, 
	0xC4CD, 0xC44D, 0xC422, 0xC493, 0xC5C7, 0xC78C, 0xC9B3, 0xCC0A, 0xCE61, 
	0xD087, 0xD24D, 0xD380, 0xD3F2, 
    },
    {
	0x0028, 0x0000, 0x0029, 0x0028, 0x0001, 0x0051, 0x0001, 0x0052, 0x0001, 
	0x0053, 0x0001, 0x0054, 0x0029, 0x0055, 0x0029, 0x007E, 0x0029, 0x00A7, 
	0x0029, 0x00D0, 0x0029, 0x00F9, 0x0029, 0x0122, 0x0029, 0x014B, 0x0029, 
	0x0174, 0x0029, 0x019D, 0x0001, 0x01C6, 0x0001, 0x01C7, 0x0001, 0x01C8, 
	0x0029, 0x01C9, 0x0029, 0x01F2, 0x0026, 0x021B, 0x0001, 0x0241, 0x0001, 
	0x0242, 0x0001, 0x0243, 0x0029, 0x0244, 0x0029, 0x026D, 0x0029, 0x0296, 
	0x0001, 0x02BF, 0x0001, 0x02C0, 0x0001, 0x02C1, 0x0029, 0x02C2, 0x0029, 
	0x02EB, 0x0029, 0x0314, 0x0011, 0x033D, 0x0013, 0x034E, 0x0015, 0x0361, 
	0x0029, 0x0376, 0x0029, 0x039F, 0x0029, 0x03C8, 0x0029, 0x03F1, 0x0029, 
	0x041A, 0x0001, 0x0443, 0x0029, 0x0444, 0x0029, 0x046D, 0x0029, 0x0496, 
	0x0029, 0x04BF, 0x0028, 0x04E8, 0x0029, 0x0510, 0x0029, 0x0539, 0x0029, 
	0x0562, 0x0029, 0x058B, 0x0029, 0x05B4, 0x0029, 0x05DD, 0x0001, 0x0606, 
	0x0029, 0x0607, 0x0029, 0x0630, 0x0029, 0x0659, 0x0029, 0x0682, 0x0029, 
	0x06AB, 0x0029, 0x06D4, 0x0029, 0x06FD, 0x0029, 0x0726, 0x0029, 0x074F, 
})

smlua_anim_util_register_animation("MARIO_ANIM_HANDSTAND_LAND",
    1,
    0,
    0,
    0,
    10,
    {
    0x0000, 0x00FD, 0x0102, 0x010B, 0x0112, 0x0114, 0x0115, 0x0116, 0x0117, 
	0x0117, 0x0118, 0x001E, 0x001C, 0x0016, 0x000F, 0x000A, 0x0006, 0x0003, 
	0x0001, 0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFD, 0xFFFF, 0xBB46, 0xBAB5, 
	0xB961, 0xB7DE, 0xB6A4, 0xB5C1, 0xB525, 0xB4C4, 0xB490, 0xB47A, 0xB476, 
	0xFFFF, 0x0000, 0xF82B, 0xF8BC, 0xFA10, 0xFB93, 0xFCCC, 0xFDB0, 0xFE4C, 
	0xFEAD, 0xFEE1, 0xFEF7, 0xFEFB, 0xFFFE, 0x0001, 0xAB1F, 0xFFFE, 0x0001, 
	0xC170, 0x1EFE, 0x210D, 0x25D8, 0x2B4C, 0x2FBA, 0x32F0, 0x3522, 0x3681, 
	0x373E, 0x378C, 0x379A, 0xDD93, 0xDF48, 0xE342, 0xE7C9, 0xEB75, 0xEE20, 
	0xEFF2, 0xF115, 0xF1B2, 0xF1F2, 0xF1FF, 0x532E, 0x526A, 0x50A2, 0x4E9A, 
	0x4CF4, 0x4BC2, 0x4AF1, 0x4A6E, 0x4A28, 0x4A0B, 0x4A06, 0xF347, 0xF457, 
	0xF6D1, 0xF9A3, 0xFBED, 0xFD96, 0xFEB8, 0xFF6E, 0xFFD0, 0xFFF7, 0x0000, 
	0x1352, 0x11B4, 0x0DF1, 0x09A9, 0x062F, 0x03A9, 0x01F0, 0x00DD, 0x0048, 
	0x000C, 0x0000, 0xCF38, 0xD200, 0xD87C, 0xDFDE, 0xE5DB, 0xEA35, 0xED2D, 
	0xEF08, 0xF008, 0xF070, 0xF084, 0x4314, 0x40A6, 0x3AFB, 0x3488, 0x2F4C, 
	0x2B80, 0x28E7, 0x2748, 0x2669, 0x260D, 0x25FC, 0xD646, 0xD5FD, 0xD553, 
	0xD491, 0xD3F4, 0xD381, 0xD333, 0xD303, 0xD2E8, 0xD2DE, 0xD2DC, 0xB4C4, 
	0xB6A7, 0xBB0C, 0xC00D, 0xC41D, 0xC70F, 0xC913, 0xCA55, 0xCB02, 0xCB49, 
	0xCB56, 0xFFFE, 0x0001, 0xC390, 0xCB2D, 0xCA16, 0xC78D, 0xC4AA, 0xC252, 
	0xC09E, 0xBF75, 0xBEBB, 0xBE57, 0xBE2E, 0xBE26, 0x236E, 0x2189, 0x1D1D, 
	0x1815, 0x1400, 0x1109, 0x0F03, 0x0DC0, 0x0D11, 0x0CCA, 0x0CBC, 0x42CC, 
	0x427E, 0x41C8, 0x40F8, 0x4050, 0x3FD6, 0x3F83, 0x3F4F, 0x3F33, 0x3F27, 
	0x3F25, 0x0D9C, 0x0C79, 0x09D3, 0x06CE, 0x045B, 0x0294, 0x015D, 0x009B, 
	0x0033, 0x0008, 0x0000, 0xF80A, 0xF8B5, 0xFA41, 0xFC05, 0xFD73, 0xFE7D, 
	0xFF33, 0xFFA4, 0xFFE1, 0xFFFA, 0x0000, 0xCBA3, 0xCEFE, 0xD6CF, 0xDFB5, 
	0xE6ED, 0xEC2B, 0xEFC0, 0xF1FC, 0xF330, 0xF3AE, 0xF3C6, 0x2196, 0x297A, 
	0x3BDC, 0xD0CA, 0xE1C6, 0xEE1B, 0xF687, 0xFBC9, 0xFE9F, 0xFFC7, 0x0000, 
	0x4A76, 0x49D9, 0x486B, 0x3936, 0x3A88, 0x3B7E, 0x3C26, 0x3C8F, 0x3CC7, 
	0x3CDE, 0x3CE3, 0x216A, 0x27C7, 0x369A, 0xC77A, 0xD52C, 0xDF1E, 0xE5E8, 
	0xEA26, 0xEC6F, 0xED5E, 0xED8B, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
	0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
	0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xBF5E, 
	0x0040, 0x0055, 0x0055, 0x0056, 0x9AE5, 0x9E9A, 0xA73B, 0xB10E, 0xB907, 
	0xBED1, 0xC2C6, 0xC53D, 0xC692, 0xC71D, 0xC737, 0x000B, 0x0009, 0x0003, 
	0xFFFB, 0xFFF6, 0xFFF2, 0xFFEF, 0xFFEE, 0xFFED, 0xFFEC, 0x001D, 0x001D, 
	0x001C, 0x001B, 0x001A, 0x0019, 0x3A80, 0x3709, 0x2EF5, 0x25C3, 0x1E4D, 
	0x18E2, 0x152F, 0x12DF, 0x11A1, 0x111F, 0x1106, 0x00EE, 0x00E5, 0x00D1, 
	0x00BB, 0x00A8, 0x009B, 0x0091, 0x008C, 0x0089, 0x0087, 0xFF5E, 0xFF57, 
	0xFF45, 0xFF30, 0xFF1F, 0xFF13, 0xFF0B, 0xFF06, 0xFF03, 0xFF02, 0xBE28, 
	0xBFD0, 0xC3AD, 0xC813, 0xCBA4, 0xCE3C, 0xD001, 0xD11B, 0xD1B4, 0xD1F2, 
	0xD1FE, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 
	0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
	0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0xBF5E, 0xFEE8, 0xFF3D, 0xFF3D, 
	0xFF3E, 0x9EF7, 0xA114, 0xA600, 0xAB9B, 0xB028, 0xB375, 0xB5B7, 0xB71F, 
	0xB7E1, 0xB831, 0xB840, 0xFF2B, 0xFF3E, 0xFF6A, 0xFF9D, 0xFFC6, 0xFFE3, 
	0xFFF8, 0x0005, 0x000C, 0x000F, 0x0010, 0xFEFC, 0x49C6, 0x46CF, 0x3FE7, 
	0x380A, 0x31A9, 0x2D07, 0x29DD, 0x27E4, 0x26D3, 0x2664, 0x264F, 0xFE1E, 
	0xFE48, 0xFEAB, 0xFF1C, 0xFF77, 0xFFBA, 0xFFE7, 0x0004, 0x0014, 0x001A, 
	0x001B, 0x016D, 0x0181, 0x01AF, 0x01E4, 0x020F, 0x022E, 0x0243, 0x0250, 
	0x0258, 0x025A, 0x025B, 0xA3BD, 0xA708, 0xAEB4, 0xB770, 0xBE87, 0xC3AD, 
	0xC731, 0xC962, 0xCA91, 0xCB0D, 0xCB24, 
    },
    {
	0x0001, 0x0000, 0x000A, 0x0001, 0x0009, 0x000B, 0x0001, 0x0014, 0x0001, 
	0x0015, 0x0001, 0x0016, 0x0001, 0x0017, 0x0001, 0x0018, 0x000B, 0x0019, 
	0x0001, 0x0024, 0x0001, 0x0025, 0x000B, 0x0026, 0x0001, 0x0031, 0x0001, 
	0x0032, 0x0001, 0x0033, 0x0001, 0x0034, 0x0001, 0x0035, 0x0001, 0x0036, 
	0x000B, 0x0037, 0x000B, 0x0042, 0x000B, 0x004D, 0x000B, 0x0058, 0x000B, 
	0x0063, 0x000B, 0x006E, 0x000B, 0x0079, 0x000B, 0x0084, 0x000B, 0x008F, 
	0x0001, 0x009A, 0x0001, 0x009B, 0x0001, 0x009C, 0x000B, 0x009D, 0x000B, 
	0x00A8, 0x000B, 0x00B3, 0x000B, 0x00BE, 0x000B, 0x00C9, 0x000B, 0x00D4, 
	0x000B, 0x00DF, 0x000B, 0x00EA, 0x000B, 0x00F5, 0x000B, 0x0100, 0x000B, 
	0x010B, 0x0001, 0x0116, 0x0001, 0x0117, 0x0003, 0x0118, 0x000B, 0x011B, 
	0x000A, 0x0126, 0x0006, 0x0130, 0x000B, 0x0136, 0x000A, 0x0141, 0x000A, 
	0x014B, 0x000B, 0x0155, 0x000B, 0x0160, 0x000B, 0x016B, 0x0001, 0x0176, 
	0x0001, 0x0177, 0x0003, 0x0178, 0x000B, 0x017B, 0x000B, 0x0186, 0x0001, 
	0x0191, 0x000B, 0x0192, 0x000B, 0x019D, 0x000B, 0x01A8, 0x000B, 0x01B3, 
})

smlua_anim_util_register_animation("MARIO_ANIM_HANDSTAND_JUMP_1",
    1,
    0,
    0,
    0,
    10,
    {
    0x0000, 0x004E, 0x009C, 0x00FB, 0x0119, 0x0130, 0x0140, 0x014B, 0x0152, 
	0x0155, 0x0157, 0xFFDD, 0xFFE4, 0xFFEE, 0xFFF4, 0xFFF9, 0xFFFC, 0xFFFE, 
	0xFFFF, 0x0000, 0x0000, 0x3FFF, 0x0000, 0xFDEA, 0xFE56, 0xFEF3, 0xFF4B, 
	0xFF8D, 0xFFBC, 0xFFDC, 0xFFEF, 0xFFF9, 0xFFFD, 0x0708, 0x059A, 0x0384, 
	0x025B, 0x017C, 0x00DC, 0x0070, 0x002F, 0x000E, 0x0002, 0xFFFF, 0x7876, 
	0x855D, 0x9838, 0xA2B4, 0xAA94, 0xB039, 0xB402, 0xB64E, 0xB77B, 0xB7EA, 
	0xB7FA, 0x07C2, 0x062F, 0x03E1, 0x0299, 0x01A3, 0x00F2, 0x007C, 0x0034, 
	0x000F, 0x0002, 0xFFFF, 0xF19B, 0xF487, 0xF8CD, 0xFB2D, 0xFCF6, 0xFE3D, 
	0xFF19, 0xFF9E, 0xFFE2, 0xFFFC, 0x0000, 0xF482, 0xF496, 0xF4C8, 0xF50B, 
	0xF558, 0xF5A9, 0xF5F8, 0xF640, 0xF67B, 0xF6A2, 0xF6B0, 0xF53E, 0xF76D, 
	0xFA9E, 0xFC64, 0xFDB9, 0xFEAE, 0xFF52, 0xFFB5, 0xFFE8, 0xFFFB, 0xFFFE, 
	0x0253, 0x01DA, 0x012A, 0x00C8, 0x007E, 0x0049, 0x0026, 0x0011, 0x0006, 
	0x0002, 0x0001, 0xD9D8, 0xD0DF, 0xC3C2, 0xBC78, 0xB6FD, 0xB310, 0xB06F, 
	0xAED6, 0xAE04, 0xADB7, 0xADAC, 0x0001, 0x0001, 0x0000, 0xFFFF, 0xFFFE, 
	0xFFFE, 0xFFFE, 0xFFFF, 0x0000, 0x0001, 0xC170, 0x08E8, 0x1264, 0x2041, 
	0x27F6, 0x2DC1, 0x31E7, 0x34AF, 0x365F, 0x373D, 0x378F, 0x379A, 0xE05D, 
	0xE3F2, 0xE92E, 0xEC17, 0xEE47, 0xEFD8, 0xF0E4, 0xF188, 0xF1DB, 0xF1FA, 
	0xF1FF, 0x9B4D, 0x8ACA, 0x72A9, 0x653F, 0x5B2B, 0x53F2, 0x4F1A, 0x4C2A, 
	0x4AA8, 0x4A1A, 0x4A06, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 
	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xCD91, 0xD4AB, 
	0xDF0B, 0xE4CF, 0xE925, 0xEC40, 0xEE55, 0xEF98, 0xF03E, 0xF07B, 0xF084, 
	0x18D3, 0x13DB, 0x0C75, 0x082D, 0x04F5, 0x02A7, 0x011B, 0x002B, 0xFFAF, 
	0xFF81, 0xFF7B, 0x0C3D, 0x098A, 0x03E4, 0xFE57, 0xF984, 0xF56B, 0xF20D, 
	0xEF6C, 0xED8A, 0xEC67, 0xEC06, 0xD5BD, 0xDAF2, 0xE2C0, 0xE752, 0xEAC2, 
	0xED38, 0xEEDE, 0xEFDF, 0xF062, 0xF093, 0xF099, 0x0001, 0x0001, 0x0000, 
	0xFFFF, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFF, 0x0000, 0x0001, 0xC170, 0xC1DF, 
	0xC280, 0xC2DA, 0xC31E, 0xC34E, 0xC36E, 0xC382, 0xC38C, 0xC390, 0xECCE, 
	0xE69D, 0xDD91, 0xD889, 0xD4C2, 0xD20C, 0xD03C, 0xCF22, 0xCE91, 0xCE5C, 
	0xCE54, 0x162B, 0x14CD, 0x12CD, 0x11B1, 0x10DB, 0x1042, 0x0FDC, 0x0F9D, 
	0x0F7E, 0x0F72, 0x0F70, 0x8A10, 0x7BF9, 0x6761, 0x5BEF, 0x5354, 0x4D2A, 
	0x4908, 0x4686, 0x453D, 0x44C4, 0x44B2, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xD558, 
	0xDB86, 0xE48F, 0xE995, 0xED5B, 0xF00F, 0xF1DF, 0xF2F9, 0xF389, 0xF3BE, 
	0xF3C6, 0xE7A5, 0xEC97, 0xF3D2, 0xF7D7, 0xFADC, 0xFD06, 0xFE79, 0xFF5B, 
	0xFFCE, 0xFFF9, 0x0000, 0xFD82, 0xFE13, 0xFF80, 0x016C, 0x039E, 0x05EF, 
	0x0833, 0x0A40, 0x0BEB, 0x0D0B, 0x0D74, 0xE285, 0xE4C2, 0xE808, 0xE9DA, 
	0xEB38, 0xEC33, 0xECDB, 0xED41, 0xED75, 0xED88, 0xED8B, 0xFFFF, 0x0000, 
	0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 
	0xFFFF, 0x0000, 0xBF5E, 0xFCEC, 0xFD99, 0xFE96, 0xFF22, 0xFF8C, 0xFFD7, 
	0x000B, 0x002A, 0x0039, 0x003F, 0x0040, 0xE5E4, 0xEB43, 0xF31D, 0xF77A, 
	0xFAC2, 0xFD1B, 0xFEAE, 0xFFA3, 0x0021, 0x0050, 0x0056, 0x8A68, 0x97AB, 
	0xAB0D, 0xB5D4, 0xBDED, 0xC3BB, 0xC79E, 0xC9FA, 0xCB30, 0xCBA3, 0xCBB3, 
	0x0000, 0xFFFB, 0xFFF6, 0xFFF3, 0xFFF0, 0xFFEF, 0xFFED, 0xFFED, 0xFFEC, 
	0xFFFF, 0x0005, 0x000C, 0x0010, 0x0013, 0x0016, 0x0017, 0x0018, 0x0018, 
	0x0019, 0x4FFE, 0x4333, 0x3082, 0x261D, 0x1E4E, 0x18B6, 0x14F5, 0x12AF, 
	0x1184, 0x1116, 0x1106, 0xF768, 0xF942, 0xFBF7, 0xFD78, 0xFE9A, 0xFF69, 
	0xFFF4, 0x004A, 0x0075, 0x0085, 0x0087, 0xF7BA, 0xF935, 0xFB5E, 0xFC91, 
	0xFD79, 0xFE1E, 0xFE8D, 0xFED1, 0xFEF3, 0xFF00, 0xFF02, 0xD552, 0xD4A5, 
	0xD3A8, 0xD31B, 0xD2B2, 0xD266, 0xD233, 0xD214, 0xD205, 0xD1FF, 0xD1FE, 
	0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
	0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xBF5E, 0xFEF6, 0xFEF3, 0xFEEF, 0xFEED, 
	0xFEEB, 0xFEEA, 0xFEE9, 0xFEE8, 0x133A, 0x0F2B, 0x093D, 0x05F1, 0x0376, 
	0x01B0, 0x007F, 0xFFC5, 0xFF66, 0xFF43, 0xFF3E, 0x912F, 0x9C99, 0xAD49, 
	0xB68F, 0xBD88, 0xC286, 0xC5DF, 0xC7E7, 0xC8F2, 0xC954, 0xC962, 0xFFFF, 
	0x0001, 0x0003, 0x0005, 0x0007, 0x0009, 0x000B, 0x000D, 0x000E, 0x000F, 
	0x0010, 0xFFFF, 0xFFCA, 0xFF7D, 0xFF53, 0xFF33, 0xFF1C, 0xFF0C, 0xFF03, 
	0xFEFE, 0xFEFC, 0x4C54, 0x4754, 0x3DE8, 0x361E, 0x3043, 0x2C12, 0x2942, 
	0x278D, 0x26AD, 0x265A, 0x264F, 0xFFAC, 0xFFC2, 0xFFE3, 0xFFF5, 0x0004, 
	0x000E, 0x0014, 0x0018, 0x001A, 0x001B, 0x03BB, 0x0373, 0x030B, 0x02D1, 
	0x02A5, 0x0286, 0x0271, 0x0264, 0x025E, 0x025B, 0xDA83, 0xD764, 0xD2D4, 
	0xD04A, 0xCE62, 0xCD05, 0xCC1A, 0xCB8C, 0xCB43, 0xCB28, 0xCB24,
    },
    {
	0x0001, 0x0000, 0x000A, 0x0001, 0x0009, 0x000B, 0x0001, 0x0014, 0x0001, 
	0x0015, 0x0001, 0x0016, 0x000A, 0x0017, 0x000B, 0x0021, 0x000B, 0x002C, 
	0x000B, 0x0037, 0x000B, 0x0042, 0x000B, 0x004D, 0x000B, 0x0058, 0x000B, 
	0x0063, 0x000B, 0x006E, 0x0005, 0x0079, 0x0005, 0x007E, 0x0001, 0x0083, 
	0x000B, 0x0084, 0x000B, 0x008F, 0x000B, 0x009A, 0x000B, 0x00A5, 0x000B, 
	0x00B0, 0x000B, 0x00BB, 0x000B, 0x00C6, 0x000B, 0x00D1, 0x000B, 0x00DC, 
	0x0005, 0x00E7, 0x0005, 0x00EC, 0x000A, 0x00F1, 0x000B, 0x00FB, 0x000B, 
	0x0106, 0x000B, 0x0111, 0x000B, 0x011C, 0x0001, 0x0127, 0x000B, 0x0128, 
	0x000B, 0x0133, 0x000B, 0x013E, 0x000B, 0x0149, 0x000B, 0x0154, 0x000B, 
	0x015F, 0x0001, 0x016A, 0x000B, 0x016B, 0x000B, 0x0176, 0x000B, 0x0181, 
	0x0009, 0x018C, 0x000A, 0x0195, 0x000B, 0x019F, 0x000B, 0x01AA, 0x000B, 
	0x01B5, 0x000B, 0x01C0, 0x000B, 0x01CB, 0x000B, 0x01D6, 0x0001, 0x01E1, 
	0x0008, 0x01E2, 0x000B, 0x01EA, 0x000B, 0x01F5, 0x000B, 0x0200, 0x000A, 
	0x020B, 0x000B, 0x0215, 0x000A, 0x0220, 0x000A, 0x022A, 0x000B, 0x0234, 
})

smlua_anim_util_register_animation("MARIO_ANIM_HANDSTAND_JUMP_2",
    1,
    0,
    0,
    0,
    20,
    {
	0x0000, 0x00FD, 0x00FB, 0x00F6, 0x00EE, 0x00E6, 0x00DC, 0x00D3, 0x00CB, 
	0x00C4, 0x00BF, 0x00BA, 0x00B6, 0x00B2, 0x00B0, 0x00AE, 0x00AC, 0x00AB, 
	0x00AB, 0x00AA, 0x001E, 0x0029, 0x0044, 0x0066, 0x0089, 0x00A4, 0x00AE, 
	0x00AC, 0x00A5, 0x009A, 0x008C, 0x007B, 0x006A, 0x0057, 0x0045, 0x0033, 
	0x0023, 0x0015, 0x000A, 0x0003, 0x0000, 0x0000, 0x3FFF, 0x0000, 0xFFFD, 
	0xFFFD, 0xFFFD, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFE, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 
	0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 
	0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0xBB46, 0xBF9F, 0xCAF7, 0xDAC1, 
	0xEC73, 0xFD80, 0x0B5C, 0x15FB, 0x1F15, 0x26CA, 0x2D37, 0x327A, 0x36B0, 
	0x39F8, 0x3C6F, 0x3E34, 0x3F63, 0x401B, 0x4079, 0x409C, 0x40A1, 0xFFFF, 
	0x0038, 0x00D0, 0x01AD, 0x02B5, 0x03CE, 0x04DD, 0x05CE, 0x069D, 0x074E, 
	0x07E3, 0x085D, 0x08C1, 0x0910, 0x094C, 0x0978, 0x0997, 0x09AA, 0x09B5, 
	0x09BA, 0x09BB, 0x0000, 0x0004, 0x0010, 0x0021, 0x0035, 0x004B, 0x005F, 
	0x0072, 0x0081, 0x008F, 0x009A, 0x00A4, 0x00AB, 0x00B1, 0x00B6, 0x00B9, 
	0x00BB, 0x00BD, 0x00BE, 0xF82B, 0xF7C4, 0xF6C5, 0xF579, 0xF42D, 0xF32E, 
	0xF2C8, 0xF2F8, 0xF37F, 0xF44F, 0xF559, 0xF68F, 0xF7E1, 0xF942, 0xFAA3, 
	0xFBF6, 0xFD2B, 0xFE35, 0xFF05, 0xFF8D, 0xFFBD, 0xFFFE, 0xFFC3, 0xFF27, 
	0xFE49, 0xFD48, 0xFC43, 0xFB5A, 0xFA98, 0xF9F1, 0xF964, 0xF8EE, 0xF88D, 
	0xF840, 0xF804, 0xF7D7, 0xF7B7, 0xF7A1, 0xF794, 0xF78D, 0xF78A, 0x0001, 
	0xFFAF, 0xFEE6, 0xFDDF, 0xFCD9, 0xFC0F, 0xFBBF, 0xFBDE, 0xFC36, 0xFCBE, 
	0xFD6B, 0xFE34, 0xFF11, 0xFFF6, 0x00DD, 0x01B9, 0x0283, 0x0330, 0x03B7, 
	0x0410, 0x042F, 0xAB1F, 0xADB2, 0xB49E, 0xBEB0, 0xCAB5, 0xD779, 0xE3C9, 
	0xEEAA, 0xF803, 0xFFF0, 0x0691, 0x0C02, 0x1061, 0x13CC, 0x1662, 0x1840, 
	0x1984, 0x1A4C, 0x1AB6, 0x1AE0, 0x1AE7, 0xFFFE, 0x0001, 0xC170, 0x1EFE, 
	0x1F3C, 0x1FE5, 0x20DD, 0x220C, 0x2357, 0x24A3, 0x25DC, 0x26FD, 0x2805, 
	0x28F6, 0x29CF, 0x2A91, 0x2B3B, 0xABCE, 0xAC4A, 0xACAF, 0xACFE, 0xAD36, 
	0xAD57, 0xAD62, 0xDD93, 0xDDF7, 0xDEF1, 0xE036, 0xE17B, 0xE275, 0xE2D9, 
	0xE280, 0xE186, 0xE007, 0xDE1C, 0xDBE1, 0xD971, 0xD6E6, 0xABA4, 0xAE14, 
	0xB04F, 0xB23A, 0xB3B9, 0xB4B3, 0xB50C, 0x532E, 0x5204, 0x4F19, 0x4B4F, 
	0x4784, 0x449A, 0x436F, 0x4465, 0x4715, 0x4B36, 0x507E, 0x56A2, 0x5D5B, 
	0x645C, 0xEB5E, 0xF216, 0xF83B, 0xFD82, 0x01A4, 0x0454, 0x054A, 0xF347, 
	0xF470, 0xF756, 0xFB1A, 0xFEDF, 0x01C5, 0x02EE, 0x02E3, 0x02C4, 0x0295, 
	0x0259, 0x0213, 0x01C7, 0x0177, 0x0127, 0x00DB, 0x0095, 0x0059, 0x002A, 
	0x000B, 0x0000, 0x1352, 0x12F7, 0x1200, 0x1095, 0x0EDE, 0x0D02, 0x0B2A, 
	0x0976, 0x07EC, 0x0689, 0x054E, 0x0438, 0x0345, 0x0275, 0x01C5, 0x0134, 
	0x00C1, 0x006A, 0x002E, 0x000B, 0x0000, 0xCF38, 0xD23C, 0xD9C8, 0xE398, 
	0xED67, 0xF4F3, 0xF7F8, 0xF78D, 0xF663, 0xF499, 0xF24F, 0xEFA5, 0xECBB, 
	0xE9B1, 0xE6A8, 0xE3BE, 0xE114, 0xDECA, 0xDD00, 0xDBD6, 0xDB6B, 0x4314, 
	0x418F, 0x3D79, 0x3785, 0x3069, 0x28D9, 0x218A, 0x1B0F, 0x1579, 0x10B6, 
	0x0CB6, 0x0968, 0x06BA, 0x049D, 0x02FE, 0x01CE, 0x00FA, 0x0073, 0x0028, 
	0x0007, 0x0000, 0xD646, 0xD713, 0xD938, 0xDC57, 0xE013, 0xE40B, 0xE7E1, 
	0xEB47, 0xEE36, 0xF0B6, 0xF2CF, 0xF48B, 0xF5F3, 0xF70F, 0xF7E9, 0xF889, 
	0xF8F8, 0xF93E, 0xF966, 0xF977, 0xF97B, 0xB4C4, 0xB60D, 0xB983, 0xBE8D, 
	0xC491, 0xCAF8, 0xD128, 0xD6A4, 0xDB5E, 0xDF66, 0xE2C9, 0xE595, 0xE7D9, 
	0xE9A4, 0xEB03, 0xEC04, 0xECB7, 0xED29, 0xED69, 0xED85, 0xED8B, 0xFFFE, 
	0x0001, 0xC390, 0xC384, 0xC363, 0xC333, 0xC2F9, 0xC2BC, 0xC280, 0xC24C, 
	0xC21E, 0xC1F8, 0xC1D7, 0xC1BD, 0xC1A7, 0xC196, 0xC189, 0xC17F, 0xC178, 
	0xC174, 0xC172, 0xC170, 0xCB2D, 0xCB41, 0xCB72, 0xCBB1, 0xCBF1, 0xCC22, 
	0xCC35, 0xCBF6, 0xCB46, 0xCA38, 0xC8DE, 0xC74B, 0xC592, 0xC3C7, 0xC1FC, 
	0xC044, 0xBEB1, 0xBD57, 0xBC48, 0x3B99, 0x3B5A, 0x236E, 0x229C, 0x208F, 
	0x1DE4, 0x1B39, 0x192C, 0x185A, 0x18BA, 0x19C7, 0x1B65, 0x1D76, 0x1FDE, 
	0x227F, 0x253E, 0x27FC, 0x2A9E, 0x2D05, 0x2F16, 0x30B4, 0x4E3E, 0x4DDE, 
	0x42CC, 0x41C1, 0x3F27, 0x3BC4, 0x3861, 0x35C7, 0x34BC, 0x350F, 0x35F8, 
	0x375E, 0x3927, 0x3B3C, 0x3D82, 0x3FE1, 0x4240, 0x4486, 0x469B, 0x4864, 
	0x49CA, 0xCAB2, 0xCB05, 0x0D9C, 0x0CE4, 0x0B12, 0x08A5, 0x061F, 0x0400, 
	0x02C8, 0x023A, 0x01C1, 0x0159, 0x0104, 0x00BD, 0x0085, 0x0059, 0x0038, 
	0x0020, 0x0011, 0x0007, 0x0002, 0x0000, 0xF80A, 0xF80B, 0xF810, 0xF81D, 
	0xF837, 0xF861, 0xF8A0, 0xF8FC, 0xF976, 0xFA09, 0xFAAF, 0xFB61, 0xFC19, 
	0xFCD2, 0xFD86, 0xFE2F, 0xFEC6, 0xFF46, 0xFFA9, 0xFFE8, 0x0000, 0xCBA3, 
	0xCF19, 0xD7C1, 0xE301, 0xEE41, 0xF6E8, 0xFA5F, 0xFA3D, 0xF9E0, 0xF950, 
	0xF898, 0xF7C3, 0xF6D9, 0xF5E5, 0xF4F1, 0xF407, 0xF331, 0xF27A, 0xF1EA, 
	0xF18C, 0xF16B, 0x2196, 0x23B9, 0x297A, 0x31DB, 0xBBDC, 0xC680, 0xD0CA, 
	0xD9E9, 0xE1C6, 0xE879, 0xEE1B, 0xF2C2, 0xF687, 0xF981, 0xFBC9, 0xFD75, 
	0xFE9F, 0xFF5C, 0xFFC7, 0xFFF5, 0x0000, 0x4A76, 0x4BAD, 0x4EF0, 0x53B0, 
	0x26A3, 0x209A, 0x1AC5, 0x1599, 0x1123, 0x0D57, 0x0A25, 0x0782, 0x055E, 
	0x03AE, 0x0263, 0x0170, 0x00C8, 0x005C, 0x0020, 0x0006, 0xFFFF, 0x216A, 
	0x2350, 0x286D, 0x2FDE, 0xB8C1, 0xC235, 0xCB59, 0xD373, 0xDA6F, 0xE063, 
	0xE563, 0xE986, 0xECDF, 0xEF84, 0xF18A, 0xF307, 0xF40F, 0xF4B8, 0xF516, 
	0xF53F, 0xF548, 0xFFFF, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 
	0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 
	0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 
	0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xBF5E, 0x0040, 
	0x003F, 0x003C, 0x0037, 0x0031, 0x002B, 0x0026, 0x0021, 0x001D, 0x001A, 
	0x0017, 0x0015, 0x0013, 0x0012, 0x0011, 0x0010, 0x0010, 0x000F, 0x0055, 
	0xFFDA, 0xFE92, 0xFCB5, 0xFA7B, 0xF81C, 0xF5D2, 0xF3CA, 0xF20A, 0xF08C, 
	0xEF4B, 0xEE42, 0xED6B, 0xECC1, 0xEC3F, 0xEBE0, 0xEB9E, 0xEB73, 0xEB5C, 
	0xEB51, 0xEB4F, 0x9AE5, 0x9E39, 0xA689, 0xB157, 0xBC26, 0xC476, 0xC7C9, 
	0xC68C, 0xC315, 0xBDC2, 0xB6F4, 0xAF08, 0xA65E, 0x9D55, 0x944C, 0x8BA2, 
	0x83B7, 0x7CE8, 0x7796, 0x741E, 0x72E2, 0x000B, 0x000A, 0x0006, 0x0001, 
	0xFFFB, 0xFFF7, 0xFFF6, 0xFFF6, 0xFFF6, 0xFFF7, 0xFFF7, 0xFFF8, 0xFFF9, 
	0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFE, 0xFFFF, 0x0000, 0x001D, 
	0x001C, 0x001A, 0x0017, 0x0013, 0x000F, 0x000C, 0x000A, 0x0008, 0x0006, 
	0x0004, 0x0003, 0x0002, 0x0002, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0x3A80, 0x3812, 0x31FE, 0x2A17, 0x2231, 0x1C1D, 0x19AE, 
	0x1A6B, 0x1C7C, 0x1FA9, 0x23B9, 0x2872, 0x2D9D, 0x3301, 0x3865, 0x3D90, 
	0x4249, 0x4659, 0x4985, 0x4B97, 0x4C54, 0x00EE, 0x00DA, 0x00A8, 0x0068, 
	0x0027, 0xFFF5, 0xFFE1, 0xFFE1, 0xFFE3, 0xFFE4, 0xFFE7, 0xFFEA, 0xFFED, 
	0xFFF0, 0xFFF3, 0xFFF6, 0xFFF9, 0xFFFB, 0xFFFD, 0xFFFF, 0x0000, 0xFF5E, 
	0xFF5F, 0xFF60, 0xFF63, 0xFF66, 0xFF6C, 0xFF73, 0xFF7C, 0xFF86, 0xFF92, 
	0xFF9F, 0xFFAC, 0xFFBA, 0xFFC7, 0xFFD4, 0xFFDF, 0xFFEA, 0xFFF3, 0xFFF9, 
	0xFFFD, 0x0000, 0xBE28, 0xC301, 0xCF22, 0xDEE5, 0xEEA9, 0xFAC9, 0xFFA3, 
	0xFF2E, 0xFDE6, 0xFBEE, 0xF96A, 0xF67C, 0xF348, 0xEFF1, 0xEC9A, 0xE967, 
	0xE679, 0xE3F5, 0xE1FD, 0xE0B5, 0xE040, 0xFFFF, 0x0000, 0x0000, 0x0000, 
	0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 
	0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 
	0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 
	0xFFFF, 0xBF5E, 0xFEE8, 0xFF3B, 0x001B, 0x0160, 0x02E5, 0x0481, 0x0610, 
	0x0772, 0x08A3, 0x09A7, 0x0A81, 0x0B36, 0x0BC8, 0x0C3B, 0x0C94, 0x0CD5, 
	0x0D02, 0x0D1E, 0x0D2E, 0x0D35, 0x0D37, 0xFF3D, 0xFF68, 0xFFDA, 0x0082, 
	0x0149, 0x021C, 0x02E9, 0x039E, 0x043A, 0x04BF, 0x052F, 0x058C, 0x05D7, 
	0x0612, 0x063F, 0x0661, 0x0678, 0x0686, 0x068F, 0x0692, 0x0693, 0x9EF7, 
	0x9EFC, 0x9F12, 0x9F47, 0x9FA7, 0xA03D, 0xA117, 0xA23C, 0xA3A2, 0xA53D, 
	0xA6FC, 0xA8D4, 0xAAB5, 0xAC92, 0xAE5C, 0xB007, 0xB183, 0xB2C3, 0xB3B9, 
	0xB457, 0xB48E, 0xFF2B, 0xFF2D, 0xFF34, 0xFF3F, 0xFF4C, 0xFF5B, 0xFF6B, 
	0xFF7B, 0xFF8B, 0xFF9A, 0xFFA9, 0xFFB7, 0xFFC5, 0xFFD1, 0xFFDC, 0xFFE6, 
	0xFFEF, 0xFFF6, 0xFFFB, 0xFFFE, 0x0000, 0xFEFC, 0xFF07, 0xFF23, 0xFF49, 
	0xFF72, 0xFF97, 0xFFB0, 0xFFC0, 0xFFCD, 0xFFD9, 0xFFE2, 0xFFEA, 0xFFF0, 
	0xFFF5, 0xFFF9, 0xFFFB, 0xFFFD, 0xFFFE, 0xFFFF, 0x49C6, 0x497A, 0x489A, 
	0x4730, 0x4543, 0x42DD, 0x4005, 0x3CC7, 0x3936, 0x356B, 0x317C, 0x2D80, 
	0x298E, 0x25BC, 0x2223, 0x1ED8, 0x1BF3, 0x198B, 0x17B6, 0x168C, 0x1624, 
	0xFE1E, 0xFE25, 0xFE39, 0xFE57, 0xFE79, 0xFE9F, 0xFEC4, 0xFEE4, 0xFF01, 
	0xFF1B, 0xFF30, 0xFF43, 0xFF52, 0xFF5F, 0xFF69, 0xFF71, 0xFF77, 0xFF7B, 
	0xFF7E, 0xFF80, 0x016D, 0x015C, 0x0131, 0x00F4, 0x00B0, 0x006D, 0x0036, 
	0x000A, 0xFFE4, 0xFFC4, 0xFFAA, 0xFF94, 0xFF83, 0xFF75, 0xFF6B, 0xFF64, 
	0xFF5F, 0xFF5C, 0xFF5B, 0xFF5A, 0xA3BD, 0xA4E1, 0xA7FB, 0xAC8C, 0xB218, 
	0xB820, 0xBE28, 0xC3C6, 0xC8E8, 0xCD92, 0xD1C5, 0xD585, 0xD8D4, 0xDBB5, 
	0xDE2A, 0xE038, 0xE1DF, 0xE324, 0xE409, 0xE490, 0xE4BC, 
    },
    {
	0x0001, 0x0000, 0x0013, 0x0001, 0x0015, 0x0014, 0x0001, 0x0029, 0x0001, 
	0x002A, 0x0001, 0x002B, 0x0015, 0x002C, 0x0015, 0x0041, 0x0015, 0x0056, 
	0x0015, 0x006B, 0x0013, 0x0080, 0x0015, 0x0093, 0x0014, 0x00A8, 0x0015, 
	0x00BC, 0x0015, 0x00D1, 0x0001, 0x00E6, 0x0001, 0x00E7, 0x0001, 0x00E8, 
	0x0015, 0x00E9, 0x0015, 0x00FE, 0x0015, 0x0113, 0x0015, 0x0128, 0x0015, 
	0x013D, 0x0015, 0x0152, 0x0015, 0x0167, 0x0015, 0x017C, 0x0015, 0x0191, 
	0x0001, 0x01A6, 0x0001, 0x01A7, 0x0014, 0x01A8, 0x0015, 0x01BC, 0x0015, 
	0x01D1, 0x0015, 0x01E6, 0x0014, 0x01FB, 0x0015, 0x020F, 0x0015, 0x0224, 
	0x0015, 0x0239, 0x0015, 0x024E, 0x0015, 0x0263, 0x0014, 0x0278, 0x0015, 
	0x028C, 0x0001, 0x02A1, 0x0012, 0x02A2, 0x0015, 0x02B4, 0x0015, 0x02C9, 
	0x0015, 0x02DE, 0x0015, 0x02F3, 0x0015, 0x0308, 0x0015, 0x031D, 0x0015, 
	0x0332, 0x0015, 0x0347, 0x0014, 0x035C, 0x0015, 0x0370, 0x0001, 0x0385, 
	0x0015, 0x0386, 0x0015, 0x039B, 0x0015, 0x03B0, 0x0015, 0x03C5, 0x0013, 
	0x03DA, 0x0015, 0x03ED, 0x0014, 0x0402, 0x0014, 0x0416, 0x0015, 0x042A, 
})