sm64coopdx/src/pc/lua/smlua_functions_autogen.c

/* THIS FILE IS AUTOGENERATED */
/* SHOULD NOT BE MANUALLY CHANGED */

#include "smlua.h"

#include "src/audio/external.h"
#include "src/engine/surface_collision.h"
#include "src/game/camera.h"
#include "src/game/characters.h"
#include "src/game/mario_step.h"
#include "src/game/mario.h"
#include "src/pc/djui/djui_popup.h"
#include "src/pc/network/network_utils.h"
#include "src/pc/djui/djui_chat_message.h"
#include "src/game/interaction.h"
#include "src/game/level_info.h"
#include "src/game/save_file.h"
#include "src/game/sound_init.h"
#include "src/pc/djui/djui_hud_utils.h"
#include "src/pc/network/network_player.h"
#include "include/behavior_table.h"
#include "src/pc/lua/utils/smlua_obj_utils.h"
#include "src/pc/lua/utils/smlua_misc_utils.h"
#include "src/pc/lua/utils/smlua_collision_utils.h"
#include "src/pc/lua/utils/smlua_model_utils.h"
#include "src/pc/lua/utils/smlua_text_utils.h"
#include "src/pc/lua/utils/smlua_audio_utils.h"
#include "src/engine/surface_load.h"
#include "src/game/object_list_processor.h"
#include "src/game/behavior_actions.h"
#include "src/game/mario_misc.h"


  ////////////////////////
 // behavior_actions.h //
////////////////////////

int smlua_func_arc_to_goal_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* a0 = smlua_get_vec3f_from_buffer();
    a0[0] = smlua_get_number_field(1, "x");
    a0[1] = smlua_get_number_field(1, "y");
    a0[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* a1 = smlua_get_vec3f_from_buffer();
    a1[0] = smlua_get_number_field(2, "x");
    a1[1] = smlua_get_number_field(2, "y");
    a1[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 yVel = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 gravity = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, arc_to_goal_pos(a0, a1, yVel, gravity));

    smlua_push_number_field(1, "x", a0[0]);
    smlua_push_number_field(1, "y", a0[1]);
    smlua_push_number_field(1, "z", a0[2]);

    smlua_push_number_field(2, "x", a1[0]);
    smlua_push_number_field(2, "y", a1[1]);
    smlua_push_number_field(2, "z", a1[2]);

    return 1;
}

int smlua_func_bhv_1up_common_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_common_init();

    return 1;
}

int smlua_func_bhv_1up_hidden_in_pole_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_hidden_in_pole_loop();

    return 1;
}

int smlua_func_bhv_1up_hidden_in_pole_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_hidden_in_pole_spawner_loop();

    return 1;
}

int smlua_func_bhv_1up_hidden_in_pole_trigger_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_hidden_in_pole_trigger_loop();

    return 1;
}

int smlua_func_bhv_1up_hidden_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_hidden_loop();

    return 1;
}

int smlua_func_bhv_1up_hidden_trigger_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_hidden_trigger_loop();

    return 1;
}

int smlua_func_bhv_1up_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_init();

    return 1;
}

int smlua_func_bhv_1up_jump_on_approach_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_jump_on_approach_loop();

    return 1;
}

int smlua_func_bhv_1up_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_loop();

    return 1;
}

int smlua_func_bhv_1up_running_away_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_running_away_loop();

    return 1;
}

int smlua_func_bhv_1up_sliding_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_sliding_loop();

    return 1;
}

int smlua_func_bhv_1up_walking_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_1up_walking_loop();

    return 1;
}

int smlua_func_bhv_act_selector_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_act_selector_init();

    return 1;
}

int smlua_func_bhv_act_selector_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_act_selector_loop();

    return 1;
}

int smlua_func_bhv_act_selector_star_type_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_act_selector_star_type_loop();

    return 1;
}

int smlua_func_bhv_activated_back_and_forth_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_activated_back_and_forth_platform_init();

    return 1;
}

int smlua_func_bhv_activated_back_and_forth_platform_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_activated_back_and_forth_platform_update();

    return 1;
}

int smlua_func_bhv_alpha_boo_key_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_alpha_boo_key_loop();

    return 1;
}

int smlua_func_bhv_ambient_sounds_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ambient_sounds_init();

    return 1;
}

int smlua_func_bhv_animated_texture_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_animated_texture_loop();

    return 1;
}

int smlua_func_bhv_animates_on_floor_switch_press_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_animates_on_floor_switch_press_init();

    return 1;
}

int smlua_func_bhv_animates_on_floor_switch_press_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_animates_on_floor_switch_press_loop();

    return 1;
}

int smlua_func_bhv_arrow_lift_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_arrow_lift_loop();

    return 1;
}

int smlua_func_bhv_bbh_tilting_trap_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bbh_tilting_trap_platform_loop();

    return 1;
}

int smlua_func_bhv_beta_boo_key_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_boo_key_loop();

    return 1;
}

int smlua_func_bhv_beta_bowser_anchor_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_bowser_anchor_loop();

    return 1;
}

int smlua_func_bhv_beta_chest_bottom_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_chest_bottom_init();

    return 1;
}

int smlua_func_bhv_beta_chest_bottom_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_chest_bottom_loop();

    return 1;
}

int smlua_func_bhv_beta_chest_lid_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_chest_lid_loop();

    return 1;
}

int smlua_func_bhv_beta_fish_splash_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_fish_splash_spawner_loop();

    return 1;
}

int smlua_func_bhv_beta_holdable_object_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_holdable_object_init();

    return 1;
}

int smlua_func_bhv_beta_holdable_object_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_holdable_object_loop();

    return 1;
}

int smlua_func_bhv_beta_moving_flames_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_moving_flames_loop();

    return 1;
}

int smlua_func_bhv_beta_moving_flames_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_moving_flames_spawn_loop();

    return 1;
}

int smlua_func_bhv_beta_trampoline_spring_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_trampoline_spring_loop();

    return 1;
}

int smlua_func_bhv_beta_trampoline_top_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_beta_trampoline_top_loop();

    return 1;
}

int smlua_func_bhv_big_boo_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_boo_loop();

    return 1;
}

int smlua_func_bhv_big_boulder_generator_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_boulder_generator_loop();

    return 1;
}

int smlua_func_bhv_big_boulder_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_boulder_init();

    return 1;
}

int smlua_func_bhv_big_boulder_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_boulder_loop();

    return 1;
}

int smlua_func_bhv_big_bully_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_bully_init();

    return 1;
}

int smlua_func_bhv_big_bully_with_minions_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_bully_with_minions_init();

    return 1;
}

int smlua_func_bhv_big_bully_with_minions_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_big_bully_with_minions_loop();

    return 1;
}

int smlua_func_bhv_bird_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bird_update();

    return 1;
}

int smlua_func_bhv_birds_sound_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_birds_sound_loop();

    return 1;
}

int smlua_func_bhv_bitfs_sinking_cage_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bitfs_sinking_cage_platform_loop();

    return 1;
}

int smlua_func_bhv_bitfs_sinking_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bitfs_sinking_platform_loop();

    return 1;
}

int smlua_func_bhv_black_smoke_bowser_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_black_smoke_bowser_loop();

    return 1;
}

int smlua_func_bhv_black_smoke_mario_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_black_smoke_mario_loop();

    return 1;
}

int smlua_func_bhv_black_smoke_upward_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_black_smoke_upward_loop();

    return 1;
}

int smlua_func_bhv_blue_bowser_flame_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_bowser_flame_init();

    return 1;
}

int smlua_func_bhv_blue_bowser_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_bowser_flame_loop();

    return 1;
}

int smlua_func_bhv_blue_coin_jumping_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_coin_jumping_loop();

    return 1;
}

int smlua_func_bhv_blue_coin_sliding_jumping_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_coin_sliding_jumping_init();

    return 1;
}

int smlua_func_bhv_blue_coin_sliding_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_coin_sliding_loop();

    return 1;
}

int smlua_func_bhv_blue_coin_switch_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_coin_switch_loop();

    return 1;
}

int smlua_func_bhv_blue_fish_movement_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_fish_movement_loop();

    return 1;
}

int smlua_func_bhv_blue_flames_group_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_blue_flames_group_loop();

    return 1;
}

int smlua_func_bhv_bob_pit_bowling_ball_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bob_pit_bowling_ball_init();

    return 1;
}

int smlua_func_bhv_bob_pit_bowling_ball_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bob_pit_bowling_ball_loop();

    return 1;
}

int smlua_func_bhv_bobomb_anchor_mario_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_anchor_mario_loop();

    return 1;
}

int smlua_func_bhv_bobomb_buddy_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_buddy_init();

    return 1;
}

int smlua_func_bhv_bobomb_buddy_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_buddy_loop();

    return 1;
}

int smlua_func_bhv_bobomb_bully_death_smoke_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_bully_death_smoke_init();

    return 1;
}

int smlua_func_bhv_bobomb_explosion_bubble_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_explosion_bubble_init();

    return 1;
}

int smlua_func_bhv_bobomb_explosion_bubble_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_explosion_bubble_loop();

    return 1;
}

int smlua_func_bhv_bobomb_fuse_smoke_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_fuse_smoke_init();

    return 1;
}

int smlua_func_bhv_bobomb_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_init();

    return 1;
}

int smlua_func_bhv_bobomb_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bobomb_loop();

    return 1;
}

int smlua_func_bhv_boo_boss_spawned_bridge_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_boss_spawned_bridge_loop();

    return 1;
}

int smlua_func_bhv_boo_cage_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_cage_init();

    return 1;
}

int smlua_func_bhv_boo_cage_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_cage_loop();

    return 1;
}

int smlua_func_bhv_boo_in_castle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_in_castle_loop();

    return 1;
}

int smlua_func_bhv_boo_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_init();

    return 1;
}

int smlua_func_bhv_boo_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_loop();

    return 1;
}

int smlua_func_bhv_boo_with_cage_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_with_cage_init();

    return 1;
}

int smlua_func_bhv_boo_with_cage_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_boo_with_cage_loop();

    return 1;
}

int smlua_func_bhv_book_switch_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_book_switch_loop();

    return 1;
}

int smlua_func_bhv_bookend_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bookend_spawn_loop();

    return 1;
}

int smlua_func_bhv_bouncing_fireball_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bouncing_fireball_flame_loop();

    return 1;
}

int smlua_func_bhv_bouncing_fireball_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bouncing_fireball_loop();

    return 1;
}

int smlua_func_bhv_bowling_ball_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowling_ball_init();

    return 1;
}

int smlua_func_bhv_bowling_ball_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowling_ball_loop();

    return 1;
}

int smlua_func_bhv_bowser_body_anchor_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_body_anchor_init();

    return 1;
}

int smlua_func_bhv_bowser_body_anchor_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_body_anchor_loop();

    return 1;
}

int smlua_func_bhv_bowser_bomb_explosion_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_bomb_explosion_loop();

    return 1;
}

int smlua_func_bhv_bowser_bomb_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_bomb_loop();

    return 1;
}

int smlua_func_bhv_bowser_bomb_smoke_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_bomb_smoke_loop();

    return 1;
}

int smlua_func_bhv_bowser_course_red_coin_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_course_red_coin_star_loop();

    return 1;
}

int smlua_func_bhv_bowser_flame_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_flame_spawn_loop();

    return 1;
}

int smlua_func_bhv_bowser_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_init();

    return 1;
}

int smlua_func_bhv_bowser_key_course_exit_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_key_course_exit_loop();

    return 1;
}

int smlua_func_bhv_bowser_key_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_key_init();

    return 1;
}

int smlua_func_bhv_bowser_key_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_key_loop();

    return 1;
}

int smlua_func_bhv_bowser_key_unlock_door_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_key_unlock_door_loop();

    return 1;
}

int smlua_func_bhv_bowser_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_loop();

    return 1;
}

int smlua_func_bhv_bowser_shock_wave_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_shock_wave_loop();

    return 1;
}

int smlua_func_bhv_bowser_tail_anchor_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_tail_anchor_init();

    return 1;
}

int smlua_func_bhv_bowser_tail_anchor_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowser_tail_anchor_loop();

    return 1;
}

int smlua_func_bhv_bowsers_sub_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bowsers_sub_loop();

    return 1;
}

int smlua_func_bhv_breakable_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_breakable_box_loop();

    return 1;
}

int smlua_func_bhv_breakable_box_small_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_breakable_box_small_init();

    return 1;
}

int smlua_func_bhv_breakable_box_small_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_breakable_box_small_loop();

    return 1;
}

int smlua_func_bhv_bub_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bub_loop();

    return 1;
}

int smlua_func_bhv_bub_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bub_spawner_loop();

    return 1;
}

int smlua_func_bhv_bubba_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubba_loop();

    return 1;
}

int smlua_func_bhv_bubble_cannon_barrel_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubble_cannon_barrel_loop();

    return 1;
}

int smlua_func_bhv_bubble_maybe_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubble_maybe_loop();

    return 1;
}

int smlua_func_bhv_bubble_player_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubble_player_loop();

    return 1;
}

int smlua_func_bhv_bubble_splash_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubble_splash_init();

    return 1;
}

int smlua_func_bhv_bubble_wave_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bubble_wave_init();

    return 1;
}

int smlua_func_bhv_bullet_bill_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bullet_bill_init();

    return 1;
}

int smlua_func_bhv_bullet_bill_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bullet_bill_loop();

    return 1;
}

int smlua_func_bhv_bully_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_bully_loop();

    return 1;
}

int smlua_func_bhv_butterfly_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_butterfly_init();

    return 1;
}

int smlua_func_bhv_butterfly_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_butterfly_loop();

    return 1;
}

int smlua_func_bhv_camera_lakitu_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_camera_lakitu_init();

    return 1;
}

int smlua_func_bhv_camera_lakitu_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_camera_lakitu_update();

    return 1;
}

int smlua_func_bhv_cannon_barrel_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cannon_barrel_loop();

    return 1;
}

int smlua_func_bhv_cannon_base_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cannon_base_loop();

    return 1;
}

int smlua_func_bhv_cannon_base_unused_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cannon_base_unused_loop();

    return 1;
}

int smlua_func_bhv_cannon_closed_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cannon_closed_init();

    return 1;
}

int smlua_func_bhv_cannon_closed_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cannon_closed_loop();

    return 1;
}

int smlua_func_bhv_cap_switch_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cap_switch_loop();

    return 1;
}

int smlua_func_bhv_castle_cannon_grate_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_castle_cannon_grate_init();

    return 1;
}

int smlua_func_bhv_castle_flag_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_castle_flag_init();

    return 1;
}

int smlua_func_bhv_castle_floor_trap_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_castle_floor_trap_init();

    return 1;
}

int smlua_func_bhv_castle_floor_trap_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_castle_floor_trap_loop();

    return 1;
}

int smlua_func_bhv_ccm_touched_star_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ccm_touched_star_spawn_loop();

    return 1;
}

int smlua_func_bhv_celebration_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_celebration_star_init();

    return 1;
}

int smlua_func_bhv_celebration_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_celebration_star_loop();

    return 1;
}

int smlua_func_bhv_celebration_star_sparkle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_celebration_star_sparkle_loop();

    return 1;
}

int smlua_func_bhv_chain_chomp_chain_part_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chain_chomp_chain_part_update();

    return 1;
}

int smlua_func_bhv_chain_chomp_gate_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chain_chomp_gate_init();

    return 1;
}

int smlua_func_bhv_chain_chomp_gate_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chain_chomp_gate_update();

    return 1;
}

int smlua_func_bhv_chain_chomp_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chain_chomp_update();

    return 1;
}

int smlua_func_bhv_checkerboard_elevator_group_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_checkerboard_elevator_group_init();

    return 1;
}

int smlua_func_bhv_checkerboard_elevator_group_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_checkerboard_elevator_group_loop();

    return 1;
}

int smlua_func_bhv_checkerboard_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_checkerboard_platform_init();

    return 1;
}

int smlua_func_bhv_checkerboard_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_checkerboard_platform_loop();

    return 1;
}

int smlua_func_bhv_chuckya_anchor_mario_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chuckya_anchor_mario_loop();

    return 1;
}

int smlua_func_bhv_chuckya_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_chuckya_loop();

    return 1;
}

int smlua_func_bhv_circling_amp_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_circling_amp_init();

    return 1;
}

int smlua_func_bhv_circling_amp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_circling_amp_loop();

    return 1;
}

int smlua_func_bhv_clam_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_clam_loop();

    return 1;
}

int smlua_func_bhv_cloud_part_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cloud_part_update();

    return 1;
}

int smlua_func_bhv_cloud_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_cloud_update();

    return 1;
}

int smlua_func_bhv_coffin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coffin_loop();

    return 1;
}

int smlua_func_bhv_coffin_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coffin_spawner_loop();

    return 1;
}

int smlua_func_bhv_coin_formation_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_formation_init();

    return 1;
}

int smlua_func_bhv_coin_formation_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_formation_loop();

    return 1;
}

int smlua_func_bhv_coin_formation_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_formation_spawn_loop();

    return 1;
}

int smlua_func_bhv_coin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_init();

    return 1;
}

int smlua_func_bhv_coin_inside_boo_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_inside_boo_loop();

    return 1;
}

int smlua_func_bhv_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_loop();

    return 1;
}

int smlua_func_bhv_coin_sparkles_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_coin_sparkles_loop();

    return 1;
}

int smlua_func_bhv_collect_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_collect_star_init();

    return 1;
}

int smlua_func_bhv_collect_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_collect_star_loop();

    return 1;
}

int smlua_func_bhv_controllable_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_controllable_platform_init();

    return 1;
}

int smlua_func_bhv_controllable_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_controllable_platform_loop();

    return 1;
}

int smlua_func_bhv_controllable_platform_sub_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_controllable_platform_sub_loop();

    return 1;
}

int smlua_func_bhv_courtyard_boo_triplet_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_courtyard_boo_triplet_init();

    return 1;
}

int smlua_func_bhv_ddd_moving_pole_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ddd_moving_pole_loop();

    return 1;
}

int smlua_func_bhv_ddd_pole_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ddd_pole_init();

    return 1;
}

int smlua_func_bhv_ddd_pole_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ddd_pole_update();

    return 1;
}

int smlua_func_bhv_ddd_warp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ddd_warp_loop();

    return 1;
}

int smlua_func_bhv_decorative_pendulum_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_decorative_pendulum_init();

    return 1;
}

int smlua_func_bhv_decorative_pendulum_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_decorative_pendulum_loop();

    return 1;
}

int smlua_func_bhv_donut_platform_spawner_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_donut_platform_spawner_update();

    return 1;
}

int smlua_func_bhv_donut_platform_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_donut_platform_update();

    return 1;
}

int smlua_func_bhv_door_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_door_init();

    return 1;
}

int smlua_func_bhv_door_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_door_loop();

    return 1;
}

int smlua_func_bhv_dorrie_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_dorrie_update();

    return 1;
}

int smlua_func_bhv_elevator_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_elevator_init();

    return 1;
}

int smlua_func_bhv_elevator_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_elevator_loop();

    return 1;
}

int smlua_func_bhv_end_birds_1_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_end_birds_1_loop();

    return 1;
}

int smlua_func_bhv_end_birds_2_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_end_birds_2_loop();

    return 1;
}

int smlua_func_bhv_enemy_lakitu_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_enemy_lakitu_update();

    return 1;
}

int smlua_func_bhv_exclamation_box_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_exclamation_box_init();

    return 1;
}

int smlua_func_bhv_exclamation_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_exclamation_box_loop();

    return 1;
}

int smlua_func_bhv_explosion_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_explosion_init();

    return 1;
}

int smlua_func_bhv_explosion_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_explosion_loop();

    return 1;
}

int smlua_func_bhv_eyerok_boss_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_eyerok_boss_init();

    return 1;
}

int smlua_func_bhv_eyerok_boss_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_eyerok_boss_loop();

    return 1;
}

int smlua_func_bhv_eyerok_hand_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_eyerok_hand_loop();

    return 1;
}

int smlua_func_bhv_fading_warp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fading_warp_loop();

    return 1;
}

int smlua_func_bhv_falling_bowser_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_falling_bowser_platform_loop();

    return 1;
}

int smlua_func_bhv_falling_pillar_hitbox_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_falling_pillar_hitbox_loop();

    return 1;
}

int smlua_func_bhv_falling_pillar_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_falling_pillar_init();

    return 1;
}

int smlua_func_bhv_falling_pillar_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_falling_pillar_loop();

    return 1;
}

int smlua_func_bhv_ferris_wheel_axle_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ferris_wheel_axle_init();

    return 1;
}

int smlua_func_bhv_ferris_wheel_platform_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ferris_wheel_platform_update();

    return 1;
}

int smlua_func_bhv_fire_piranha_plant_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fire_piranha_plant_init();

    return 1;
}

int smlua_func_bhv_fire_piranha_plant_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fire_piranha_plant_update();

    return 1;
}

int smlua_func_bhv_fire_spitter_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fire_spitter_update();

    return 1;
}

int smlua_func_bhv_fish_group_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fish_group_loop();

    return 1;
}

int smlua_func_bhv_fish_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fish_loop();

    return 1;
}

int smlua_func_bhv_fish_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fish_spawner_loop();

    return 1;
}

int smlua_func_bhv_flame_bouncing_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_bouncing_init();

    return 1;
}

int smlua_func_bhv_flame_bouncing_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_bouncing_loop();

    return 1;
}

int smlua_func_bhv_flame_bowser_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_bowser_init();

    return 1;
}

int smlua_func_bhv_flame_bowser_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_bowser_loop();

    return 1;
}

int smlua_func_bhv_flame_floating_landing_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_floating_landing_init();

    return 1;
}

int smlua_func_bhv_flame_floating_landing_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_floating_landing_loop();

    return 1;
}

int smlua_func_bhv_flame_large_burning_out_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_large_burning_out_init();

    return 1;
}

int smlua_func_bhv_flame_mario_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_mario_loop();

    return 1;
}

int smlua_func_bhv_flame_moving_forward_growing_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_moving_forward_growing_init();

    return 1;
}

int smlua_func_bhv_flame_moving_forward_growing_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flame_moving_forward_growing_loop();

    return 1;
}

int smlua_func_bhv_flamethrower_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flamethrower_flame_loop();

    return 1;
}

int smlua_func_bhv_flamethrower_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flamethrower_loop();

    return 1;
}

int smlua_func_bhv_floating_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_floating_platform_loop();

    return 1;
}

int smlua_func_bhv_floor_trap_in_castle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_floor_trap_in_castle_loop();

    return 1;
}

int smlua_func_bhv_fly_guy_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fly_guy_flame_loop();

    return 1;
}

int smlua_func_bhv_fly_guy_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_fly_guy_update();

    return 1;
}

int smlua_func_bhv_flying_bookend_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_flying_bookend_loop();

    return 1;
}

int smlua_func_bhv_free_bowling_ball_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_free_bowling_ball_init();

    return 1;
}

int smlua_func_bhv_free_bowling_ball_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_free_bowling_ball_loop();

    return 1;
}

int smlua_func_bhv_generic_bowling_ball_spawner_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_generic_bowling_ball_spawner_init();

    return 1;
}

int smlua_func_bhv_generic_bowling_ball_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_generic_bowling_ball_spawner_loop();

    return 1;
}

int smlua_func_bhv_giant_pole_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_giant_pole_loop();

    return 1;
}

int smlua_func_bhv_golden_coin_sparkles_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_golden_coin_sparkles_loop();

    return 1;
}

int smlua_func_bhv_goomba_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_goomba_init();

    return 1;
}

int smlua_func_bhv_goomba_triplet_spawner_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_goomba_triplet_spawner_update();

    return 1;
}

int smlua_func_bhv_goomba_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_goomba_update();

    return 1;
}

int smlua_func_bhv_grand_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_grand_star_init();

    return 1;
}

int smlua_func_bhv_grand_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_grand_star_loop();

    return 1;
}

int smlua_func_bhv_grindel_thwomp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_grindel_thwomp_loop();

    return 1;
}

int smlua_func_bhv_ground_sand_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ground_sand_init();

    return 1;
}

int smlua_func_bhv_ground_snow_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ground_snow_init();

    return 1;
}

int smlua_func_bhv_haunted_bookshelf_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_haunted_bookshelf_loop();

    return 1;
}

int smlua_func_bhv_haunted_bookshelf_manager_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_haunted_bookshelf_manager_loop();

    return 1;
}

int smlua_func_bhv_haunted_chair_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_haunted_chair_init();

    return 1;
}

int smlua_func_bhv_haunted_chair_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_haunted_chair_loop();

    return 1;
}

int smlua_func_bhv_heave_ho_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_heave_ho_loop();

    return 1;
}

int smlua_func_bhv_heave_ho_throw_mario_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_heave_ho_throw_mario_loop();

    return 1;
}

int smlua_func_bhv_hidden_blue_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_blue_coin_loop();

    return 1;
}

int smlua_func_bhv_hidden_object_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_object_loop();

    return 1;
}

int smlua_func_bhv_hidden_red_coin_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_red_coin_star_init();

    return 1;
}

int smlua_func_bhv_hidden_red_coin_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_red_coin_star_loop();

    return 1;
}

int smlua_func_bhv_hidden_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_star_init();

    return 1;
}

int smlua_func_bhv_hidden_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_star_loop();

    return 1;
}

int smlua_func_bhv_hidden_star_trigger_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hidden_star_trigger_loop();

    return 1;
}

int smlua_func_bhv_homing_amp_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_homing_amp_init();

    return 1;
}

int smlua_func_bhv_homing_amp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_homing_amp_loop();

    return 1;
}

int smlua_func_bhv_hoot_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hoot_init();

    return 1;
}

int smlua_func_bhv_hoot_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_hoot_loop();

    return 1;
}

int smlua_func_bhv_horizontal_grindel_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_horizontal_grindel_init();

    return 1;
}

int smlua_func_bhv_horizontal_grindel_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_horizontal_grindel_update();

    return 1;
}

int smlua_func_bhv_idle_water_wave_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_idle_water_wave_loop();

    return 1;
}

int smlua_func_bhv_init_changing_water_level_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_init_changing_water_level_loop();

    return 1;
}

int smlua_func_bhv_intro_lakitu_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_intro_lakitu_loop();

    return 1;
}

int smlua_func_bhv_intro_peach_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_intro_peach_loop();

    return 1;
}

int smlua_func_bhv_intro_scene_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_intro_scene_loop();

    return 1;
}

int smlua_func_bhv_invisible_objects_under_bridge_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_invisible_objects_under_bridge_init();

    return 1;
}

int smlua_func_bhv_invisible_objects_under_bridge_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_invisible_objects_under_bridge_loop();

    return 1;
}

int smlua_func_bhv_jet_stream_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jet_stream_loop();

    return 1;
}

int smlua_func_bhv_jet_stream_ring_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jet_stream_ring_spawner_loop();

    return 1;
}

int smlua_func_bhv_jet_stream_water_ring_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jet_stream_water_ring_init();

    return 1;
}

int smlua_func_bhv_jet_stream_water_ring_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jet_stream_water_ring_loop();

    return 1;
}

int smlua_func_bhv_jrb_floating_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jrb_floating_box_loop();

    return 1;
}

int smlua_func_bhv_jrb_sliding_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jrb_sliding_box_loop();

    return 1;
}

int smlua_func_bhv_jumping_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_jumping_box_loop();

    return 1;
}

int smlua_func_bhv_kickable_board_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_kickable_board_loop();

    return 1;
}

int smlua_func_bhv_king_bobomb_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_king_bobomb_loop();

    return 1;
}

int smlua_func_bhv_klepto_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_klepto_init();

    return 1;
}

int smlua_func_bhv_klepto_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_klepto_update();

    return 1;
}

int smlua_func_bhv_koopa_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_init();

    return 1;
}

int smlua_func_bhv_koopa_race_endpoint_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_race_endpoint_update();

    return 1;
}

int smlua_func_bhv_koopa_shell_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_shell_flame_loop();

    return 1;
}

int smlua_func_bhv_koopa_shell_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_shell_loop();

    return 1;
}

int smlua_func_bhv_koopa_shell_underwater_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_shell_underwater_loop();

    return 1;
}

int smlua_func_bhv_koopa_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_koopa_update();

    return 1;
}

int smlua_func_bhv_large_bomp_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_large_bomp_init();

    return 1;
}

int smlua_func_bhv_large_bomp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_large_bomp_loop();

    return 1;
}

int smlua_func_bhv_lll_bowser_puzzle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_bowser_puzzle_loop();

    return 1;
}

int smlua_func_bhv_lll_bowser_puzzle_piece_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_bowser_puzzle_piece_loop();

    return 1;
}

int smlua_func_bhv_lll_drawbridge_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_drawbridge_loop();

    return 1;
}

int smlua_func_bhv_lll_drawbridge_spawner_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_drawbridge_spawner_init();

    return 1;
}

int smlua_func_bhv_lll_drawbridge_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_drawbridge_spawner_loop();

    return 1;
}

int smlua_func_bhv_lll_floating_wood_bridge_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_floating_wood_bridge_loop();

    return 1;
}

int smlua_func_bhv_lll_moving_octagonal_mesh_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_moving_octagonal_mesh_platform_loop();

    return 1;
}

int smlua_func_bhv_lll_rolling_log_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_rolling_log_init();

    return 1;
}

int smlua_func_bhv_lll_rotating_block_fire_bars_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_rotating_block_fire_bars_loop();

    return 1;
}

int smlua_func_bhv_lll_rotating_hex_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_rotating_hex_flame_loop();

    return 1;
}

int smlua_func_bhv_lll_rotating_hexagonal_ring_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_rotating_hexagonal_ring_loop();

    return 1;
}

int smlua_func_bhv_lll_sinking_rectangular_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_sinking_rectangular_platform_loop();

    return 1;
}

int smlua_func_bhv_lll_sinking_rock_block_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_sinking_rock_block_loop();

    return 1;
}

int smlua_func_bhv_lll_sinking_square_platforms_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_sinking_square_platforms_loop();

    return 1;
}

int smlua_func_bhv_lll_wood_piece_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_lll_wood_piece_loop();

    return 1;
}

int smlua_func_bhv_mad_piano_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mad_piano_update();

    return 1;
}

int smlua_func_bhv_manta_ray_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_manta_ray_init();

    return 1;
}

int smlua_func_bhv_manta_ray_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_manta_ray_loop();

    return 1;
}

int smlua_func_bhv_manta_ray_water_ring_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_manta_ray_water_ring_init();

    return 1;
}

int smlua_func_bhv_manta_ray_water_ring_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_manta_ray_water_ring_loop();

    return 1;
}

int smlua_func_bhv_menu_button_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_menu_button_init();

    return 1;
}

int smlua_func_bhv_menu_button_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_menu_button_loop();

    return 1;
}

int smlua_func_bhv_menu_button_manager_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_menu_button_manager_init();

    return 1;
}

int smlua_func_bhv_menu_button_manager_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_menu_button_manager_loop();

    return 1;
}

int smlua_func_bhv_merry_go_round_boo_manager_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_merry_go_round_boo_manager_loop();

    return 1;
}

int smlua_func_bhv_merry_go_round_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_merry_go_round_loop();

    return 1;
}

int smlua_func_bhv_metal_cap_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_metal_cap_init();

    return 1;
}

int smlua_func_bhv_metal_cap_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_metal_cap_loop();

    return 1;
}

int smlua_func_bhv_mips_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mips_init();

    return 1;
}

int smlua_func_bhv_mips_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mips_loop();

    return 1;
}

int smlua_func_bhv_moat_grills_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moat_grills_loop();

    return 1;
}

int smlua_func_bhv_moneybag_hidden_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moneybag_hidden_loop();

    return 1;
}

int smlua_func_bhv_moneybag_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moneybag_init();

    return 1;
}

int smlua_func_bhv_moneybag_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moneybag_loop();

    return 1;
}

int smlua_func_bhv_monty_mole_hole_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_monty_mole_hole_update();

    return 1;
}

int smlua_func_bhv_monty_mole_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_monty_mole_init();

    return 1;
}

int smlua_func_bhv_monty_mole_rock_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_monty_mole_rock_update();

    return 1;
}

int smlua_func_bhv_monty_mole_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_monty_mole_update();

    return 1;
}

int smlua_func_bhv_moving_blue_coin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moving_blue_coin_init();

    return 1;
}

int smlua_func_bhv_moving_blue_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moving_blue_coin_loop();

    return 1;
}

int smlua_func_bhv_moving_yellow_coin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moving_yellow_coin_init();

    return 1;
}

int smlua_func_bhv_moving_yellow_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_moving_yellow_coin_loop();

    return 1;
}

int smlua_func_bhv_mr_blizzard_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_blizzard_init();

    return 1;
}

int smlua_func_bhv_mr_blizzard_snowball(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_blizzard_snowball();

    return 1;
}

int smlua_func_bhv_mr_blizzard_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_blizzard_update();

    return 1;
}

int smlua_func_bhv_mr_i_body_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_i_body_loop();

    return 1;
}

int smlua_func_bhv_mr_i_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_i_loop();

    return 1;
}

int smlua_func_bhv_mr_i_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_mr_i_particle_loop();

    return 1;
}

int smlua_func_bhv_normal_cap_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_normal_cap_init();

    return 1;
}

int smlua_func_bhv_normal_cap_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_normal_cap_loop();

    return 1;
}

int smlua_func_bhv_object_bubble_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_object_bubble_init();

    return 1;
}

int smlua_func_bhv_object_bubble_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_object_bubble_loop();

    return 1;
}

int smlua_func_bhv_object_water_wave_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_object_water_wave_init();

    return 1;
}

int smlua_func_bhv_object_water_wave_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_object_water_wave_loop();

    return 1;
}

int smlua_func_bhv_openable_cage_door_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_openable_cage_door_loop();

    return 1;
}

int smlua_func_bhv_openable_grill_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_openable_grill_loop();

    return 1;
}

int smlua_func_bhv_orange_number_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_orange_number_init();

    return 1;
}

int smlua_func_bhv_orange_number_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_orange_number_loop();

    return 1;
}

int smlua_func_bhv_particle_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_particle_init();

    return 1;
}

int smlua_func_bhv_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_particle_loop();

    return 1;
}

int smlua_func_bhv_penguin_race_finish_line_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_penguin_race_finish_line_update();

    return 1;
}

int smlua_func_bhv_penguin_race_shortcut_check_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_penguin_race_shortcut_check_update();

    return 1;
}

int smlua_func_bhv_piranha_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_piranha_particle_loop();

    return 1;
}

int smlua_func_bhv_piranha_plant_bubble_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_piranha_plant_bubble_loop();

    return 1;
}

int smlua_func_bhv_piranha_plant_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_piranha_plant_loop();

    return 1;
}

int smlua_func_bhv_piranha_plant_waking_bubbles_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_piranha_plant_waking_bubbles_loop();

    return 1;
}

int smlua_func_bhv_platform_normals_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_platform_normals_init();

    return 1;
}

int smlua_func_bhv_platform_on_track_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_platform_on_track_init();

    return 1;
}

int smlua_func_bhv_platform_on_track_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_platform_on_track_update();

    return 1;
}

int smlua_func_bhv_play_music_track_when_touched_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_play_music_track_when_touched_loop();

    return 1;
}

int smlua_func_bhv_pokey_body_part_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pokey_body_part_update();

    return 1;
}

int smlua_func_bhv_pokey_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pokey_update();

    return 1;
}

int smlua_func_bhv_pole_base_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pole_base_loop();

    return 1;
}

int smlua_func_bhv_pole_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pole_init();

    return 1;
}

int smlua_func_bhv_pound_tiny_star_particle_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pound_tiny_star_particle_init();

    return 1;
}

int smlua_func_bhv_pound_tiny_star_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pound_tiny_star_particle_loop();

    return 1;
}

int smlua_func_bhv_pound_white_puffs_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pound_white_puffs_init();

    return 1;
}

int smlua_func_bhv_punch_tiny_triangle_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_punch_tiny_triangle_init();

    return 1;
}

int smlua_func_bhv_punch_tiny_triangle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_punch_tiny_triangle_loop();

    return 1;
}

int smlua_func_bhv_purple_switch_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_purple_switch_loop();

    return 1;
}

int smlua_func_bhv_pushable_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pushable_loop();

    return 1;
}

int smlua_func_bhv_pyramid_elevator_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_elevator_init();

    return 1;
}

int smlua_func_bhv_pyramid_elevator_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_elevator_loop();

    return 1;
}

int smlua_func_bhv_pyramid_elevator_trajectory_marker_ball_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_elevator_trajectory_marker_ball_loop();

    return 1;
}

int smlua_func_bhv_pyramid_pillar_touch_detector_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_pillar_touch_detector_loop();

    return 1;
}

int smlua_func_bhv_pyramid_top_fragment_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_top_fragment_init();

    return 1;
}

int smlua_func_bhv_pyramid_top_fragment_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_top_fragment_loop();

    return 1;
}

int smlua_func_bhv_pyramid_top_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_top_init();

    return 1;
}

int smlua_func_bhv_pyramid_top_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_pyramid_top_loop();

    return 1;
}

int smlua_func_bhv_racing_penguin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_racing_penguin_init();

    return 1;
}

int smlua_func_bhv_racing_penguin_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_racing_penguin_update();

    return 1;
}

int smlua_func_bhv_recovery_heart_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_recovery_heart_loop();

    return 1;
}

int smlua_func_bhv_red_coin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_red_coin_init();

    return 1;
}

int smlua_func_bhv_red_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_red_coin_loop();

    return 1;
}

int smlua_func_bhv_red_coin_star_marker_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_red_coin_star_marker_init();

    return 1;
}

int smlua_func_bhv_respawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_respawner_loop();

    return 1;
}

int smlua_func_bhv_rolling_log_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rolling_log_loop();

    return 1;
}

int smlua_func_bhv_rotating_clock_arm_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rotating_clock_arm_loop();

    return 1;
}

int smlua_func_bhv_rotating_exclamation_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rotating_exclamation_box_loop();

    return 1;
}

int smlua_func_bhv_rotating_octagonal_plat_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rotating_octagonal_plat_init();

    return 1;
}

int smlua_func_bhv_rotating_octagonal_plat_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rotating_octagonal_plat_loop();

    return 1;
}

int smlua_func_bhv_rotating_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rotating_platform_loop();

    return 1;
}

int smlua_func_bhv_rr_cruiser_wing_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rr_cruiser_wing_init();

    return 1;
}

int smlua_func_bhv_rr_cruiser_wing_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rr_cruiser_wing_loop();

    return 1;
}

int smlua_func_bhv_rr_rotating_bridge_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_rr_rotating_bridge_platform_loop();

    return 1;
}

int smlua_func_bhv_sand_sound_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sand_sound_loop();

    return 1;
}

int smlua_func_bhv_scuttlebug_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_scuttlebug_loop();

    return 1;
}

int smlua_func_bhv_scuttlebug_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_scuttlebug_spawn_loop();

    return 1;
}

int smlua_func_bhv_seaweed_bundle_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_seaweed_bundle_init();

    return 1;
}

int smlua_func_bhv_seaweed_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_seaweed_init();

    return 1;
}

int smlua_func_bhv_seesaw_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_seesaw_platform_init();

    return 1;
}

int smlua_func_bhv_seesaw_platform_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_seesaw_platform_update();

    return 1;
}

int smlua_func_bhv_shallow_water_splash_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_shallow_water_splash_init();

    return 1;
}

int smlua_func_bhv_ship_part_3_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ship_part_3_loop();

    return 1;
}

int smlua_func_bhv_skeeter_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_skeeter_update();

    return 1;
}

int smlua_func_bhv_skeeter_wave_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_skeeter_wave_update();

    return 1;
}

int smlua_func_bhv_sl_snowman_wind_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sl_snowman_wind_loop();

    return 1;
}

int smlua_func_bhv_sl_walking_penguin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sl_walking_penguin_loop();

    return 1;
}

int smlua_func_bhv_sliding_plat_2_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sliding_plat_2_init();

    return 1;
}

int smlua_func_bhv_sliding_plat_2_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sliding_plat_2_loop();

    return 1;
}

int smlua_func_bhv_sliding_snow_mound_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sliding_snow_mound_loop();

    return 1;
}

int smlua_func_bhv_small_bomp_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_bomp_init();

    return 1;
}

int smlua_func_bhv_small_bomp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_bomp_loop();

    return 1;
}

int smlua_func_bhv_small_bubbles_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_bubbles_loop();

    return 1;
}

int smlua_func_bhv_small_bully_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_bully_init();

    return 1;
}

int smlua_func_bhv_small_penguin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_penguin_loop();

    return 1;
}

int smlua_func_bhv_small_piranha_flame_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_piranha_flame_loop();

    return 1;
}

int smlua_func_bhv_small_water_wave_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_small_water_wave_loop();

    return 1;
}

int smlua_func_bhv_snow_leaf_particle_spawn_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snow_leaf_particle_spawn_init();

    return 1;
}

int smlua_func_bhv_snow_mound_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snow_mound_spawn_loop();

    return 1;
}

int smlua_func_bhv_snowmans_body_checkpoint_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snowmans_body_checkpoint_loop();

    return 1;
}

int smlua_func_bhv_snowmans_bottom_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snowmans_bottom_init();

    return 1;
}

int smlua_func_bhv_snowmans_bottom_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snowmans_bottom_loop();

    return 1;
}

int smlua_func_bhv_snowmans_head_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snowmans_head_init();

    return 1;
}

int smlua_func_bhv_snowmans_head_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snowmans_head_loop();

    return 1;
}

int smlua_func_bhv_snufit_balls_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snufit_balls_loop();

    return 1;
}

int smlua_func_bhv_snufit_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_snufit_loop();

    return 1;
}

int smlua_func_bhv_sound_spawner_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sound_spawner_init();

    return 1;
}

int smlua_func_bhv_sparkle_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sparkle_spawn_loop();

    return 1;
}

int smlua_func_bhv_spawn_star_no_level_exit(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* object = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 params = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 networkSendEvent = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    bhv_spawn_star_no_level_exit(object, params, networkSendEvent);

    return 1;
}

int smlua_func_bhv_spawned_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spawned_star_init();

    return 1;
}

int smlua_func_bhv_spawned_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spawned_star_loop();

    return 1;
}

int smlua_func_bhv_spindel_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spindel_init();

    return 1;
}

int smlua_func_bhv_spindel_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spindel_loop();

    return 1;
}

int smlua_func_bhv_spindrift_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spindrift_loop();

    return 1;
}

int smlua_func_bhv_spiny_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_spiny_update();

    return 1;
}

int smlua_func_bhv_squarish_path_moving_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_squarish_path_moving_loop();

    return 1;
}

int smlua_func_bhv_squarish_path_parent_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_squarish_path_parent_init();

    return 1;
}

int smlua_func_bhv_squarish_path_parent_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_squarish_path_parent_loop();

    return 1;
}

int smlua_func_bhv_squishable_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_squishable_platform_loop();

    return 1;
}

int smlua_func_bhv_ssl_moving_pyramid_wall_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ssl_moving_pyramid_wall_init();

    return 1;
}

int smlua_func_bhv_ssl_moving_pyramid_wall_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ssl_moving_pyramid_wall_loop();

    return 1;
}

int smlua_func_bhv_star_door_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_star_door_loop();

    return 1;
}

int smlua_func_bhv_star_door_loop_2(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_star_door_loop_2();

    return 1;
}

int smlua_func_bhv_star_key_collection_puff_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_star_key_collection_puff_spawner_loop();

    return 1;
}

int smlua_func_bhv_star_spawn_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_star_spawn_init();

    return 1;
}

int smlua_func_bhv_star_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_star_spawn_loop();

    return 1;
}

int smlua_func_bhv_static_checkered_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_static_checkered_platform_loop();

    return 1;
}

int smlua_func_bhv_strong_wind_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_strong_wind_particle_loop();

    return 1;
}

int smlua_func_bhv_sunken_ship_part_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sunken_ship_part_loop();

    return 1;
}

int smlua_func_bhv_sushi_shark_collision_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sushi_shark_collision_loop();

    return 1;
}

int smlua_func_bhv_sushi_shark_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_sushi_shark_loop();

    return 1;
}

int smlua_func_bhv_swing_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_swing_platform_init();

    return 1;
}

int smlua_func_bhv_swing_platform_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_swing_platform_update();

    return 1;
}

int smlua_func_bhv_swoop_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_swoop_update();

    return 1;
}

int smlua_func_bhv_tank_fish_group_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tank_fish_group_loop();

    return 1;
}

int smlua_func_bhv_temp_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_temp_coin_loop();

    return 1;
}

int smlua_func_bhv_thi_bowling_ball_spawner_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_thi_bowling_ball_spawner_loop();

    return 1;
}

int smlua_func_bhv_thi_huge_island_top_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_thi_huge_island_top_loop();

    return 1;
}

int smlua_func_bhv_thi_tiny_island_top_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_thi_tiny_island_top_loop();

    return 1;
}

int smlua_func_bhv_tilting_bowser_lava_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tilting_bowser_lava_platform_init();

    return 1;
}

int smlua_func_bhv_tilting_inverted_pyramid_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tilting_inverted_pyramid_loop();

    return 1;
}

int smlua_func_bhv_tiny_star_particles_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tiny_star_particles_init();

    return 1;
}

int smlua_func_bhv_tower_door_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tower_door_loop();

    return 1;
}

int smlua_func_bhv_tower_platform_group_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tower_platform_group_init();

    return 1;
}

int smlua_func_bhv_tower_platform_group_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tower_platform_group_loop();

    return 1;
}

int smlua_func_bhv_tox_box_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tox_box_loop();

    return 1;
}

int smlua_func_bhv_track_ball_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_track_ball_update();

    return 1;
}

int smlua_func_bhv_treasure_chest_bottom_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_bottom_init();

    return 1;
}

int smlua_func_bhv_treasure_chest_bottom_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_bottom_loop();

    return 1;
}

int smlua_func_bhv_treasure_chest_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_init();

    return 1;
}

int smlua_func_bhv_treasure_chest_jrb_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_jrb_init();

    return 1;
}

int smlua_func_bhv_treasure_chest_jrb_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_jrb_loop();

    return 1;
}

int smlua_func_bhv_treasure_chest_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_loop();

    return 1;
}

int smlua_func_bhv_treasure_chest_ship_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_ship_init();

    return 1;
}

int smlua_func_bhv_treasure_chest_ship_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_ship_loop();

    return 1;
}

int smlua_func_bhv_treasure_chest_top_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_treasure_chest_top_loop();

    return 1;
}

int smlua_func_bhv_tree_snow_or_leaf_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tree_snow_or_leaf_loop();

    return 1;
}

int smlua_func_bhv_triplet_butterfly_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_triplet_butterfly_update();

    return 1;
}

int smlua_func_bhv_ttc_2d_rotator_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_2d_rotator_init();

    return 1;
}

int smlua_func_bhv_ttc_2d_rotator_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_2d_rotator_update();

    return 1;
}

int smlua_func_bhv_ttc_cog_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_cog_init();

    return 1;
}

int smlua_func_bhv_ttc_cog_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_cog_update();

    return 1;
}

int smlua_func_bhv_ttc_elevator_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_elevator_init();

    return 1;
}

int smlua_func_bhv_ttc_elevator_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_elevator_update();

    return 1;
}

int smlua_func_bhv_ttc_moving_bar_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_moving_bar_init();

    return 1;
}

int smlua_func_bhv_ttc_moving_bar_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_moving_bar_update();

    return 1;
}

int smlua_func_bhv_ttc_pendulum_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_pendulum_init();

    return 1;
}

int smlua_func_bhv_ttc_pendulum_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_pendulum_update();

    return 1;
}

int smlua_func_bhv_ttc_pit_block_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_pit_block_init();

    return 1;
}

int smlua_func_bhv_ttc_pit_block_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_pit_block_update();

    return 1;
}

int smlua_func_bhv_ttc_rotating_solid_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_rotating_solid_init();

    return 1;
}

int smlua_func_bhv_ttc_rotating_solid_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_rotating_solid_update();

    return 1;
}

int smlua_func_bhv_ttc_spinner_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_spinner_update();

    return 1;
}

int smlua_func_bhv_ttc_treadmill_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_treadmill_init();

    return 1;
}

int smlua_func_bhv_ttc_treadmill_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttc_treadmill_update();

    return 1;
}

int smlua_func_bhv_ttm_rolling_log_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ttm_rolling_log_init();

    return 1;
}

int smlua_func_bhv_tumbling_bridge_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tumbling_bridge_loop();

    return 1;
}

int smlua_func_bhv_tumbling_bridge_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tumbling_bridge_platform_loop();

    return 1;
}

int smlua_func_bhv_tuxies_mother_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tuxies_mother_loop();

    return 1;
}

int smlua_func_bhv_tweester_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tweester_loop();

    return 1;
}

int smlua_func_bhv_tweester_sand_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_tweester_sand_particle_loop();

    return 1;
}

int smlua_func_bhv_ukiki_cage_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ukiki_cage_loop();

    return 1;
}

int smlua_func_bhv_ukiki_cage_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ukiki_cage_star_loop();

    return 1;
}

int smlua_func_bhv_ukiki_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ukiki_init();

    return 1;
}

int smlua_func_bhv_ukiki_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_ukiki_loop();

    return 1;
}

int smlua_func_bhv_unagi_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unagi_init();

    return 1;
}

int smlua_func_bhv_unagi_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unagi_loop();

    return 1;
}

int smlua_func_bhv_unagi_subobject_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unagi_subobject_loop();

    return 1;
}

int smlua_func_bhv_unused_particle_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unused_particle_spawn_loop();

    return 1;
}

int smlua_func_bhv_unused_poundable_platform(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unused_poundable_platform();

    return 1;
}

int smlua_func_bhv_vanish_cap_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_vanish_cap_init();

    return 1;
}

int smlua_func_bhv_volcano_flames_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_volcano_flames_loop();

    return 1;
}

int smlua_func_bhv_volcano_sound_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_volcano_sound_loop();

    return 1;
}

int smlua_func_bhv_volcano_trap_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_volcano_trap_loop();

    return 1;
}

int smlua_func_bhv_wall_tiny_star_particle_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wall_tiny_star_particle_loop();

    return 1;
}

int smlua_func_bhv_warp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_warp_loop();

    return 1;
}

int smlua_func_bhv_water_air_bubble_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_air_bubble_init();

    return 1;
}

int smlua_func_bhv_water_air_bubble_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_air_bubble_loop();

    return 1;
}

int smlua_func_bhv_water_bomb_cannon_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_bomb_cannon_loop();

    return 1;
}

int smlua_func_bhv_water_bomb_shadow_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_bomb_shadow_update();

    return 1;
}

int smlua_func_bhv_water_bomb_spawner_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_bomb_spawner_update();

    return 1;
}

int smlua_func_bhv_water_bomb_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_bomb_update();

    return 1;
}

int smlua_func_bhv_water_droplet_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_droplet_loop();

    return 1;
}

int smlua_func_bhv_water_droplet_splash_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_droplet_splash_init();

    return 1;
}

int smlua_func_bhv_water_level_diamond_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_level_diamond_loop();

    return 1;
}

int smlua_func_bhv_water_level_pillar_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_level_pillar_init();

    return 1;
}

int smlua_func_bhv_water_level_pillar_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_level_pillar_loop();

    return 1;
}

int smlua_func_bhv_water_mist_2_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_mist_2_loop();

    return 1;
}

int smlua_func_bhv_water_mist_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_mist_loop();

    return 1;
}

int smlua_func_bhv_water_mist_spawn_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_mist_spawn_loop();

    return 1;
}

int smlua_func_bhv_water_splash_spawn_droplets(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_splash_spawn_droplets();

    return 1;
}

int smlua_func_bhv_water_waves_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_water_waves_init();

    return 1;
}

int smlua_func_bhv_waterfall_sound_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_waterfall_sound_loop();

    return 1;
}

int smlua_func_bhv_wave_trail_shrink(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wave_trail_shrink();

    return 1;
}

int smlua_func_bhv_wdw_express_elevator_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wdw_express_elevator_loop();

    return 1;
}

int smlua_func_bhv_wf_breakable_wall_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_breakable_wall_loop();

    return 1;
}

int smlua_func_bhv_wf_elevator_tower_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_elevator_tower_platform_loop();

    return 1;
}

int smlua_func_bhv_wf_rotating_wooden_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_rotating_wooden_platform_init();

    return 1;
}

int smlua_func_bhv_wf_rotating_wooden_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_rotating_wooden_platform_loop();

    return 1;
}

int smlua_func_bhv_wf_sliding_platform_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_sliding_platform_init();

    return 1;
}

int smlua_func_bhv_wf_sliding_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_sliding_platform_loop();

    return 1;
}

int smlua_func_bhv_wf_sliding_tower_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_sliding_tower_platform_loop();

    return 1;
}

int smlua_func_bhv_wf_solid_tower_platform_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wf_solid_tower_platform_loop();

    return 1;
}

int smlua_func_bhv_whirlpool_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_whirlpool_init();

    return 1;
}

int smlua_func_bhv_whirlpool_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_whirlpool_loop();

    return 1;
}

int smlua_func_bhv_white_puff_1_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_white_puff_1_loop();

    return 1;
}

int smlua_func_bhv_white_puff_2_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_white_puff_2_loop();

    return 1;
}

int smlua_func_bhv_white_puff_exploding_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_white_puff_exploding_loop();

    return 1;
}

int smlua_func_bhv_white_puff_smoke_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_white_puff_smoke_init();

    return 1;
}

int smlua_func_bhv_whomp_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_whomp_loop();

    return 1;
}

int smlua_func_bhv_wiggler_body_part_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wiggler_body_part_update();

    return 1;
}

int smlua_func_bhv_wiggler_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wiggler_update();

    return 1;
}

int smlua_func_bhv_wind_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wind_loop();

    return 1;
}

int smlua_func_bhv_wing_cap_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wing_cap_init();

    return 1;
}

int smlua_func_bhv_wing_vanish_cap_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wing_vanish_cap_loop();

    return 1;
}

int smlua_func_bhv_wooden_post_update(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_wooden_post_update();

    return 1;
}

int smlua_func_bhv_yellow_coin_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_yellow_coin_init();

    return 1;
}

int smlua_func_bhv_yellow_coin_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_yellow_coin_loop();

    return 1;
}

int smlua_func_bhv_yoshi_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_yoshi_init();

    return 1;
}

int smlua_func_bhv_yoshi_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_yoshi_loop();

    return 1;
}

int smlua_func_check_if_moving_over_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 a0 = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 a1 = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, check_if_moving_over_floor(a0, a1));

    return 1;
}

int smlua_func_clear_particle_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    clear_particle_flags(flags);

    return 1;
}

int smlua_func_common_anchor_mario_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 sp28 = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 sp2C = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 sp30 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    common_anchor_mario_behavior(sp28, sp2C, sp30);

    return 1;
}

int smlua_func_cur_obj_spawn_strong_wind_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    s32 windSpread = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 scale = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 relPosX = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 relPosY = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 relPosZ = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    cur_obj_spawn_strong_wind_particles(windSpread, scale, relPosX, relPosY, relPosZ);

    return 1;
}

/*
int smlua_func_geo_bits_bowser_coloring(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 a2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_bits_bowser_coloring(run, node, a2));

    return 1;
}
*/

/*
int smlua_func_geo_move_mario_part_from_parent(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_move_mario_part_from_parent(run, node, mtx));

    return 1;
}
*/

/*
int smlua_func_geo_scale_bowser_key(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 mtx[4][4] = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_scale_bowser_key(run, node, mtx[4][4]));

    return 1;
}
*/

/*
int smlua_func_geo_snufit_move_mask(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 * c = (Mat4 *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_snufit_move_mask(callContext, node, c));

    return 1;
}
*/

/*
int smlua_func_geo_snufit_scale_body(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 * c = (Mat4 *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_snufit_scale_body(callContext, node, c));

    return 1;
}
*/

/*
int smlua_func_geo_switch_bowser_eyes(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 * mtx = (Mat4 *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_switch_bowser_eyes(run, node, mtx));

    return 1;
}
*/

/*
int smlua_func_geo_switch_tuxie_mother_eyes(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 * mtx = (Mat4 *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_switch_tuxie_mother_eyes(run, node, mtx));

    return 1;
}
*/

/*
int smlua_func_geo_update_body_rot_from_parent(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_update_body_rot_from_parent(run, node, mtx));

    return 1;
}
*/

/*
int smlua_func_geo_update_held_mario_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 run = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_update_held_mario_pos(run, node, mtx));

    return 1;
}
*/

int smlua_func_mario_moving_fast_enough_to_make_piranha_plant_bite(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, mario_moving_fast_enough_to_make_piranha_plant_bite());

    return 1;
}

int smlua_func_obj_set_secondary_camera_focus(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    obj_set_secondary_camera_focus();

    return 1;
}

int smlua_func_play_penguin_walking_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 walk = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_penguin_walking_sound(walk);

    return 1;
}

int smlua_func_spawn_default_star(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, spawn_default_star(x, y, z));

    return 1;
}

int smlua_func_spawn_mist_from_global(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    spawn_mist_from_global();

    return 1;
}

int smlua_func_spawn_mist_particles_variable(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 count = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 offsetY = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 size = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    spawn_mist_particles_variable(count, offsetY, size);

    return 1;
}

int smlua_func_spawn_no_exit_star(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, spawn_no_exit_star(x, y, z));

    return 1;
}

int smlua_func_spawn_red_coin_cutscene_star(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, spawn_red_coin_cutscene_star(x, y, z));

    return 1;
}

int smlua_func_spawn_triangle_break_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 numTris = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 triModel = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 triSize = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 triAnimState = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    spawn_triangle_break_particles(numTris, triModel, triSize, triAnimState);

    return 1;
}

int smlua_func_spawn_wind_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 pitch = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 yaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    spawn_wind_particles(pitch, yaw);

    return 1;
}

int smlua_func_tox_box_move(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 forwardVel = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 a1 = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 deltaPitch = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 deltaRoll = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    tox_box_move(forwardVel, a1, deltaPitch, deltaRoll);

    return 1;
}

int smlua_func_update_angle_from_move_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 * angle = (s32 *)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, update_angle_from_move_flags(angle));

    return 1;
}

int smlua_func_vec3f_copy_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* dest = smlua_get_vec3f_from_buffer();
    dest[0] = smlua_get_number_field(1, "x");
    dest[1] = smlua_get_number_field(1, "y");
    dest[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* src = smlua_get_vec3f_from_buffer();
    src[0] = smlua_get_number_field(2, "x");
    src[1] = smlua_get_number_field(2, "y");
    src[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    vec3f_copy_2(dest, src);

    smlua_push_number_field(1, "x", dest[0]);
    smlua_push_number_field(1, "y", dest[1]);
    smlua_push_number_field(1, "z", dest[2]);

    smlua_push_number_field(2, "x", src[0]);
    smlua_push_number_field(2, "y", src[1]);
    smlua_push_number_field(2, "z", src[2]);

    return 1;
}

  //////////////////////
 // behavior_table.h //
//////////////////////

int smlua_func_get_behavior_from_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int id = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_pointer(L, LVT_BEHAVIORSCRIPT_P, (void*)get_behavior_from_id(id));

    return 1;
}

int smlua_func_get_behavior_name_from_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int id = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushstring(L, get_behavior_name_from_id(id));

    return 1;
}

int smlua_func_get_id_from_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_id_from_behavior(behavior));

    return 1;
}

int smlua_func_get_id_from_behavior_name(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_id_from_behavior_name(name));

    return 1;
}

int smlua_func_get_id_from_vanilla_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_id_from_vanilla_behavior(behavior));

    return 1;
}

  //////////////
 // camera.h //
//////////////

int smlua_func_approach_camera_height(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 goal = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 inc = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    approach_camera_height(c, goal, inc);

    return 1;
}

int smlua_func_approach_f32_asymptotic(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 current = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 multiplier = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, approach_f32_asymptotic(current, target, multiplier));

    return 1;
}

int smlua_func_approach_f32_asymptotic_bool(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * current = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 multiplier = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, approach_f32_asymptotic_bool(current, target, multiplier));

    return 1;
}

int smlua_func_approach_s16_asymptotic(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 current = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 target = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 divisor = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, approach_s16_asymptotic(current, target, divisor));

    return 1;
}

int smlua_func_approach_s16_asymptotic_bool(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 * current = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 target = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 divisor = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, approach_s16_asymptotic_bool(current, target, divisor));

    return 1;
}

int smlua_func_approach_vec3f_asymptotic(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }


    f32* current = smlua_get_vec3f_from_buffer();
    current[0] = smlua_get_number_field(1, "x");
    current[1] = smlua_get_number_field(1, "y");
    current[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* target = smlua_get_vec3f_from_buffer();
    target[0] = smlua_get_number_field(2, "x");
    target[1] = smlua_get_number_field(2, "y");
    target[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 xMul = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 yMul = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 zMul = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    approach_vec3f_asymptotic(current, target, xMul, yMul, zMul);

    smlua_push_number_field(1, "x", current[0]);
    smlua_push_number_field(1, "y", current[1]);
    smlua_push_number_field(1, "z", current[2]);

    smlua_push_number_field(2, "x", target[0]);
    smlua_push_number_field(2, "y", target[1]);
    smlua_push_number_field(2, "z", target[2]);

    return 1;
}

int smlua_func_calc_abs_dist(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* a = smlua_get_vec3f_from_buffer();
    a[0] = smlua_get_number_field(1, "x");
    a[1] = smlua_get_number_field(1, "y");
    a[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* b = smlua_get_vec3f_from_buffer();
    b[0] = smlua_get_number_field(2, "x");
    b[1] = smlua_get_number_field(2, "y");
    b[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, calc_abs_dist(a, b));

    smlua_push_number_field(1, "x", a[0]);
    smlua_push_number_field(1, "y", a[1]);
    smlua_push_number_field(1, "z", a[2]);

    smlua_push_number_field(2, "x", b[0]);
    smlua_push_number_field(2, "y", b[1]);
    smlua_push_number_field(2, "z", b[2]);

    return 1;
}

int smlua_func_calc_hor_dist(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* a = smlua_get_vec3f_from_buffer();
    a[0] = smlua_get_number_field(1, "x");
    a[1] = smlua_get_number_field(1, "y");
    a[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* b = smlua_get_vec3f_from_buffer();
    b[0] = smlua_get_number_field(2, "x");
    b[1] = smlua_get_number_field(2, "y");
    b[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, calc_hor_dist(a, b));

    smlua_push_number_field(1, "x", a[0]);
    smlua_push_number_field(1, "y", a[1]);
    smlua_push_number_field(1, "z", a[2]);

    smlua_push_number_field(2, "x", b[0]);
    smlua_push_number_field(2, "y", b[1]);
    smlua_push_number_field(2, "z", b[2]);

    return 1;
}

int smlua_func_calculate_angles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(1, "x");
    from[1] = smlua_get_number_field(1, "y");
    from[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(2, "x");
    to[1] = smlua_get_number_field(2, "y");
    to[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 * pitch = (s16 *)smlua_to_cpointer(L, 3, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 * yaw = (s16 *)smlua_to_cpointer(L, 4, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    calculate_angles(from, to, pitch, yaw);

    smlua_push_number_field(1, "x", from[0]);
    smlua_push_number_field(1, "y", from[1]);
    smlua_push_number_field(1, "z", from[2]);

    smlua_push_number_field(2, "x", to[0]);
    smlua_push_number_field(2, "y", to[1]);
    smlua_push_number_field(2, "z", to[2]);

    return 1;
}

int smlua_func_calculate_pitch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(1, "x");
    from[1] = smlua_get_number_field(1, "y");
    from[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(2, "x");
    to[1] = smlua_get_number_field(2, "y");
    to[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, calculate_pitch(from, to));

    smlua_push_number_field(1, "x", from[0]);
    smlua_push_number_field(1, "y", from[1]);
    smlua_push_number_field(1, "z", from[2]);

    smlua_push_number_field(2, "x", to[0]);
    smlua_push_number_field(2, "y", to[1]);
    smlua_push_number_field(2, "z", to[2]);

    return 1;
}

int smlua_func_calculate_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(1, "x");
    from[1] = smlua_get_number_field(1, "y");
    from[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(2, "x");
    to[1] = smlua_get_number_field(2, "y");
    to[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, calculate_yaw(from, to));

    smlua_push_number_field(1, "x", from[0]);
    smlua_push_number_field(1, "y", from[1]);
    smlua_push_number_field(1, "z", from[2]);

    smlua_push_number_field(2, "x", to[0]);
    smlua_push_number_field(2, "y", to[1]);
    smlua_push_number_field(2, "z", to[2]);

    return 1;
}

int smlua_func_cam_select_alt_mode(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 angle = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, cam_select_alt_mode(angle));

    return 1;
}

int smlua_func_camera_approach_f32_symmetric(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 value = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 increment = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, camera_approach_f32_symmetric(value, target, increment));

    return 1;
}

int smlua_func_camera_approach_f32_symmetric_bool(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * current = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 increment = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, camera_approach_f32_symmetric_bool(current, target, increment));

    return 1;
}

int smlua_func_camera_approach_s16_symmetric_bool(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 * current = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 target = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 increment = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, camera_approach_s16_symmetric_bool(current, target, increment));

    return 1;
}

int smlua_func_camera_course_processing(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, camera_course_processing(c));

    return 1;
}

int smlua_func_camera_set_use_course_specific_settings(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 enable = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    camera_set_use_course_specific_settings(enable);

    return 1;
}

int smlua_func_clamp_pitch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(1, "x");
    from[1] = smlua_get_number_field(1, "y");
    from[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(2, "x");
    to[1] = smlua_get_number_field(2, "y");
    to[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 maxPitch = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 minPitch = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, clamp_pitch(from, to, maxPitch, minPitch));

    smlua_push_number_field(1, "x", from[0]);
    smlua_push_number_field(1, "y", from[1]);
    smlua_push_number_field(1, "z", from[2]);

    smlua_push_number_field(2, "x", to[0]);
    smlua_push_number_field(2, "y", to[1]);
    smlua_push_number_field(2, "z", to[2]);

    return 1;
}

int smlua_func_clamp_positions_and_find_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* origin = smlua_get_vec3f_from_buffer();
    origin[0] = smlua_get_number_field(2, "x");
    origin[1] = smlua_get_number_field(2, "y");
    origin[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 xMax = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 xMin = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 zMax = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 zMin = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    lua_pushinteger(L, clamp_positions_and_find_yaw(pos, origin, xMax, xMin, zMax, zMin));

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", origin[0]);
    smlua_push_number_field(2, "y", origin[1]);
    smlua_push_number_field(2, "z", origin[2]);

    return 1;
}

int smlua_func_collide_with_walls(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 offsetY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 radius = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, collide_with_walls(pos, offsetY, radius));

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    return 1;
}

/*
int smlua_func_cutscene_event(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

//  CameraEvent event = (CameraEvent)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 2, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 start = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 end = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, cutscene_event(event, c, start, end));

    return 1;
}
*/

int smlua_func_cutscene_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u8 cutscene = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, cutscene_object(cutscene, o));

    return 1;
}

int smlua_func_cutscene_object_with_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u8 cutscene = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 dialogID = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, cutscene_object_with_dialog(cutscene, o, dialogID));

    return 1;
}

int smlua_func_cutscene_object_without_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u8 cutscene = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, cutscene_object_without_dialog(cutscene, o));

    return 1;
}

int smlua_func_cutscene_set_fov_shake_preset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 preset = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    cutscene_set_fov_shake_preset(preset);

    return 1;
}

int smlua_func_cutscene_spawn_obj(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u32 obj = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 frame = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, cutscene_spawn_obj(obj, frame));

    return 1;
}

int smlua_func_find_c_buttons_pressed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u16 currentState = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 buttonsPressed = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u16 buttonsDown = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, find_c_buttons_pressed(currentState, buttonsPressed, buttonsDown));

    return 1;
}

int smlua_func_find_mario_floor_and_ceil(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct PlayerGeometry* pg = (struct PlayerGeometry*)smlua_to_cobject(L, 1, LOT_PLAYERGEOMETRY);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    find_mario_floor_and_ceil(pg);

    return 1;
}

/*
int smlua_func_geo_camera_fov(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* g = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  void * context = (void *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_camera_fov(callContext, g, context));

    return 1;
}
*/

/*
int smlua_func_geo_camera_main(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* g = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  void * context = (void *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    UNIMPLEMENTED -->(L, geo_camera_main(callContext, g, context));

    return 1;
}
*/

int smlua_func_get_cutscene_from_mario_status(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_cutscene_from_mario_status(c));

    return 1;
}

int smlua_func_handle_c_button_movement(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    handle_c_button_movement(c);

    return 1;
}

int smlua_func_is_range_behind_surface(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }


    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(1, "x");
    from[1] = smlua_get_number_field(1, "y");
    from[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(2, "x");
    to[1] = smlua_get_number_field(2, "y");
    to[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    struct Surface* surf = (struct Surface*)smlua_to_cobject(L, 3, LOT_SURFACE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 range = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 surfType = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    lua_pushinteger(L, is_range_behind_surface(from, to, surf, range, surfType));

    smlua_push_number_field(1, "x", from[0]);
    smlua_push_number_field(1, "y", from[1]);
    smlua_push_number_field(1, "z", from[2]);

    smlua_push_number_field(2, "x", to[0]);
    smlua_push_number_field(2, "y", to[1]);
    smlua_push_number_field(2, "z", to[2]);

    return 1;
}

int smlua_func_is_within_100_units_of_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 posX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 posY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 posZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, is_within_100_units_of_mario(posX, posY, posZ));

    return 1;
}

int smlua_func_move_mario_head_c_up(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    move_mario_head_c_up(c);

    return 1;
}

int smlua_func_next_lakitu_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 7)) { return 0; }


    f32* newPos = smlua_get_vec3f_from_buffer();
    newPos[0] = smlua_get_number_field(1, "x");
    newPos[1] = smlua_get_number_field(1, "y");
    newPos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* newFoc = smlua_get_vec3f_from_buffer();
    newFoc[0] = smlua_get_number_field(2, "x");
    newFoc[1] = smlua_get_number_field(2, "y");
    newFoc[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    f32* curPos = smlua_get_vec3f_from_buffer();
    curPos[0] = smlua_get_number_field(3, "x");
    curPos[1] = smlua_get_number_field(3, "y");
    curPos[2] = smlua_get_number_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    f32* curFoc = smlua_get_vec3f_from_buffer();
    curFoc[0] = smlua_get_number_field(4, "x");
    curFoc[1] = smlua_get_number_field(4, "y");
    curFoc[2] = smlua_get_number_field(4, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    f32* oldPos = smlua_get_vec3f_from_buffer();
    oldPos[0] = smlua_get_number_field(5, "x");
    oldPos[1] = smlua_get_number_field(5, "y");
    oldPos[2] = smlua_get_number_field(5, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    f32* oldFoc = smlua_get_vec3f_from_buffer();
    oldFoc[0] = smlua_get_number_field(6, "x");
    oldFoc[1] = smlua_get_number_field(6, "y");
    oldFoc[2] = smlua_get_number_field(6, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    s16 yaw = smlua_to_integer(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }

    lua_pushinteger(L, next_lakitu_state(newPos, newFoc, curPos, curFoc, oldPos, oldFoc, yaw));

    smlua_push_number_field(1, "x", newPos[0]);
    smlua_push_number_field(1, "y", newPos[1]);
    smlua_push_number_field(1, "z", newPos[2]);

    smlua_push_number_field(2, "x", newFoc[0]);
    smlua_push_number_field(2, "y", newFoc[1]);
    smlua_push_number_field(2, "z", newFoc[2]);

    smlua_push_number_field(3, "x", curPos[0]);
    smlua_push_number_field(3, "y", curPos[1]);
    smlua_push_number_field(3, "z", curPos[2]);

    smlua_push_number_field(4, "x", curFoc[0]);
    smlua_push_number_field(4, "y", curFoc[1]);
    smlua_push_number_field(4, "z", curFoc[2]);

    smlua_push_number_field(5, "x", oldPos[0]);
    smlua_push_number_field(5, "y", oldPos[1]);
    smlua_push_number_field(5, "z", oldPos[2]);

    smlua_push_number_field(6, "x", oldFoc[0]);
    smlua_push_number_field(6, "y", oldFoc[1]);
    smlua_push_number_field(6, "z", oldFoc[2]);

    return 1;
}

int smlua_func_obj_rotate_towards_point(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* point = smlua_get_vec3f_from_buffer();
    point[0] = smlua_get_number_field(2, "x");
    point[1] = smlua_get_number_field(2, "y");
    point[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 pitchOff = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 yawOff = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 pitchDiv = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    s16 yawDiv = smlua_to_integer(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    obj_rotate_towards_point(o, point, pitchOff, yawOff, pitchDiv, yawDiv);

    smlua_push_number_field(2, "x", point[0]);
    smlua_push_number_field(2, "y", point[1]);
    smlua_push_number_field(2, "z", point[2]);

    return 1;
}

int smlua_func_object_pos_to_vec3f(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    object_pos_to_vec3f(dst, o);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    return 1;
}

int smlua_func_offset_rotated(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(2, "x");
    from[1] = smlua_get_number_field(2, "y");
    from[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(3, "x");
    to[1] = smlua_get_number_field(3, "y");
    to[2] = smlua_get_number_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    s16* rotation = smlua_get_vec3s_from_buffer();
    rotation[0] = smlua_get_integer_field(4, "x");
    rotation[1] = smlua_get_integer_field(4, "y");
    rotation[2] = smlua_get_integer_field(4, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    offset_rotated(dst, from, to, rotation);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    smlua_push_number_field(2, "x", from[0]);
    smlua_push_number_field(2, "y", from[1]);
    smlua_push_number_field(2, "z", from[2]);

    smlua_push_number_field(3, "x", to[0]);
    smlua_push_number_field(3, "y", to[1]);
    smlua_push_number_field(3, "z", to[2]);

    smlua_push_integer_field(4, "x", rotation[0]);
    smlua_push_integer_field(4, "y", rotation[1]);
    smlua_push_integer_field(4, "z", rotation[2]);

    return 1;
}

int smlua_func_offset_yaw_outward_radial(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 areaYaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, offset_yaw_outward_radial(c, areaYaw));

    return 1;
}

int smlua_func_play_camera_buzz_if_c_sideways(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_camera_buzz_if_c_sideways();

    return 1;
}

int smlua_func_play_camera_buzz_if_cbutton(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_camera_buzz_if_cbutton();

    return 1;
}

int smlua_func_play_camera_buzz_if_cdown(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_camera_buzz_if_cdown();

    return 1;
}

int smlua_func_play_cutscene(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_cutscene(c);

    return 1;
}

int smlua_func_play_sound_button_change_blocked(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_button_change_blocked();

    return 1;
}

int smlua_func_play_sound_cbutton_down(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_cbutton_down();

    return 1;
}

int smlua_func_play_sound_cbutton_side(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_cbutton_side();

    return 1;
}

int smlua_func_play_sound_cbutton_up(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_cbutton_up();

    return 1;
}

int smlua_func_play_sound_if_cam_switched_to_lakitu_or_mario(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_if_cam_switched_to_lakitu_or_mario();

    return 1;
}

int smlua_func_play_sound_rbutton_changed(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_sound_rbutton_changed();

    return 1;
}

int smlua_func_radial_camera_input(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 unused = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, radial_camera_input(c, unused));

    return 1;
}

int smlua_func_random_vec3s(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    s16* dst = smlua_get_vec3s_from_buffer();
    dst[0] = smlua_get_integer_field(1, "x");
    dst[1] = smlua_get_integer_field(1, "y");
    dst[2] = smlua_get_integer_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 xRange = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 yRange = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 zRange = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    random_vec3s(dst, xRange, yRange, zRange);

    smlua_push_integer_field(1, "x", dst[0]);
    smlua_push_integer_field(1, "y", dst[1]);
    smlua_push_integer_field(1, "z", dst[2]);

    return 1;
}

int smlua_func_reset_camera(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    reset_camera(c);

    return 1;
}

int smlua_func_resolve_geometry_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* lastGood = smlua_get_vec3f_from_buffer();
    lastGood[0] = smlua_get_number_field(2, "x");
    lastGood[1] = smlua_get_number_field(2, "y");
    lastGood[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    resolve_geometry_collisions(pos, lastGood);

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", lastGood[0]);
    smlua_push_number_field(2, "y", lastGood[1]);
    smlua_push_number_field(2, "z", lastGood[2]);

    return 1;
}

int smlua_func_rotate_camera_around_walls(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* cPos = smlua_get_vec3f_from_buffer();
    cPos[0] = smlua_get_number_field(2, "x");
    cPos[1] = smlua_get_number_field(2, "y");
    cPos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 * avoidYaw = (s16 *)smlua_to_cpointer(L, 3, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 yawRange = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, rotate_camera_around_walls(c, cPos, avoidYaw, yawRange));

    smlua_push_number_field(2, "x", cPos[0]);
    smlua_push_number_field(2, "y", cPos[1]);
    smlua_push_number_field(2, "z", cPos[2]);

    return 1;
}

int smlua_func_rotate_in_xz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* src = smlua_get_vec3f_from_buffer();
    src[0] = smlua_get_number_field(2, "x");
    src[1] = smlua_get_number_field(2, "y");
    src[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 yaw = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    rotate_in_xz(dst, src, yaw);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    smlua_push_number_field(2, "x", src[0]);
    smlua_push_number_field(2, "y", src[1]);
    smlua_push_number_field(2, "z", src[2]);

    return 1;
}

int smlua_func_rotate_in_yz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* src = smlua_get_vec3f_from_buffer();
    src[0] = smlua_get_number_field(2, "x");
    src[1] = smlua_get_number_field(2, "y");
    src[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 pitch = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    rotate_in_yz(dst, src, pitch);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    smlua_push_number_field(2, "x", src[0]);
    smlua_push_number_field(2, "y", src[1]);
    smlua_push_number_field(2, "z", src[2]);

    return 1;
}

int smlua_func_scale_along_line(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* dest = smlua_get_vec3f_from_buffer();
    dest[0] = smlua_get_number_field(1, "x");
    dest[1] = smlua_get_number_field(1, "y");
    dest[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* from = smlua_get_vec3f_from_buffer();
    from[0] = smlua_get_number_field(2, "x");
    from[1] = smlua_get_number_field(2, "y");
    from[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    f32* to = smlua_get_vec3f_from_buffer();
    to[0] = smlua_get_number_field(3, "x");
    to[1] = smlua_get_number_field(3, "y");
    to[2] = smlua_get_number_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 scale = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    scale_along_line(dest, from, to, scale);

    smlua_push_number_field(1, "x", dest[0]);
    smlua_push_number_field(1, "y", dest[1]);
    smlua_push_number_field(1, "z", dest[2]);

    smlua_push_number_field(2, "x", from[0]);
    smlua_push_number_field(2, "y", from[1]);
    smlua_push_number_field(2, "z", from[2]);

    smlua_push_number_field(3, "x", to[0]);
    smlua_push_number_field(3, "y", to[1]);
    smlua_push_number_field(3, "z", to[2]);

    return 1;
}

int smlua_func_select_mario_cam_mode(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    select_mario_cam_mode();

    return 1;
}

int smlua_func_set_cam_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 mode = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, set_cam_angle(mode));

    return 1;
}

int smlua_func_set_camera_mode(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 mode = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 frames = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_camera_mode(c, mode, frames);

    return 1;
}

int smlua_func_set_camera_mode_fixed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 x = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 y = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 z = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, set_camera_mode_fixed(c, x, y, z));

    return 1;
}

int smlua_func_set_camera_pitch_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 mag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 decay = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 inc = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_camera_pitch_shake(mag, decay, inc);

    return 1;
}

int smlua_func_set_camera_roll_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 mag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 decay = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 inc = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_camera_roll_shake(mag, decay, inc);

    return 1;
}

int smlua_func_set_camera_shake_from_hit(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 shake = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_camera_shake_from_hit(shake);

    return 1;
}

int smlua_func_set_camera_shake_from_point(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 shake = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 posX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 posY = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 posZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    set_camera_shake_from_point(shake, posX, posY, posZ);

    return 1;
}

int smlua_func_set_camera_yaw_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 mag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 decay = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 inc = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_camera_yaw_shake(mag, decay, inc);

    return 1;
}

int smlua_func_set_environmental_camera_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 shake = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_environmental_camera_shake(shake);

    return 1;
}

int smlua_func_set_fixed_cam_axis_sa_lobby(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 preset = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_fixed_cam_axis_sa_lobby(preset);

    return 1;
}

int smlua_func_set_fov_function(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 func = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_fov_function(func);

    return 1;
}

int smlua_func_set_fov_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 amplitude = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 decay = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 shakeSpeed = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_fov_shake(amplitude, decay, shakeSpeed);

    return 1;
}

int smlua_func_set_fov_shake_from_point_preset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    u8 preset = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 posX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 posY = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 posZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    set_fov_shake_from_point_preset(preset, posX, posY, posZ);

    return 1;
}

int smlua_func_set_handheld_shake(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 mode = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_handheld_shake(mode);

    return 1;
}

int smlua_func_set_or_approach_f32_asymptotic(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * dst = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 goal = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 scale = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, set_or_approach_f32_asymptotic(dst, goal, scale));

    return 1;
}

int smlua_func_set_or_approach_s16_symmetric(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 * current = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 target = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 increment = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, set_or_approach_s16_symmetric(current, target, increment));

    return 1;
}

int smlua_func_set_or_approach_vec3f_asymptotic(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* goal = smlua_get_vec3f_from_buffer();
    goal[0] = smlua_get_number_field(2, "x");
    goal[1] = smlua_get_number_field(2, "y");
    goal[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 xMul = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 yMul = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 zMul = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    set_or_approach_vec3f_asymptotic(dst, goal, xMul, yMul, zMul);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    smlua_push_number_field(2, "x", goal[0]);
    smlua_push_number_field(2, "y", goal[1]);
    smlua_push_number_field(2, "z", goal[2]);

    return 1;
}

int smlua_func_set_pitch_shake_from_point(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 7)) { return 0; }

    s16 mag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 decay = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 inc = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 maxDist = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 posX = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 posY = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    f32 posZ = smlua_to_number(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }

    set_pitch_shake_from_point(mag, decay, inc, maxDist, posX, posY, posZ);

    return 1;
}

int smlua_func_shake_camera_handheld(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* focus = smlua_get_vec3f_from_buffer();
    focus[0] = smlua_get_number_field(2, "x");
    focus[1] = smlua_get_number_field(2, "y");
    focus[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    shake_camera_handheld(pos, focus);

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", focus[0]);
    smlua_push_number_field(2, "y", focus[1]);
    smlua_push_number_field(2, "z", focus[2]);

    return 1;
}

int smlua_func_shake_camera_pitch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* focus = smlua_get_vec3f_from_buffer();
    focus[0] = smlua_get_number_field(2, "x");
    focus[1] = smlua_get_number_field(2, "y");
    focus[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    shake_camera_pitch(pos, focus);

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", focus[0]);
    smlua_push_number_field(2, "y", focus[1]);
    smlua_push_number_field(2, "z", focus[2]);

    return 1;
}

int smlua_func_shake_camera_roll(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 * roll = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    shake_camera_roll(roll);

    return 1;
}

int smlua_func_shake_camera_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* focus = smlua_get_vec3f_from_buffer();
    focus[0] = smlua_get_number_field(2, "x");
    focus[1] = smlua_get_number_field(2, "y");
    focus[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    shake_camera_yaw(pos, focus);

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", focus[0]);
    smlua_push_number_field(2, "y", focus[1]);
    smlua_push_number_field(2, "z", focus[2]);

    return 1;
}

int smlua_func_soft_reset_camera(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    soft_reset_camera(c);

    return 1;
}

int smlua_func_start_cutscene(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 cutscene = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    start_cutscene(c, cutscene);

    return 1;
}

int smlua_func_start_object_cutscene_without_focus(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 cutscene = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, start_object_cutscene_without_focus(cutscene));

    return 1;
}

int smlua_func_transition_next_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Camera* c = (struct Camera*)smlua_to_cobject(L, 1, LOT_CAMERA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 frames = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    transition_next_state(c, frames);

    return 1;
}

int smlua_func_trigger_cutscene_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 trigger = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, trigger_cutscene_dialog(trigger));

    return 1;
}

int smlua_func_vec3f_sub(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(1, "x");
    dst[1] = smlua_get_number_field(1, "y");
    dst[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* src = smlua_get_vec3f_from_buffer();
    src[0] = smlua_get_number_field(2, "x");
    src[1] = smlua_get_number_field(2, "y");
    src[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    vec3f_sub(dst, src);

    smlua_push_number_field(1, "x", dst[0]);
    smlua_push_number_field(1, "y", dst[1]);
    smlua_push_number_field(1, "z", dst[2]);

    smlua_push_number_field(2, "x", src[0]);
    smlua_push_number_field(2, "y", src[1]);
    smlua_push_number_field(2, "z", src[2]);

    return 1;
}

int smlua_func_vec3f_to_object_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* src = smlua_get_vec3f_from_buffer();
    src[0] = smlua_get_number_field(2, "x");
    src[1] = smlua_get_number_field(2, "y");
    src[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    vec3f_to_object_pos(o, src);

    smlua_push_number_field(2, "x", src[0]);
    smlua_push_number_field(2, "y", src[1]);
    smlua_push_number_field(2, "z", src[2]);

    return 1;
}

int smlua_func_warp_camera(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 displacementX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 displacementY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 displacementZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    warp_camera(displacementX, displacementY, displacementZ);

    return 1;
}

  //////////////////
 // characters.h //
//////////////////

int smlua_func_get_character(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_CHARACTER, get_character(m));

    return 1;
}

int smlua_func_get_character_anim_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, get_character_anim_offset(m));

    return 1;
}

int smlua_func_play_character_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int characterSound = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_character_sound(m, characterSound);

    return 1;
}

int smlua_func_play_character_sound_if_no_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int characterSound = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 flags = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_character_sound_if_no_flag(m, characterSound, flags);

    return 1;
}

int smlua_func_play_character_sound_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int characterSound = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 offset = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_character_sound_offset(m, characterSound, offset);

    return 1;
}

int smlua_func_update_character_anim_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    update_character_anim_offset(m);

    return 1;
}

  /////////////////////////
 // djui_chat_message.h //
/////////////////////////

int smlua_func_djui_chat_message_create(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* message = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    djui_chat_message_create(message);

    return 1;
}

  //////////////////////
 // djui_hud_utils.h //
//////////////////////

int smlua_func_djui_hud_get_mouse_x(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushnumber(L, djui_hud_get_mouse_x());

    return 1;
}

int smlua_func_djui_hud_get_mouse_y(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushnumber(L, djui_hud_get_mouse_y());

    return 1;
}

int smlua_func_djui_hud_get_raw_mouse_x(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushnumber(L, djui_hud_get_raw_mouse_x());

    return 1;
}

int smlua_func_djui_hud_get_raw_mouse_y(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushnumber(L, djui_hud_get_raw_mouse_y());

    return 1;
}

int smlua_func_djui_hud_get_screen_height(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, djui_hud_get_screen_height());

    return 1;
}

int smlua_func_djui_hud_get_screen_width(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, djui_hud_get_screen_width());

    return 1;
}

int smlua_func_djui_hud_measure_text(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* message = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, djui_hud_measure_text(message));

    return 1;
}

int smlua_func_djui_hud_print_text(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    const char* message = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    float x = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    float y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    float scale = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    djui_hud_print_text(message, x, y, scale);

    return 1;
}

int smlua_func_djui_hud_render_rect(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 width = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 height = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    djui_hud_render_rect(x, y, width, height);

    return 1;
}

int smlua_func_djui_hud_render_rect_interpolated(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 8)) { return 0; }

    f32 prevX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 prevY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 prevWidth = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 prevHeight = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 x = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 y = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    f32 width = smlua_to_number(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }
    f32 height = smlua_to_number(L, 8);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 8"); return 0; }

    djui_hud_render_rect_interpolated(prevX, prevY, prevWidth, prevHeight, x, y, width, height);

    return 1;
}

int smlua_func_djui_hud_set_color(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    u8 r = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 g = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 b = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u8 a = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    djui_hud_set_color(r, g, b, a);

    return 1;
}

int smlua_func_djui_hud_set_font(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int fontType = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    djui_hud_set_font(fontType);

    return 1;
}

int smlua_func_djui_hud_set_mouse_locked(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    bool locked = smlua_to_boolean(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    djui_hud_set_mouse_locked(locked);

    return 1;
}

int smlua_func_djui_hud_set_resolution(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int resolutionType = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    djui_hud_set_resolution(resolutionType);

    return 1;
}

int smlua_func_djui_hud_world_pos_to_screen_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* out = smlua_get_vec3f_from_buffer();
    out[0] = smlua_get_number_field(2, "x");
    out[1] = smlua_get_number_field(2, "y");
    out[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    djui_hud_world_pos_to_screen_pos(pos, out);

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    smlua_push_number_field(2, "x", out[0]);
    smlua_push_number_field(2, "y", out[1]);
    smlua_push_number_field(2, "z", out[2]);

    return 1;
}

  //////////////////
 // djui_popup.h //
//////////////////

int smlua_func_djui_popup_create(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    const char* message = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int lines = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    djui_popup_create(message, lines);

    return 1;
}

  ////////////////
 // external.h //
////////////////

int smlua_func_fade_volume_scale(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u8 player = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 targetScale = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u16 fadeDuration = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    fade_volume_scale(player, targetScale, fadeDuration);

    return 1;
}

int smlua_func_fadeout_background_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u16 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 fadeOut = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    fadeout_background_music(arg0, fadeOut);

    return 1;
}

int smlua_func_get_current_background_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_current_background_music());

    return 1;
}

int smlua_func_get_current_background_music_default_volume(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_current_background_music_default_volume());

    return 1;
}

int smlua_func_get_current_background_music_max_target_volume(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_current_background_music_max_target_volume());

    return 1;
}

int smlua_func_get_current_background_music_target_volume(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_current_background_music_target_volume());

    return 1;
}

int smlua_func_is_current_background_music_volume_lowered(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, is_current_background_music_volume_lowered());

    return 1;
}

int smlua_func_play_course_clear(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_course_clear();

    return 1;
}

int smlua_func_play_dialog_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 dialogID = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_dialog_sound(dialogID);

    return 1;
}

int smlua_func_play_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u8 player = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 seqArgs = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u16 fadeTimer = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_music(player, seqArgs, fadeTimer);

    return 1;
}

int smlua_func_play_peachs_jingle(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_peachs_jingle();

    return 1;
}

int smlua_func_play_power_star_jingle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_power_star_jingle(arg0);

    return 1;
}

int smlua_func_play_puzzle_jingle(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_puzzle_jingle();

    return 1;
}

int smlua_func_play_race_fanfare(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_race_fanfare();

    return 1;
}

int smlua_func_play_secondary_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    u8 seqId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 bgMusicVolume = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 volume = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u16 fadeTimer = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    play_secondary_music(seqId, bgMusicVolume, volume, fadeTimer);

    return 1;
}

int smlua_func_play_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 soundBits = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(2, "x");
    pos[1] = smlua_get_number_field(2, "y");
    pos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_sound(soundBits, pos);

    smlua_push_number_field(2, "x", pos[0]);
    smlua_push_number_field(2, "y", pos[1]);
    smlua_push_number_field(2, "z", pos[2]);

    return 1;
}

int smlua_func_play_sound_with_freq_scale(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 soundBits = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(2, "x");
    pos[1] = smlua_get_number_field(2, "y");
    pos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 freqScale = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_sound_with_freq_scale(soundBits, pos, freqScale);

    smlua_push_number_field(2, "x", pos[0]);
    smlua_push_number_field(2, "y", pos[1]);
    smlua_push_number_field(2, "z", pos[2]);

    return 1;
}

int smlua_func_play_star_fanfare(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_star_fanfare();

    return 1;
}

int smlua_func_play_toads_jingle(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_toads_jingle();

    return 1;
}

int smlua_func_seq_player_fade_out(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u8 player = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 fadeDuration = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    seq_player_fade_out(player, fadeDuration);

    return 1;
}

int smlua_func_seq_player_lower_volume(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u8 player = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 fadeDuration = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 percentage = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    seq_player_lower_volume(player, fadeDuration, percentage);

    return 1;
}

int smlua_func_seq_player_unlower_volume(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u8 player = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 fadeDuration = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    seq_player_unlower_volume(player, fadeDuration);

    return 1;
}

  ///////////////////
 // interaction.h //
///////////////////

int smlua_func_does_mario_have_normal_cap_on_head(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, does_mario_have_normal_cap_on_head(m));

    return 1;
}

int smlua_func_get_door_save_file_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* door = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_door_save_file_flag(door));

    return 1;
}

int smlua_func_interact_damage(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 interactType = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 3, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, interact_damage(m, interactType, o));

    return 1;
}

int smlua_func_mario_blow_off_cap(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 capSpeed = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    mario_blow_off_cap(m, capSpeed);

    return 1;
}

int smlua_func_mario_check_object_grab(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_check_object_grab(m));

    return 1;
}

int smlua_func_mario_drop_held_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_drop_held_object(m);

    return 1;
}

int smlua_func_mario_get_collided_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 interactType = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    smlua_push_object(L, LOT_OBJECT, mario_get_collided_object(m, interactType));

    return 1;
}

int smlua_func_mario_grab_used_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_grab_used_object(m);

    return 1;
}

int smlua_func_mario_lose_cap_to_enemy(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 arg = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, mario_lose_cap_to_enemy(m, arg));

    return 1;
}

int smlua_func_mario_obj_angle_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, mario_obj_angle_to_object(m, o));

    return 1;
}

int smlua_func_mario_retrieve_cap(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_retrieve_cap(m);

    return 1;
}

int smlua_func_mario_stop_riding_and_holding(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_stop_riding_and_holding(m);

    return 1;
}

int smlua_func_mario_stop_riding_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_stop_riding_object(m);

    return 1;
}

int smlua_func_mario_throw_held_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_throw_held_object(m);

    return 1;
}

int smlua_func_passes_pvp_interaction_checks(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* attacker = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct MarioState* victim = (struct MarioState*)smlua_to_cobject(L, 2, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, passes_pvp_interaction_checks(attacker, victim));

    return 1;
}

int smlua_func_take_damage_and_knock_back(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, take_damage_and_knock_back(m, o));

    return 1;
}

  //////////////////
 // level_info.h //
//////////////////

int smlua_func_get_level_name(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 levelNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 areaIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushstring(L, get_level_name(courseNum, levelNum, areaIndex));

    return 1;
}

int smlua_func_get_level_name_ascii(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 levelNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 areaIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 charCase = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushstring(L, get_level_name_ascii(courseNum, levelNum, areaIndex, charCase));

    return 1;
}

int smlua_func_get_level_name_sm64(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 levelNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 areaIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 charCase = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    smlua_push_pointer(L, LVT_U8_P, (void*)get_level_name_sm64(courseNum, levelNum, areaIndex, charCase));

    return 1;
}

int smlua_func_get_star_name(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 starNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushstring(L, get_star_name(courseNum, starNum));

    return 1;
}

int smlua_func_get_star_name_ascii(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 starNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 charCase = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushstring(L, get_star_name_ascii(courseNum, starNum, charCase));

    return 1;
}

int smlua_func_get_star_name_sm64(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 starNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 charCase = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_pointer(L, LVT_U8_P, (void*)get_star_name_sm64(courseNum, starNum, charCase));

    return 1;
}

  /////////////
 // mario.h //
/////////////

int smlua_func_adjust_sound_for_speed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    adjust_sound_for_speed(m);

    return 1;
}

int smlua_func_check_common_action_exits(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, check_common_action_exits(m));

    return 1;
}

int smlua_func_check_common_hold_action_exits(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, check_common_hold_action_exits(m));

    return 1;
}

int smlua_func_drop_and_set_mario_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 actionArg = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, drop_and_set_mario_action(m, action, actionArg));

    return 1;
}

int smlua_func_execute_mario_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, execute_mario_action(o));

    return 1;
}

int smlua_func_find_floor_height_relative_polar(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 angleFromMario = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 distFromMario = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, find_floor_height_relative_polar(m, angleFromMario, distFromMario));

    return 1;
}

int smlua_func_find_floor_slope(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 yawOffset = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, find_floor_slope(m, yawOffset));

    return 1;
}

int smlua_func_find_mario_anim_flags_and_translation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 yaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    s16* translation = smlua_get_vec3s_from_buffer();
    translation[0] = smlua_get_integer_field(3, "x");
    translation[1] = smlua_get_integer_field(3, "y");
    translation[2] = smlua_get_integer_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, find_mario_anim_flags_and_translation(o, yaw, translation));

    smlua_push_integer_field(3, "x", translation[0]);
    smlua_push_integer_field(3, "y", translation[1]);
    smlua_push_integer_field(3, "z", translation[2]);

    return 1;
}

int smlua_func_force_idle_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, force_idle_state(m));

    return 1;
}

int smlua_func_hurt_and_set_mario_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 actionArg = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 hurtCounter = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushinteger(L, hurt_and_set_mario_action(m, action, actionArg, hurtCounter));

    return 1;
}

int smlua_func_init_single_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    init_single_mario(m);

    return 1;
}

int smlua_func_is_anim_at_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, is_anim_at_end(m));

    return 1;
}

int smlua_func_is_anim_past_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, is_anim_past_end(m));

    return 1;
}

int smlua_func_is_anim_past_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 animFrame = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, is_anim_past_frame(m, animFrame));

    return 1;
}

int smlua_func_mario_can_bubble(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushboolean(L, mario_can_bubble(m));

    return 1;
}

int smlua_func_mario_facing_downhill(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 turnYaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, mario_facing_downhill(m, turnYaw));

    return 1;
}

int smlua_func_mario_floor_is_slippery(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_floor_is_slippery(m));

    return 1;
}

int smlua_func_mario_floor_is_slope(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_floor_is_slope(m));

    return 1;
}

int smlua_func_mario_floor_is_steep(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_floor_is_steep(m));

    return 1;
}

int smlua_func_mario_get_floor_class(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_get_floor_class(m));

    return 1;
}

int smlua_func_mario_get_terrain_sound_addend(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_get_terrain_sound_addend(m));

    return 1;
}

int smlua_func_mario_set_bubbled(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    mario_set_bubbled(m);

    return 1;
}

int smlua_func_mario_set_forward_vel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 speed = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    mario_set_forward_vel(m, speed);

    return 1;
}

int smlua_func_play_mario_action_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 waveParticleType = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_mario_action_sound(m, soundBits, waveParticleType);

    return 1;
}

int smlua_func_play_mario_heavy_landing_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_mario_heavy_landing_sound(m, soundBits);

    return 1;
}

int smlua_func_play_mario_heavy_landing_sound_once(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_mario_heavy_landing_sound_once(m, soundBits);

    return 1;
}

int smlua_func_play_mario_jump_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_mario_jump_sound(m);

    return 1;
}

int smlua_func_play_mario_landing_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_mario_landing_sound(m, soundBits);

    return 1;
}

int smlua_func_play_mario_landing_sound_once(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    play_mario_landing_sound_once(m, soundBits);

    return 1;
}

int smlua_func_play_mario_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 primarySoundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 scondarySoundBits = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_mario_sound(m, primarySoundBits, scondarySoundBits);

    return 1;
}

int smlua_func_play_sound_and_spawn_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 waveParticleType = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_sound_and_spawn_particles(m, soundBits, waveParticleType);

    return 1;
}

int smlua_func_play_sound_if_no_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 soundBits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 flags = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    play_sound_if_no_flag(m, soundBits, flags);

    return 1;
}

int smlua_func_resolve_and_return_wall_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 offset = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 radius = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_SURFACE, resolve_and_return_wall_collisions(pos, offset, radius));

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    return 1;
}

int smlua_func_return_mario_anim_y_translation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, return_mario_anim_y_translation(m));

    return 1;
}

int smlua_func_set_anim_to_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 animFrame = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    set_anim_to_frame(m, animFrame);

    return 1;
}

int smlua_func_set_jump_from_landing(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, set_jump_from_landing(m));

    return 1;
}

int smlua_func_set_jumping_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 actionArg = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, set_jumping_action(m, action, actionArg));

    return 1;
}

int smlua_func_set_mario_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 actionArg = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, set_mario_action(m, action, actionArg));

    return 1;
}

int smlua_func_set_mario_anim_with_accel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 targetAnimID = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 accel = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, set_mario_anim_with_accel(m, targetAnimID, accel));

    return 1;
}

int smlua_func_set_mario_animation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 targetAnimID = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, set_mario_animation(m, targetAnimID));

    return 1;
}

int smlua_func_set_mario_particle_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 flags = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 clear = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_mario_particle_flags(m, flags, clear);

    return 1;
}

int smlua_func_set_mario_y_vel_based_on_fspeed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 initialVelY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 multiplier = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_mario_y_vel_based_on_fspeed(m, initialVelY, multiplier);

    return 1;
}

int smlua_func_set_steep_jump_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_steep_jump_action(m);

    return 1;
}

int smlua_func_set_water_plunge_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, set_water_plunge_action(m));

    return 1;
}

int smlua_func_transition_submerged_to_walking(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, transition_submerged_to_walking(m));

    return 1;
}

int smlua_func_update_mario_pos_for_anim(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    update_mario_pos_for_anim(m);

    return 1;
}

int smlua_func_update_mario_sound_and_camera(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    update_mario_sound_and_camera(m);

    return 1;
}

/*
int smlua_func_vec3f_find_ceil(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }


    f32* pos = smlua_get_vec3f_from_buffer();
    pos[0] = smlua_get_number_field(1, "x");
    pos[1] = smlua_get_number_field(1, "y");
    pos[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 height = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  struct Surface** ceil = (struct Surface**)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, vec3f_find_ceil(pos, height, ceil));

    smlua_push_number_field(1, "x", pos[0]);
    smlua_push_number_field(1, "y", pos[1]);
    smlua_push_number_field(1, "z", pos[2]);

    return 1;
}
*/

  //////////////////////////////
 // mario_actions_airborne.c //
//////////////////////////////

int smlua_func_check_common_airborne_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_airborne_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_airborne_cancels(m));

    return 1;
}

int smlua_func_check_fall_damage(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 hardFallAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 check_fall_damage(struct MarioState *m, u32 hardFallAction);
    lua_pushinteger(L, check_fall_damage(m, hardFallAction));

    return 1;
}

int smlua_func_check_fall_damage_or_get_stuck(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 hardFallAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 check_fall_damage_or_get_stuck(struct MarioState *m, u32 hardFallAction);
    lua_pushinteger(L, check_fall_damage_or_get_stuck(m, hardFallAction));

    return 1;
}

int smlua_func_check_horizontal_wind(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_horizontal_wind(struct MarioState *m);
    lua_pushinteger(L, check_horizontal_wind(m));

    return 1;
}

int smlua_func_check_kick_or_dive_in_air(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_kick_or_dive_in_air(struct MarioState *m);
    lua_pushinteger(L, check_kick_or_dive_in_air(m));

    return 1;
}

int smlua_func_check_wall_kick(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_wall_kick(struct MarioState *m);
    lua_pushinteger(L, check_wall_kick(m));

    return 1;
}

int smlua_func_common_air_action_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 landAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 animation = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 stepArg = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern u32 common_air_action_step(struct MarioState *m, u32 landAction, s32 animation, u32 stepArg);
    lua_pushinteger(L, common_air_action_step(m, landAction, animation, stepArg));

    return 1;
}

int smlua_func_common_air_knockback_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 landAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 hardFallAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 animation = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 speed = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern u32 common_air_knockback_step(struct MarioState *m, u32 landAction, u32 hardFallAction, s32 animation, f32 speed);
    lua_pushinteger(L, common_air_knockback_step(m, landAction, hardFallAction, animation, speed));

    return 1;
}

int smlua_func_lava_boost_on_wall(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 lava_boost_on_wall(struct MarioState *m);
    lua_pushinteger(L, lava_boost_on_wall(m));

    return 1;
}

int smlua_func_mario_execute_airborne_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_airborne_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_airborne_action(m));

    return 1;
}

int smlua_func_play_far_fall_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void play_far_fall_sound(struct MarioState *m);
    play_far_fall_sound(m);

    return 1;
}

int smlua_func_play_flip_sounds(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 frame1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 frame2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 frame3 = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void play_flip_sounds(struct MarioState *m, s16 frame1, s16 frame2, s16 frame3);
    play_flip_sounds(m, frame1, frame2, frame3);

    return 1;
}

int smlua_func_play_knockback_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void play_knockback_sound(struct MarioState *m);
    play_knockback_sound(m);

    return 1;
}

int smlua_func_should_get_stuck_in_ground(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 should_get_stuck_in_ground(struct MarioState *m);
    lua_pushinteger(L, should_get_stuck_in_ground(m));

    return 1;
}

int smlua_func_update_air_with_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_air_with_turn(struct MarioState *m);
    update_air_with_turn(m);

    return 1;
}

int smlua_func_update_air_without_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_air_without_turn(struct MarioState *m);
    update_air_without_turn(m);

    return 1;
}

int smlua_func_update_flying(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_flying(struct MarioState *m);
    update_flying(m);

    return 1;
}

int smlua_func_update_flying_pitch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_flying_pitch(struct MarioState *m);
    update_flying_pitch(m);

    return 1;
}

int smlua_func_update_flying_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_flying_yaw(struct MarioState *m);
    update_flying_yaw(m);

    return 1;
}

int smlua_func_update_lava_boost_or_twirling(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_lava_boost_or_twirling(struct MarioState *m);
    update_lava_boost_or_twirling(m);

    return 1;
}

  ///////////////////////////////
 // mario_actions_automatic.c //
///////////////////////////////

int smlua_func_add_tree_leaf_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void add_tree_leaf_particles(struct MarioState *m);
    add_tree_leaf_particles(m);

    return 1;
}

int smlua_func_check_common_automatic_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_automatic_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_automatic_cancels(m));

    return 1;
}

int smlua_func_climb_up_ledge(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void climb_up_ledge(struct MarioState *m);
    climb_up_ledge(m);

    return 1;
}

int smlua_func_let_go_of_ledge(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 let_go_of_ledge(struct MarioState *m);
    lua_pushinteger(L, let_go_of_ledge(m));

    return 1;
}

int smlua_func_mario_execute_automatic_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_automatic_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_automatic_action(m));

    return 1;
}

int smlua_func_perform_hanging_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* nextPos = smlua_get_vec3f_from_buffer();
    nextPos[0] = smlua_get_number_field(2, "x");
    nextPos[1] = smlua_get_number_field(2, "y");
    nextPos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 perform_hanging_step(struct MarioState *m, Vec3f nextPos);
    lua_pushinteger(L, perform_hanging_step(m, nextPos));

    smlua_push_number_field(2, "x", nextPos[0]);
    smlua_push_number_field(2, "y", nextPos[1]);
    smlua_push_number_field(2, "z", nextPos[2]);

    return 1;
}

int smlua_func_play_climbing_sounds(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 b = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void play_climbing_sounds(struct MarioState *m, s32 b);
    play_climbing_sounds(m, b);

    return 1;
}

int smlua_func_set_pole_position(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 offsetY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 set_pole_position(struct MarioState *m, f32 offsetY);
    lua_pushinteger(L, set_pole_position(m, offsetY));

    return 1;
}

int smlua_func_update_hang_moving(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 update_hang_moving(struct MarioState *m);
    lua_pushinteger(L, update_hang_moving(m));

    return 1;
}

int smlua_func_update_hang_stationary(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_hang_stationary(struct MarioState *m);
    update_hang_stationary(m);

    return 1;
}

int smlua_func_update_ledge_climb(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 endAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void update_ledge_climb(struct MarioState *m, s32 animation, u32 endAction);
    update_ledge_climb(m, animation, endAction);

    return 1;
}

int smlua_func_update_ledge_climb_camera(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_ledge_climb_camera(struct MarioState *m);
    update_ledge_climb_camera(m);

    return 1;
}

  //////////////////////////////
 // mario_actions_cutscene.c //
//////////////////////////////

int smlua_func_bhv_end_peach_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void bhv_end_peach_loop(void);
    bhv_end_peach_loop();

    return 1;
}

int smlua_func_bhv_end_toad_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void bhv_end_toad_loop(void);
    bhv_end_toad_loop();

    return 1;
}

int smlua_func_common_death_handler(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 frameToDeathWarp = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 common_death_handler(struct MarioState *m, s32 animation, s32 frameToDeathWarp);
    lua_pushinteger(L, common_death_handler(m, animation, frameToDeathWarp));

    return 1;
}

int smlua_func_cutscene_put_cap_on(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cutscene_put_cap_on(struct MarioState *m);
    cutscene_put_cap_on(m);

    return 1;
}

int smlua_func_cutscene_take_cap_off(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cutscene_take_cap_off(struct MarioState *m);
    cutscene_take_cap_off(m);

    return 1;
}

int smlua_func_general_star_dance_handler(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 isInWater = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void general_star_dance_handler(struct MarioState *m, s32 isInWater);
    general_star_dance_handler(m, isInWater);

    return 1;
}

int smlua_func_generate_yellow_sparkles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 x = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 y = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 z = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 radius = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void generate_yellow_sparkles(s16 x, s16 y, s16 z, f32 radius);
    generate_yellow_sparkles(x, y, z, radius);

    return 1;
}

/*
int smlua_func_get_credits_str_width(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

//  char * str = (char *)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 get_credits_str_width(char *str);
    lua_pushinteger(L, get_credits_str_width(str));

    return 1;
}
*/

int smlua_func_get_star_collection_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 get_star_collection_dialog(struct MarioState *m);
    lua_pushinteger(L, get_star_collection_dialog(m));

    return 1;
}

int smlua_func_handle_save_menu(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void handle_save_menu(struct MarioState *m);
    handle_save_menu(m);

    return 1;
}

int smlua_func_launch_mario_until_land(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 endAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 animation = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 forwardVel = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 launch_mario_until_land(struct MarioState *m, s32 endAction, s32 animation, f32 forwardVel);
    lua_pushinteger(L, launch_mario_until_land(m, endAction, animation, forwardVel));

    return 1;
}

int smlua_func_mario_execute_cutscene_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_cutscene_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_cutscene_action(m));

    return 1;
}

int smlua_func_mario_ready_to_speak(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_ready_to_speak(struct MarioState* m);
    lua_pushinteger(L, mario_ready_to_speak(m));

    return 1;
}

int smlua_func_print_displaying_credits_entry(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void print_displaying_credits_entry(void);
    print_displaying_credits_entry();

    return 1;
}

int smlua_func_should_start_or_continue_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* object = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern u8 should_start_or_continue_dialog(struct MarioState* m, struct Object* object);
    lua_pushinteger(L, should_start_or_continue_dialog(m, object));

    return 1;
}

int smlua_func_stuck_in_ground_handler(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 unstuckFrame = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 target2 = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 target3 = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    s32 endAction = smlua_to_integer(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    extern void stuck_in_ground_handler(struct MarioState *m, s32 animation, s32 unstuckFrame, s32 target2, s32 target3, s32 endAction);
    stuck_in_ground_handler(m, animation, unstuckFrame, target2, target3, endAction);

    return 1;
}

  ////////////////////////////
 // mario_actions_moving.c //
////////////////////////////

int smlua_func_align_with_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void align_with_floor(struct MarioState *m);
    align_with_floor(m);

    return 1;
}

int smlua_func_analog_stick_held_back(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 analog_stick_held_back(struct MarioState *m);
    lua_pushinteger(L, analog_stick_held_back(m));

    return 1;
}

int smlua_func_anim_and_audio_for_heavy_walk(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void anim_and_audio_for_heavy_walk(struct MarioState *m);
    anim_and_audio_for_heavy_walk(m);

    return 1;
}

int smlua_func_anim_and_audio_for_hold_walk(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void anim_and_audio_for_hold_walk(struct MarioState *m);
    anim_and_audio_for_hold_walk(m);

    return 1;
}

int smlua_func_anim_and_audio_for_walk(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void anim_and_audio_for_walk(struct MarioState *m);
    anim_and_audio_for_walk(m);

    return 1;
}

int smlua_func_apply_landing_accel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 frictionFactor = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 apply_landing_accel(struct MarioState *m, f32 frictionFactor);
    lua_pushinteger(L, apply_landing_accel(m, frictionFactor));

    return 1;
}

int smlua_func_apply_slope_accel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void apply_slope_accel(struct MarioState *m);
    apply_slope_accel(m);

    return 1;
}

int smlua_func_apply_slope_decel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 decelCoef = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 apply_slope_decel(struct MarioState *m, f32 decelCoef);
    lua_pushinteger(L, apply_slope_decel(m, decelCoef));

    return 1;
}

int smlua_func_begin_braking_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 begin_braking_action(struct MarioState *m);
    lua_pushinteger(L, begin_braking_action(m));

    return 1;
}

int smlua_func_begin_walking_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 forwardVel = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 action = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 actionArg = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 begin_walking_action(struct MarioState *m, f32 forwardVel, u32 action, u32 actionArg);
    lua_pushinteger(L, begin_walking_action(m, forwardVel, action, actionArg));

    return 1;
}

int smlua_func_check_common_moving_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_moving_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_moving_cancels(m));

    return 1;
}

int smlua_func_check_ground_dive_or_punch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_ground_dive_or_punch(struct MarioState *m);
    lua_pushinteger(L, check_ground_dive_or_punch(m));

    return 1;
}

int smlua_func_check_ledge_climb_down(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void check_ledge_climb_down(struct MarioState *m);
    check_ledge_climb_down(m);

    return 1;
}

int smlua_func_common_ground_knockback_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 arg2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 arg3 = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 arg4 = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s32 common_ground_knockback_action(struct MarioState *m, s32 animation, s32 arg2, s32 arg3, s32 arg4);
    lua_pushinteger(L, common_ground_knockback_action(m, animation, arg2, arg3, arg4));

    return 1;
}

int smlua_func_common_landing_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 airAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern u32 common_landing_action(struct MarioState *m, s16 animation, u32 airAction);
    lua_pushinteger(L, common_landing_action(m, animation, airAction));

    return 1;
}

/*
int smlua_func_common_landing_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct LandingAction* landingAction = (struct LandingAction*)smlua_to_cobject(L, 2, LOT_LANDINGACTION);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  s32 (*setAPressAction)(structMarioState* arg2 = (s32 (*setAPressAction)(structMarioState*)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 arg3 = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
//  u32) arg4 = (u32))smlua_to_cobject(L, 5, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s32 common_landing_cancels(struct MarioState *m, struct LandingAction *landingAction, s32 (*setAPressAction)(struct MarioState *, u32, u32));
    lua_pushinteger(L, common_landing_cancels(m, landingAction, arg2, arg3, arg4));

    return 1;
}
*/

int smlua_func_common_slide_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 endAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 airAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 animation = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void common_slide_action(struct MarioState *m, u32 endAction, u32 airAction, s32 animation);
    common_slide_action(m, endAction, airAction, animation);

    return 1;
}

int smlua_func_common_slide_action_with_jump(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 stopAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 jumpAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 airAction = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 animation = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s32 common_slide_action_with_jump(struct MarioState *m, u32 stopAction, u32 jumpAction, u32 airAction, s32 animation);
    lua_pushinteger(L, common_slide_action_with_jump(m, stopAction, jumpAction, airAction, animation));

    return 1;
}

int smlua_func_mario_execute_moving_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_moving_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_moving_action(m));

    return 1;
}

int smlua_func_play_step_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 frame1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 frame2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void play_step_sound(struct MarioState *m, s16 frame1, s16 frame2);
    play_step_sound(m, frame1, frame2);

    return 1;
}

int smlua_func_push_or_sidle_wall(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* startPos = smlua_get_vec3f_from_buffer();
    startPos[0] = smlua_get_number_field(2, "x");
    startPos[1] = smlua_get_number_field(2, "y");
    startPos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void push_or_sidle_wall(struct MarioState *m, Vec3f startPos);
    push_or_sidle_wall(m, startPos);

    smlua_push_number_field(2, "x", startPos[0]);
    smlua_push_number_field(2, "y", startPos[1]);
    smlua_push_number_field(2, "z", startPos[2]);

    return 1;
}

int smlua_func_quicksand_jump_land_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 animation2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 endAction = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    u32 airAction = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s32 quicksand_jump_land_action(struct MarioState *m, s32 animation1, s32 animation2, u32 endAction, u32 airAction);
    lua_pushinteger(L, quicksand_jump_land_action(m, animation1, animation2, endAction, airAction));

    return 1;
}

int smlua_func_set_triple_jump_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 actionArg = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 set_triple_jump_action(struct MarioState *m, UNUSED u32 action, UNUSED u32 actionArg);
    lua_pushinteger(L, set_triple_jump_action(m, action, actionArg));

    return 1;
}

int smlua_func_should_begin_sliding(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 should_begin_sliding(struct MarioState *m);
    lua_pushinteger(L, should_begin_sliding(m));

    return 1;
}

int smlua_func_slide_bonk(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 fastAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 slowAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void slide_bonk(struct MarioState *m, u32 fastAction, u32 slowAction);
    slide_bonk(m, fastAction, slowAction);

    return 1;
}

int smlua_func_stomach_slide_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 stopAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 airAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 animation = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 stomach_slide_action(struct MarioState *m, u32 stopAction, u32 airAction, s32 animation);
    lua_pushinteger(L, stomach_slide_action(m, stopAction, airAction, animation));

    return 1;
}

int smlua_func_tilt_body_butt_slide(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void tilt_body_butt_slide(struct MarioState *m);
    tilt_body_butt_slide(m);

    return 1;
}

int smlua_func_tilt_body_ground_shell(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 startYaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void tilt_body_ground_shell(struct MarioState *m, s16 startYaw);
    tilt_body_ground_shell(m, startYaw);

    return 1;
}

int smlua_func_tilt_body_running(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s16 tilt_body_running(struct MarioState *m);
    lua_pushinteger(L, tilt_body_running(m));

    return 1;
}

int smlua_func_tilt_body_walking(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 startYaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void tilt_body_walking(struct MarioState *m, s16 startYaw);
    tilt_body_walking(m, startYaw);

    return 1;
}

int smlua_func_update_decelerating_speed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 update_decelerating_speed(struct MarioState *m);
    lua_pushinteger(L, update_decelerating_speed(m));

    return 1;
}

int smlua_func_update_shell_speed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_shell_speed(struct MarioState *m);
    update_shell_speed(m);

    return 1;
}

int smlua_func_update_sliding(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 stopSpeed = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 update_sliding(struct MarioState *m, f32 stopSpeed);
    lua_pushinteger(L, update_sliding(m, stopSpeed));

    return 1;
}

int smlua_func_update_sliding_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 accel = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 lossFactor = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void update_sliding_angle(struct MarioState *m, f32 accel, f32 lossFactor);
    update_sliding_angle(m, accel, lossFactor);

    return 1;
}

int smlua_func_update_walking_speed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void update_walking_speed(struct MarioState *m);
    update_walking_speed(m);

    return 1;
}

  ////////////////////////////
 // mario_actions_object.c //
////////////////////////////

int smlua_func_animated_stationary_ground_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animation = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 endAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void animated_stationary_ground_step(struct MarioState *m, s32 animation, u32 endAction);
    animated_stationary_ground_step(m, animation, endAction);

    return 1;
}

int smlua_func_check_common_object_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_object_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_object_cancels(m));

    return 1;
}

int smlua_func_mario_execute_object_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_object_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_object_action(m));

    return 1;
}

int smlua_func_mario_update_punch_sequence(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_update_punch_sequence(struct MarioState *m);
    lua_pushinteger(L, mario_update_punch_sequence(m));

    return 1;
}

  ////////////////////////////////
 // mario_actions_stationary.c //
////////////////////////////////

int smlua_func_check_common_hold_idle_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_hold_idle_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_hold_idle_cancels(m));

    return 1;
}

int smlua_func_check_common_idle_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_idle_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_idle_cancels(m));

    return 1;
}

int smlua_func_check_common_landing_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 action = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 check_common_landing_cancels(struct MarioState *m, u32 action);
    lua_pushinteger(L, check_common_landing_cancels(m, action));

    return 1;
}

int smlua_func_check_common_stationary_cancels(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 check_common_stationary_cancels(struct MarioState *m);
    lua_pushinteger(L, check_common_stationary_cancels(m));

    return 1;
}

int smlua_func_landing_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 action = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 landing_step(struct MarioState *m, s32 arg1, u32 action);
    lua_pushinteger(L, landing_step(m, arg1, action));

    return 1;
}

int smlua_func_mario_execute_stationary_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_stationary_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_stationary_action(m));

    return 1;
}

int smlua_func_play_anim_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 actionState = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 animFrame = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u32 sound = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void play_anim_sound(struct MarioState *m, u32 actionState, s32 animFrame, u32 sound);
    play_anim_sound(m, actionState, animFrame, sound);

    return 1;
}

int smlua_func_stopping_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animID = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 action = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void stopping_step(struct MarioState *m, s32 animID, u32 action);
    stopping_step(m, animID, action);

    return 1;
}

  ///////////////////////////////
 // mario_actions_submerged.c //
///////////////////////////////

int smlua_func_apply_water_current(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* step = smlua_get_vec3f_from_buffer();
    step[0] = smlua_get_number_field(2, "x");
    step[1] = smlua_get_number_field(2, "y");
    step[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void apply_water_current(struct MarioState *m, Vec3f step);
    apply_water_current(m, step);

    smlua_push_number_field(2, "x", step[0]);
    smlua_push_number_field(2, "y", step[1]);
    smlua_push_number_field(2, "z", step[2]);

    return 1;
}

int smlua_func_float_surface_gfx(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void float_surface_gfx(struct MarioState *m);
    float_surface_gfx(m);

    return 1;
}

int smlua_func_mario_execute_submerged_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_execute_submerged_action(struct MarioState *m);
    lua_pushinteger(L, mario_execute_submerged_action(m));

    return 1;
}

int smlua_func_perform_water_full_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* nextPos = smlua_get_vec3f_from_buffer();
    nextPos[0] = smlua_get_number_field(2, "x");
    nextPos[1] = smlua_get_number_field(2, "y");
    nextPos[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern u32 perform_water_full_step(struct MarioState *m, Vec3f nextPos);
    lua_pushinteger(L, perform_water_full_step(m, nextPos));

    smlua_push_number_field(2, "x", nextPos[0]);
    smlua_push_number_field(2, "y", nextPos[1]);
    smlua_push_number_field(2, "z", nextPos[2]);

    return 1;
}

int smlua_func_perform_water_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern u32 perform_water_step(struct MarioState *m);
    lua_pushinteger(L, perform_water_step(m));

    return 1;
}

int smlua_func_set_swimming_at_surface_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 particleFlag = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void set_swimming_at_surface_particles(struct MarioState *m, u32 particleFlag);
    set_swimming_at_surface_particles(m, particleFlag);

    return 1;
}

  //////////////////
 // mario_misc.h //
//////////////////

int smlua_func_bhv_toad_message_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_toad_message_init();

    return 1;
}

int smlua_func_bhv_toad_message_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_toad_message_loop();

    return 1;
}

int smlua_func_bhv_unlock_door_star_init(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unlock_door_star_init();

    return 1;
}

int smlua_func_bhv_unlock_door_star_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    bhv_unlock_door_star_loop();

    return 1;
}

  //////////////////
 // mario_step.h //
//////////////////

int smlua_func_get_additive_y_vel_for_jumps(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushnumber(L, get_additive_y_vel_for_jumps());

    return 1;
}

int smlua_func_init_bully_collision_data(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 7)) { return 0; }

    struct BullyCollisionData* data = (struct BullyCollisionData*)smlua_to_cobject(L, 1, LOT_BULLYCOLLISIONDATA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 posX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 posZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 forwardVel = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 yaw = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 conversionRatio = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    f32 radius = smlua_to_number(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }

    init_bully_collision_data(data, posX, posZ, forwardVel, yaw, conversionRatio, radius);

    return 1;
}

int smlua_func_mario_bonk_reflection(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    mario_bonk_reflection(arg0, arg1);

    return 1;
}

int smlua_func_mario_push_off_steep_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 arg2 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, mario_push_off_steep_floor(arg0, arg1, arg2));

    return 1;
}

int smlua_func_mario_update_moving_sand(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_update_moving_sand(arg0));

    return 1;
}

int smlua_func_mario_update_quicksand(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 arg1 = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, mario_update_quicksand(arg0, arg1));

    return 1;
}

int smlua_func_mario_update_windy_ground(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, mario_update_windy_ground(arg0));

    return 1;
}

int smlua_func_perform_air_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, perform_air_step(arg0, arg1));

    return 1;
}

int smlua_func_perform_ground_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, perform_ground_step(arg0));

    return 1;
}

int smlua_func_set_vel_from_pitch_and_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_vel_from_pitch_and_yaw(m);

    return 1;
}

int smlua_func_stationary_ground_step(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, stationary_ground_step(arg0));

    return 1;
}

int smlua_func_stop_and_set_height_to_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* arg0 = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    stop_and_set_height_to_floor(arg0);

    return 1;
}

  //////////////////////
 // network_player.h //
//////////////////////

int smlua_func_get_network_player_from_area(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 actNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 levelNum = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 areaIndex = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    smlua_push_object(L, LOT_NETWORKPLAYER, get_network_player_from_area(courseNum, actNum, levelNum, areaIndex));

    return 1;
}

int smlua_func_get_network_player_from_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 actNum = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 levelNum = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_NETWORKPLAYER, get_network_player_from_level(courseNum, actNum, levelNum));

    return 1;
}

int smlua_func_get_network_player_smallest_global(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    smlua_push_object(L, LOT_NETWORKPLAYER, get_network_player_smallest_global());

    return 1;
}

int smlua_func_network_player_connected_count(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, network_player_connected_count());

    return 1;
}

int smlua_func_network_player_from_global_index(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 globalIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_NETWORKPLAYER, network_player_from_global_index(globalIndex));

    return 1;
}

int smlua_func_network_player_set_description(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    struct NetworkPlayer* np = (struct NetworkPlayer*)smlua_to_cobject(L, 1, LOT_NETWORKPLAYER);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const char* description = smlua_to_string(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 r = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u8 g = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    u8 b = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    u8 a = smlua_to_integer(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    network_player_set_description(np, description, r, g, b, a);

    return 1;
}

  /////////////////////
 // network_utils.h //
/////////////////////

int smlua_func_network_get_player_text_color_string(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 localIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushstring(L, network_get_player_text_color_string(localIndex));

    return 1;
}

int smlua_func_network_global_index_from_local(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 localIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, network_global_index_from_local(localIndex));

    return 1;
}

int smlua_func_network_is_server(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushboolean(L, network_is_server());

    return 1;
}

int smlua_func_network_local_index_from_global(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 globalIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, network_local_index_from_global(globalIndex));

    return 1;
}

  /////////////////////
 // obj_behaviors.c //
/////////////////////

int smlua_func_absf_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 f = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern f32 absf_2(f32 f);
    lua_pushnumber(L, absf_2(f));

    return 1;
}

int smlua_func_calc_new_obj_vel_and_pos_y(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Surface* objFloor = (struct Surface*)smlua_to_cobject(L, 1, LOT_SURFACE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 objFloorY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 objVelX = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 objVelZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void calc_new_obj_vel_and_pos_y(struct Surface *objFloor, f32 objFloorY, f32 objVelX, f32 objVelZ);
    calc_new_obj_vel_and_pos_y(objFloor, objFloorY, objVelX, objVelZ);

    return 1;
}

int smlua_func_calc_new_obj_vel_and_pos_y_underwater(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct Surface* objFloor = (struct Surface*)smlua_to_cobject(L, 1, LOT_SURFACE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 floorY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 objVelX = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 objVelZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 waterY = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern void calc_new_obj_vel_and_pos_y_underwater(struct Surface *objFloor, f32 floorY, f32 objVelX, f32 objVelZ, f32 waterY);
    calc_new_obj_vel_and_pos_y_underwater(objFloor, floorY, objVelX, objVelZ, waterY);

    return 1;
}

int smlua_func_calc_obj_friction(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 * objFriction = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 floor_nY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void calc_obj_friction(f32 *objFriction, f32 floor_nY);
    calc_obj_friction(objFriction, floor_nY);

    return 1;
}

int smlua_func_current_mario_room_check(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 room = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s8 current_mario_room_check(s16 room);
    lua_pushinteger(L, current_mario_room_check(room));

    return 1;
}

/*
int smlua_func_geo_obj_transparency_something(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 * mtx = (Mat4 *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern Gfx UNUSED *geo_obj_transparency_something(s32 callContext, struct GraphNode *node, UNUSED Mat4 *mtx);
    UNIMPLEMENTED -->(L, geo_obj_transparency_something(callContext, node, mtx));

    return 1;
}
*/

int smlua_func_is_nearest_mario_state_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern u8 is_nearest_mario_state_to_object(struct MarioState *m, struct Object *obj);
    lua_pushinteger(L, is_nearest_mario_state_to_object(m, obj));

    return 1;
}

int smlua_func_is_nearest_player_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* m = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern u8 is_nearest_player_to_object(struct Object *m, struct Object *obj);
    lua_pushinteger(L, is_nearest_player_to_object(m, obj));

    return 1;
}

int smlua_func_is_other_player_active(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern u8 is_other_player_active(void);
    lua_pushinteger(L, is_other_player_active());

    return 1;
}

int smlua_func_is_player_active(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern u8 is_player_active(struct MarioState* m);
    lua_pushinteger(L, is_player_active(m));

    return 1;
}

int smlua_func_is_player_in_local_area(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern u8 is_player_in_local_area(struct MarioState* m);
    lua_pushinteger(L, is_player_in_local_area(m));

    return 1;
}

int smlua_func_is_point_close_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 x = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 z = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 dist = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s8 is_point_close_to_object(struct Object *obj, f32 x, f32 y, f32 z, s32 dist);
    lua_pushinteger(L, is_point_close_to_object(obj, x, y, z, dist));

    return 1;
}

int smlua_func_is_point_within_radius_of_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 dist = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s8 is_point_within_radius_of_mario(f32 x, f32 y, f32 z, s32 dist);
    lua_pushinteger(L, is_point_within_radius_of_mario(x, y, z, dist));

    return 1;
}

int smlua_func_nearest_interacting_mario_state_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct MarioState *nearest_interacting_mario_state_to_object(struct Object *obj);
    smlua_push_object(L, LOT_MARIOSTATE, nearest_interacting_mario_state_to_object(obj));

    return 1;
}

int smlua_func_nearest_interacting_player_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct Object *nearest_interacting_player_to_object(struct Object *obj);
    smlua_push_object(L, LOT_OBJECT, nearest_interacting_player_to_object(obj));

    return 1;
}

int smlua_func_nearest_mario_state_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct MarioState* nearest_mario_state_to_object(struct Object *obj);
    smlua_push_object(L, LOT_MARIOSTATE, nearest_mario_state_to_object(obj));

    return 1;
}

int smlua_func_nearest_player_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct Object* nearest_player_to_object(struct Object *obj);
    smlua_push_object(L, LOT_OBJECT, nearest_player_to_object(obj));

    return 1;
}

int smlua_func_obj_check_floor_death(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 collisionFlags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Surface* floor = (struct Surface*)smlua_to_cobject(L, 2, LOT_SURFACE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_check_floor_death(s16 collisionFlags, struct Surface *floor);
    obj_check_floor_death(collisionFlags, floor);

    return 1;
}

int smlua_func_obj_check_if_facing_toward_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u32 base = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 goal = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 range = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s8 obj_check_if_facing_toward_angle(u32 base, u32 goal, s16 range);
    lua_pushinteger(L, obj_check_if_facing_toward_angle(base, goal, range));

    return 1;
}

int smlua_func_obj_find_wall(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    f32 objNewX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 objY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 objNewZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 objVelX = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 objVelZ = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s8 obj_find_wall(f32 objNewX, f32 objY, f32 objNewZ, f32 objVelX, f32 objVelZ);
    lua_pushinteger(L, obj_find_wall(objNewX, objY, objNewZ, objVelX, objVelZ));

    return 1;
}

int smlua_func_obj_find_wall_displacement(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }


    f32* dist = smlua_get_vec3f_from_buffer();
    dist[0] = smlua_get_number_field(1, "x");
    dist[1] = smlua_get_number_field(1, "y");
    dist[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 x = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 z = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 radius = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s8 obj_find_wall_displacement(Vec3f dist, f32 x, f32 y, f32 z, f32 radius);
    lua_pushinteger(L, obj_find_wall_displacement(dist, x, y, z, radius));

    smlua_push_number_field(1, "x", dist[0]);
    smlua_push_number_field(1, "y", dist[1]);
    smlua_push_number_field(1, "z", dist[2]);

    return 1;
}

int smlua_func_obj_flicker_and_disappear(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 lifeSpan = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s8 obj_flicker_and_disappear(struct Object *obj, s16 lifeSpan);
    lua_pushinteger(L, obj_flicker_and_disappear(obj, lifeSpan));

    return 1;
}

int smlua_func_obj_lava_death(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s8 obj_lava_death(void);
    lua_pushinteger(L, obj_lava_death());

    return 1;
}

int smlua_func_obj_move_xyz_using_fvel_and_yaw(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_move_xyz_using_fvel_and_yaw(struct Object *obj);
    obj_move_xyz_using_fvel_and_yaw(obj);

    return 1;
}

int smlua_func_obj_orient_graph(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 normalX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 normalY = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 normalZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_orient_graph(struct Object *obj, f32 normalX, f32 normalY, f32 normalZ);
    obj_orient_graph(obj, normalX, normalY, normalZ);

    return 1;
}

int smlua_func_obj_return_and_displace_home(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 homeX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 homeY = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 homeZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 baseDisp = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern void obj_return_and_displace_home(struct Object *obj, f32 homeX, UNUSED f32 homeY, f32 homeZ, s32 baseDisp);
    obj_return_and_displace_home(obj, homeX, homeY, homeZ, baseDisp);

    return 1;
}

int smlua_func_obj_return_home_if_safe(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 homeX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 homeZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 dist = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern s8 obj_return_home_if_safe(struct Object *obj, f32 homeX, f32 y, f32 homeZ, s32 dist);
    lua_pushinteger(L, obj_return_home_if_safe(obj, homeX, y, homeZ, dist));

    return 1;
}

int smlua_func_obj_spawn_yellow_coins(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s8 nCoins = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_spawn_yellow_coins(struct Object *obj, s8 nCoins);
    obj_spawn_yellow_coins(obj, nCoins);

    return 1;
}

int smlua_func_obj_splash(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 waterY = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 objY = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_splash(s32 waterY, s32 objY);
    obj_splash(waterY, objY);

    return 1;
}

int smlua_func_obj_update_pos_vel_xz(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void obj_update_pos_vel_xz(void);
    obj_update_pos_vel_xz();

    return 1;
}

int smlua_func_object_step(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s16 object_step(void);
    lua_pushinteger(L, object_step());

    return 1;
}

int smlua_func_object_step_without_floor_orient(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s16 object_step_without_floor_orient(void);
    lua_pushinteger(L, object_step_without_floor_orient());

    return 1;
}

int smlua_func_set_object_visibility(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 dist = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void set_object_visibility(struct Object *obj, s32 dist);
    set_object_visibility(obj, dist);

    return 1;
}

int smlua_func_set_yoshi_as_not_dead(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void set_yoshi_as_not_dead(void);
    set_yoshi_as_not_dead();

    return 1;
}

int smlua_func_spawn_orange_number(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s8 behParam = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 relX = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 relY = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 relZ = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void spawn_orange_number(s8 behParam, s16 relX, s16 relY, s16 relZ);
    spawn_orange_number(behParam, relX, relY, relZ);

    return 1;
}

int smlua_func_turn_obj_away_from_steep_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Surface* objFloor = (struct Surface*)smlua_to_cobject(L, 1, LOT_SURFACE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 floorY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 objVelX = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 objVelZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s8 turn_obj_away_from_steep_floor(struct Surface *objFloor, f32 floorY, f32 objVelX, f32 objVelZ);
    lua_pushinteger(L, turn_obj_away_from_steep_floor(objFloor, floorY, objVelX, objVelZ));

    return 1;
}

int smlua_func_turn_obj_away_from_surface(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 7)) { return 0; }

    f32 velX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 velZ = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 nX = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 nY = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 nZ = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 * objYawX = (f32 *)smlua_to_cpointer(L, 6, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    f32 * objYawZ = (f32 *)smlua_to_cpointer(L, 7, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }

    extern void turn_obj_away_from_surface(f32 velX, f32 velZ, f32 nX, UNUSED f32 nY, f32 nZ, f32 *objYawX, f32 *objYawZ);
    turn_obj_away_from_surface(velX, velZ, nX, nY, nZ, objYawX, objYawZ);

    return 1;
}

  ///////////////////////
 // obj_behaviors_2.c //
///////////////////////

int smlua_func_approach_f32_ptr(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * px = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 delta = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 approach_f32_ptr(f32 *px, f32 target, f32 delta);
    lua_pushinteger(L, approach_f32_ptr(px, target, delta));

    return 1;
}

int smlua_func_cur_obj_init_anim_and_check_if_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_init_anim_and_check_if_end(s32 arg0);
    lua_pushinteger(L, cur_obj_init_anim_and_check_if_end(arg0));

    return 1;
}

int smlua_func_cur_obj_init_anim_check_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_init_anim_check_frame(s32 arg0, s32 arg1);
    lua_pushinteger(L, cur_obj_init_anim_check_frame(arg0, arg1));

    return 1;
}

int smlua_func_cur_obj_init_anim_extend(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_init_anim_extend(s32 arg0);
    cur_obj_init_anim_extend(arg0);

    return 1;
}

int smlua_func_cur_obj_play_sound_at_anim_range(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s8 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s8 arg1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u32 sound = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 cur_obj_play_sound_at_anim_range(s8 arg0, s8 arg1, u32 sound);
    lua_pushinteger(L, cur_obj_play_sound_at_anim_range(arg0, arg1, sound));

    return 1;
}

int smlua_func_cur_obj_set_anim_if_at_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 arg0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_set_anim_if_at_end(s32 arg0);
    lua_pushinteger(L, cur_obj_set_anim_if_at_end(arg0));

    return 1;
}

int smlua_func_cur_obj_spin_all_dimensions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 arg0 = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 arg1 = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_spin_all_dimensions(f32 arg0, f32 arg1);
    cur_obj_spin_all_dimensions(arg0, arg1);

    return 1;
}

int smlua_func_obj_act_knockback(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 baseScale = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_act_knockback(UNUSED f32 baseScale);
    obj_act_knockback(baseScale);

    return 1;
}

int smlua_func_obj_act_squished(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 baseScale = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_act_squished(f32 baseScale);
    obj_act_squished(baseScale);

    return 1;
}

int smlua_func_obj_bounce_off_walls_edges_objects(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 * targetYaw = (s32 *)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_bounce_off_walls_edges_objects(s32 *targetYaw);
    lua_pushinteger(L, obj_bounce_off_walls_edges_objects(targetYaw));

    return 1;
}

int smlua_func_obj_check_attacks(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct ObjectHitbox* hitbox = (struct ObjectHitbox*)smlua_to_cobject(L, 1, LOT_OBJECTHITBOX);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 attackedMarioAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_check_attacks(struct ObjectHitbox *hitbox, s32 attackedMarioAction);
    lua_pushinteger(L, obj_check_attacks(hitbox, attackedMarioAction));

    return 1;
}

int smlua_func_obj_compute_vel_from_move_pitch(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 speed = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_compute_vel_from_move_pitch(f32 speed);
    obj_compute_vel_from_move_pitch(speed);

    return 1;
}

int smlua_func_obj_die_if_above_lava_and_health_non_positive(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 obj_die_if_above_lava_and_health_non_positive(void);
    lua_pushinteger(L, obj_die_if_above_lava_and_health_non_positive());

    return 1;
}

int smlua_func_obj_die_if_health_non_positive(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void obj_die_if_health_non_positive(void);
    obj_die_if_health_non_positive();

    return 1;
}

int smlua_func_obj_face_pitch_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 targetPitch = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 deltaPitch = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_face_pitch_approach(s16 targetPitch, s16 deltaPitch);
    lua_pushinteger(L, obj_face_pitch_approach(targetPitch, deltaPitch));

    return 1;
}

int smlua_func_obj_face_roll_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 targetRoll = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 deltaRoll = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_face_roll_approach(s16 targetRoll, s16 deltaRoll);
    lua_pushinteger(L, obj_face_roll_approach(targetRoll, deltaRoll));

    return 1;
}

int smlua_func_obj_face_yaw_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 targetYaw = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 deltaYaw = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_face_yaw_approach(s16 targetYaw, s16 deltaYaw);
    lua_pushinteger(L, obj_face_yaw_approach(targetYaw, deltaYaw));

    return 1;
}

int smlua_func_obj_forward_vel_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 target = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 delta = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_forward_vel_approach(f32 target, f32 delta);
    lua_pushinteger(L, obj_forward_vel_approach(target, delta));

    return 1;
}

int smlua_func_obj_get_pitch_from_vel(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s16 obj_get_pitch_from_vel(void);
    lua_pushinteger(L, obj_get_pitch_from_vel());

    return 1;
}

int smlua_func_obj_get_pitch_to_home(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 latDistToHome = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s16 obj_get_pitch_to_home(f32 latDistToHome);
    lua_pushinteger(L, obj_get_pitch_to_home(latDistToHome));

    return 1;
}

int smlua_func_obj_grow_then_shrink(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * scaleVel = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 shootFireScale = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 endScale = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 obj_grow_then_shrink(f32 *scaleVel, f32 shootFireScale, f32 endScale);
    lua_pushinteger(L, obj_grow_then_shrink(scaleVel, shootFireScale, endScale));

    return 1;
}

int smlua_func_obj_handle_attacks(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct ObjectHitbox* hitbox = (struct ObjectHitbox*)smlua_to_cobject(L, 1, LOT_OBJECTHITBOX);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 attackedMarioAction = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 * attackHandlers = (u8 *)smlua_to_cpointer(L, 3, LVT_U8_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 obj_handle_attacks(struct ObjectHitbox *hitbox, s32 attackedMarioAction, u8 *attackHandlers);
    lua_pushinteger(L, obj_handle_attacks(hitbox, attackedMarioAction, attackHandlers));

    return 1;
}

int smlua_func_obj_is_near_to_and_facing_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 maxDist = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 maxAngleDiff = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 obj_is_near_to_and_facing_mario(struct MarioState* m, f32 maxDist, s16 maxAngleDiff);
    lua_pushinteger(L, obj_is_near_to_and_facing_mario(m, maxDist, maxAngleDiff));

    return 1;
}

int smlua_func_obj_is_rendering_enabled(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 obj_is_rendering_enabled(void);
    lua_pushinteger(L, obj_is_rendering_enabled());

    return 1;
}

int smlua_func_obj_move_for_one_second(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 endAction = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_move_for_one_second(s32 endAction);
    lua_pushinteger(L, obj_move_for_one_second(endAction));

    return 1;
}

int smlua_func_obj_move_pitch_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 target = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 delta = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_move_pitch_approach(s16 target, s16 delta);
    lua_pushinteger(L, obj_move_pitch_approach(target, delta));

    return 1;
}

int smlua_func_obj_random_fixed_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 delta = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s16 obj_random_fixed_turn(s16 delta);
    lua_pushinteger(L, obj_random_fixed_turn(delta));

    return 1;
}

int smlua_func_obj_resolve_collisions_and_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 targetYaw = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 turnSpeed = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_resolve_collisions_and_turn(s16 targetYaw, s16 turnSpeed);
    lua_pushinteger(L, obj_resolve_collisions_and_turn(targetYaw, turnSpeed));

    return 1;
}

int smlua_func_obj_resolve_object_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 * targetYaw = (s32 *)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_resolve_object_collisions(s32 *targetYaw);
    lua_pushinteger(L, obj_resolve_object_collisions(targetYaw));

    return 1;
}

int smlua_func_obj_roll_to_match_yaw_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 targetYaw = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 maxRoll = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 rollSpeed = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_roll_to_match_yaw_turn(s16 targetYaw, s16 maxRoll, s16 rollSpeed);
    obj_roll_to_match_yaw_turn(targetYaw, maxRoll, rollSpeed);

    return 1;
}

int smlua_func_obj_rotate_yaw_and_bounce_off_walls(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 targetYaw = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 turnAmount = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_rotate_yaw_and_bounce_off_walls(s16 targetYaw, s16 turnAmount);
    obj_rotate_yaw_and_bounce_off_walls(targetYaw, turnAmount);

    return 1;
}

int smlua_func_obj_set_dist_from_home(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 distFromHome = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_dist_from_home(f32 distFromHome);
    obj_set_dist_from_home(distFromHome);

    return 1;
}

int smlua_func_obj_set_knockback_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 attackType = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_knockback_action(s32 attackType);
    obj_set_knockback_action(attackType);

    return 1;
}

int smlua_func_obj_set_squished_action(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void obj_set_squished_action(void);
    obj_set_squished_action();

    return 1;
}

int smlua_func_obj_smooth_turn(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 7)) { return 0; }

    s16 * angleVel = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 * angle = (s32 *)smlua_to_cpointer(L, 2, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 targetAngle = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 targetSpeedProportion = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 accel = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    s16 minSpeed = smlua_to_integer(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    s16 maxSpeed = smlua_to_integer(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }

    extern s32 obj_smooth_turn(s16 *angleVel, s32 *angle, s16 targetAngle, f32 targetSpeedProportion, s16 accel, s16 minSpeed, s16 maxSpeed);
    lua_pushinteger(L, obj_smooth_turn(angleVel, angle, targetAngle, targetSpeedProportion, accel, minSpeed, maxSpeed));

    return 1;
}

int smlua_func_obj_spit_fire(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 8)) { return 0; }

    s16 relativePosX = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 relativePosY = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 relativePosZ = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 scale = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s32 model = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 startSpeed = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    f32 endSpeed = smlua_to_number(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }
    s16 movePitch = smlua_to_integer(L, 8);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 8"); return 0; }

    extern struct Object* obj_spit_fire(s16 relativePosX, s16 relativePosY, s16 relativePosZ, f32 scale, s32 model, f32 startSpeed, f32 endSpeed, s16 movePitch);
    smlua_push_object(L, LOT_OBJECT, obj_spit_fire(relativePosX, relativePosY, relativePosZ, scale, model, startSpeed, endSpeed, movePitch));

    return 1;
}

int smlua_func_obj_turn_pitch_toward_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 targetOffsetY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 turnAmount = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s16 obj_turn_pitch_toward_mario(struct MarioState* m, f32 targetOffsetY, s16 turnAmount);
    lua_pushinteger(L, obj_turn_pitch_toward_mario(m, targetOffsetY, turnAmount));

    return 1;
}

int smlua_func_obj_unused_die(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void obj_unused_die(void);
    obj_unused_die();

    return 1;
}

int smlua_func_obj_update_blinking(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s32 * blinkTimer = (s32 *)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 baseCycleLength = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 cycleLengthRange = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 blinkLength = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_update_blinking(s32 *blinkTimer, s16 baseCycleLength, s16 cycleLengthRange, s16 blinkLength);
    obj_update_blinking(blinkTimer, baseCycleLength, cycleLengthRange, blinkLength);

    return 1;
}

int smlua_func_obj_update_standard_actions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 scale = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_update_standard_actions(f32 scale);
    lua_pushinteger(L, obj_update_standard_actions(scale));

    return 1;
}

int smlua_func_obj_y_vel_approach(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 target = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 delta = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_y_vel_approach(f32 target, f32 delta);
    lua_pushinteger(L, obj_y_vel_approach(target, delta));

    return 1;
}

int smlua_func_oscillate_toward(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    s32 * value = (s32 *)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 * vel = (f32 *)smlua_to_cpointer(L, 2, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 target = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 velCloseToZero = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 accel = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 slowdown = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    extern s32 oscillate_toward(s32 *value, f32 *vel, s32 target, f32 velCloseToZero, f32 accel, f32 slowdown);
    lua_pushinteger(L, oscillate_toward(value, vel, target, velCloseToZero, accel, slowdown));

    return 1;
}

int smlua_func_platform_on_track_update_pos_or_spawn_ball(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s32 ballIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 x = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 z = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void platform_on_track_update_pos_or_spawn_ball(s32 ballIndex, f32 x, f32 y, f32 z);
    platform_on_track_update_pos_or_spawn_ball(ballIndex, x, y, z);

    return 1;
}

int smlua_func_random_linear_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 base = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 range = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s16 random_linear_offset(s16 base, s16 range);
    lua_pushinteger(L, random_linear_offset(base, range));

    return 1;
}

int smlua_func_random_mod_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 base = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 step = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 mod = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s16 random_mod_offset(s16 base, s16 step, s16 mod);
    lua_pushinteger(L, random_mod_offset(base, step, mod));

    return 1;
}

int smlua_func_treat_far_home_as_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 threshold = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32* distanceToPlayer = (s32*)smlua_to_cpointer(L, 2, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32* angleToPlayer = (s32*)smlua_to_cpointer(L, 3, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void treat_far_home_as_mario(f32 threshold, s32* distanceToPlayer, s32* angleToPlayer);
    treat_far_home_as_mario(threshold, distanceToPlayer, angleToPlayer);

    return 1;
}

  //////////////////////
 // object_helpers.c //
//////////////////////

int smlua_func_abs_angle_diff(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 x0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 x1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s16 abs_angle_diff(s16 x0, s16 x1);
    lua_pushinteger(L, abs_angle_diff(x0, x1));

    return 1;
}

int smlua_func_apply_drag_to_value(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 * value = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 dragStrength = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void apply_drag_to_value(f32 *value, f32 dragStrength);
    apply_drag_to_value(value, dragStrength);

    return 1;
}

int smlua_func_approach_f32_signed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 * value = (f32 *)smlua_to_cpointer(L, 1, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 increment = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 approach_f32_signed(f32 *value, f32 target, f32 increment);
    lua_pushinteger(L, approach_f32_signed(value, target, increment));

    return 1;
}

int smlua_func_approach_f32_symmetric(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 value = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 target = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 increment = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern f32 approach_f32_symmetric(f32 value, f32 target, f32 increment);
    lua_pushnumber(L, approach_f32_symmetric(value, target, increment));

    return 1;
}

int smlua_func_approach_s16_symmetric(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s16 value = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 target = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 increment = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s16 approach_s16_symmetric(s16 value, s16 target, s16 increment);
    lua_pushinteger(L, approach_s16_symmetric(value, target, increment));

    return 1;
}

int smlua_func_bhv_dust_smoke_loop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void bhv_dust_smoke_loop(void);
    bhv_dust_smoke_loop();

    return 1;
}

int smlua_func_bhv_init_room(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void bhv_init_room(void);
    bhv_init_room();

    return 1;
}

int smlua_func_bit_shift_left(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 a0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 bit_shift_left(s32 a0);
    lua_pushinteger(L, bit_shift_left(a0));

    return 1;
}

int smlua_func_chain_segment_init(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct ChainSegment* segment = (struct ChainSegment*)smlua_to_cobject(L, 1, LOT_CHAINSEGMENT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void chain_segment_init(struct ChainSegment *segment);
    chain_segment_init(segment);

    return 1;
}

int smlua_func_clear_move_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u32 * bitSet = (u32 *)smlua_to_cpointer(L, 1, LVT_U32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 flag = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 clear_move_flag(u32 *bitSet, s32 flag);
    lua_pushinteger(L, clear_move_flag(bitSet, flag));

    return 1;
}

int smlua_func_clear_time_stop_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void clear_time_stop_flags(s32 flags);
    clear_time_stop_flags(flags);

    return 1;
}

int smlua_func_count_objects_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 count_objects_with_behavior(const BehaviorScript *behavior);
    lua_pushinteger(L, count_objects_with_behavior(behavior));

    return 1;
}

int smlua_func_count_unimportant_objects(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 count_unimportant_objects(void);
    lua_pushinteger(L, count_unimportant_objects());

    return 1;
}

/*
int smlua_func_create_transformation_from_matrices(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

//  Mat4 a0 = (Mat4)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
//  Mat4 a1 = (Mat4)smlua_to_cobject(L, 2, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 a2 = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void create_transformation_from_matrices(Mat4 a0, Mat4 a1, Mat4 a2);
    create_transformation_from_matrices(a0, a1, a2);

    return 1;
}
*/

int smlua_func_cur_obj_abs_y_dist_to_home(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern f32 cur_obj_abs_y_dist_to_home(void);
    lua_pushnumber(L, cur_obj_abs_y_dist_to_home());

    return 1;
}

int smlua_func_cur_obj_advance_looping_anim(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_advance_looping_anim(void);
    lua_pushinteger(L, cur_obj_advance_looping_anim());

    return 1;
}

int smlua_func_cur_obj_align_gfx_with_floor(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_align_gfx_with_floor(void);
    cur_obj_align_gfx_with_floor();

    return 1;
}

int smlua_func_cur_obj_angle_to_home(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s16 cur_obj_angle_to_home(void);
    lua_pushinteger(L, cur_obj_angle_to_home());

    return 1;
}

int smlua_func_cur_obj_apply_drag_xz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 dragStrength = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_apply_drag_xz(f32 dragStrength);
    cur_obj_apply_drag_xz(dragStrength);

    return 1;
}

int smlua_func_cur_obj_become_intangible(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_become_intangible(void);
    cur_obj_become_intangible();

    return 1;
}

int smlua_func_cur_obj_become_tangible(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_become_tangible(void);
    cur_obj_become_tangible();

    return 1;
}

int smlua_func_cur_obj_can_mario_activate_textbox(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 radius = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 height = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s32 unused = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 cur_obj_can_mario_activate_textbox(struct MarioState* m, f32 radius, f32 height, UNUSED s32 unused);
    lua_pushinteger(L, cur_obj_can_mario_activate_textbox(m, radius, height, unused));

    return 1;
}

int smlua_func_cur_obj_can_mario_activate_textbox_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 radius = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 height = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 cur_obj_can_mario_activate_textbox_2(struct MarioState* m, f32 radius, f32 height);
    lua_pushinteger(L, cur_obj_can_mario_activate_textbox_2(m, radius, height));

    return 1;
}

int smlua_func_cur_obj_change_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 action = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_change_action(s32 action);
    cur_obj_change_action(action);

    return 1;
}

int smlua_func_cur_obj_check_anim_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 frame = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_check_anim_frame(s32 frame);
    lua_pushinteger(L, cur_obj_check_anim_frame(frame));

    return 1;
}

int smlua_func_cur_obj_check_anim_frame_in_range(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 startFrame = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 rangeLength = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_check_anim_frame_in_range(s32 startFrame, s32 rangeLength);
    lua_pushinteger(L, cur_obj_check_anim_frame_in_range(startFrame, rangeLength));

    return 1;
}

int smlua_func_cur_obj_check_frame_prior_current_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 * a0 = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_check_frame_prior_current_frame(s16 *a0);
    lua_pushinteger(L, cur_obj_check_frame_prior_current_frame(a0));

    return 1;
}

int smlua_func_cur_obj_check_grabbed_mario(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_check_grabbed_mario(void);
    lua_pushinteger(L, cur_obj_check_grabbed_mario());

    return 1;
}

int smlua_func_cur_obj_check_if_at_animation_end(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_check_if_at_animation_end(void);
    lua_pushinteger(L, cur_obj_check_if_at_animation_end());

    return 1;
}

int smlua_func_cur_obj_check_if_near_animation_end(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_check_if_near_animation_end(void);
    lua_pushinteger(L, cur_obj_check_if_near_animation_end());

    return 1;
}

int smlua_func_cur_obj_check_interacted(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_check_interacted(void);
    lua_pushinteger(L, cur_obj_check_interacted());

    return 1;
}

int smlua_func_cur_obj_clear_interact_status_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 flag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_clear_interact_status_flag(s32 flag);
    lua_pushinteger(L, cur_obj_clear_interact_status_flag(flag));

    return 1;
}

int smlua_func_cur_obj_compute_vel_xz(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_compute_vel_xz(void);
    cur_obj_compute_vel_xz();

    return 1;
}

int smlua_func_cur_obj_count_objects_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 dist = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern u16 cur_obj_count_objects_with_behavior(const BehaviorScript* behavior, f32 dist);
    lua_pushinteger(L, cur_obj_count_objects_with_behavior(behavior, dist));

    return 1;
}

int smlua_func_cur_obj_detect_steep_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 steepAngleDegrees = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_detect_steep_floor(s16 steepAngleDegrees);
    lua_pushinteger(L, cur_obj_detect_steep_floor(steepAngleDegrees));

    return 1;
}

int smlua_func_cur_obj_disable(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_disable(void);
    cur_obj_disable();

    return 1;
}

int smlua_func_cur_obj_disable_rendering(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_disable_rendering(void);
    cur_obj_disable_rendering();

    return 1;
}

int smlua_func_cur_obj_disable_rendering_and_become_intangible(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_disable_rendering_and_become_intangible(struct Object *obj);
    cur_obj_disable_rendering_and_become_intangible(obj);

    return 1;
}

int smlua_func_cur_obj_dist_to_nearest_object_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern f32 cur_obj_dist_to_nearest_object_with_behavior(const BehaviorScript *behavior);
    lua_pushnumber(L, cur_obj_dist_to_nearest_object_with_behavior(behavior));

    return 1;
}

int smlua_func_cur_obj_enable_rendering(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_enable_rendering(void);
    cur_obj_enable_rendering();

    return 1;
}

int smlua_func_cur_obj_enable_rendering_2(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_enable_rendering_2(void);
    cur_obj_enable_rendering_2();

    return 1;
}

int smlua_func_cur_obj_enable_rendering_and_become_tangible(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_enable_rendering_and_become_tangible(struct Object *obj);
    cur_obj_enable_rendering_and_become_tangible(obj);

    return 1;
}

int smlua_func_cur_obj_enable_rendering_if_mario_in_room(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_enable_rendering_if_mario_in_room(void);
    cur_obj_enable_rendering_if_mario_in_room();

    return 1;
}

int smlua_func_cur_obj_end_dialog(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 dialogFlags = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 dialogResult = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_end_dialog(struct MarioState* m, s32 dialogFlags, s32 dialogResult);
    cur_obj_end_dialog(m, dialogFlags, dialogResult);

    return 1;
}

int smlua_func_cur_obj_extend_animation_if_at_end(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_extend_animation_if_at_end(void);
    cur_obj_extend_animation_if_at_end();

    return 1;
}

int smlua_func_cur_obj_find_nearby_held_actor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 maxDist = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern struct Object *cur_obj_find_nearby_held_actor(const BehaviorScript *behavior, f32 maxDist);
    smlua_push_object(L, LOT_OBJECT, cur_obj_find_nearby_held_actor(behavior, maxDist));

    return 1;
}

int smlua_func_cur_obj_find_nearest_object_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 * dist = (f32 *)smlua_to_cpointer(L, 2, LVT_F32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern struct Object *cur_obj_find_nearest_object_with_behavior(const BehaviorScript *behavior, f32 *dist);
    smlua_push_object(L, LOT_OBJECT, cur_obj_find_nearest_object_with_behavior(behavior, dist));

    return 1;
}

int smlua_func_cur_obj_find_nearest_pole(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern struct Object* cur_obj_find_nearest_pole(void);
    smlua_push_object(L, LOT_OBJECT, cur_obj_find_nearest_pole());

    return 1;
}

int smlua_func_cur_obj_follow_path(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 unusedArg = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_follow_path(UNUSED s32 unusedArg);
    lua_pushinteger(L, cur_obj_follow_path(unusedArg));

    return 1;
}

int smlua_func_cur_obj_forward_vel_approach_upward(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 target = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 increment = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_forward_vel_approach_upward(f32 target, f32 increment);
    cur_obj_forward_vel_approach_upward(target, increment);

    return 1;
}

int smlua_func_cur_obj_get_dropped(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_get_dropped(void);
    cur_obj_get_dropped();

    return 1;
}

int smlua_func_cur_obj_get_thrown_or_placed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 forwardVel = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 velY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 thrownAction = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_get_thrown_or_placed(f32 forwardVel, f32 velY, s32 thrownAction);
    cur_obj_get_thrown_or_placed(forwardVel, velY, thrownAction);

    return 1;
}

int smlua_func_cur_obj_has_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_has_behavior(const BehaviorScript *behavior);
    lua_pushinteger(L, cur_obj_has_behavior(behavior));

    return 1;
}

int smlua_func_cur_obj_has_model(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u16 modelID = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_has_model(u16 modelID);
    lua_pushinteger(L, cur_obj_has_model(modelID));

    return 1;
}

int smlua_func_cur_obj_hide(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_hide(void);
    cur_obj_hide();

    return 1;
}

int smlua_func_cur_obj_hide_if_mario_far_away_y(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 distY = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_hide_if_mario_far_away_y(f32 distY);
    lua_pushinteger(L, cur_obj_hide_if_mario_far_away_y(distY));

    return 1;
}

int smlua_func_cur_obj_if_hit_wall_bounce_away(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_if_hit_wall_bounce_away(void);
    cur_obj_if_hit_wall_bounce_away();

    return 1;
}

int smlua_func_cur_obj_init_animation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_init_animation(s32 animIndex);
    cur_obj_init_animation(animIndex);

    return 1;
}

int smlua_func_cur_obj_init_animation_and_anim_frame(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animFrame = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_init_animation_and_anim_frame(s32 animIndex, s32 animFrame);
    cur_obj_init_animation_and_anim_frame(animIndex, animFrame);

    return 1;
}

int smlua_func_cur_obj_init_animation_and_check_if_near_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_init_animation_and_check_if_near_end(s32 animIndex);
    lua_pushinteger(L, cur_obj_init_animation_and_check_if_near_end(animIndex));

    return 1;
}

int smlua_func_cur_obj_init_animation_and_extend_if_at_end(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_init_animation_and_extend_if_at_end(s32 animIndex);
    cur_obj_init_animation_and_extend_if_at_end(animIndex);

    return 1;
}

int smlua_func_cur_obj_init_animation_with_accel_and_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 accel = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_init_animation_with_accel_and_sound(s32 animIndex, f32 accel);
    cur_obj_init_animation_with_accel_and_sound(animIndex, accel);

    return 1;
}

int smlua_func_cur_obj_init_animation_with_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 animIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_init_animation_with_sound(s32 animIndex);
    cur_obj_init_animation_with_sound(animIndex);

    return 1;
}

int smlua_func_cur_obj_is_any_player_on_platform(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_is_any_player_on_platform(void);
    lua_pushinteger(L, cur_obj_is_any_player_on_platform());

    return 1;
}

int smlua_func_cur_obj_is_mario_ground_pounding_platform(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_is_mario_ground_pounding_platform(void);
    lua_pushinteger(L, cur_obj_is_mario_ground_pounding_platform());

    return 1;
}

int smlua_func_cur_obj_is_mario_on_platform(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_is_mario_on_platform(void);
    lua_pushinteger(L, cur_obj_is_mario_on_platform());

    return 1;
}

int smlua_func_cur_obj_lateral_dist_from_mario_to_home(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern f32 cur_obj_lateral_dist_from_mario_to_home(void);
    lua_pushnumber(L, cur_obj_lateral_dist_from_mario_to_home());

    return 1;
}

int smlua_func_cur_obj_lateral_dist_from_obj_to_home(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern f32 cur_obj_lateral_dist_from_obj_to_home(struct Object *obj);
    lua_pushnumber(L, cur_obj_lateral_dist_from_obj_to_home(obj));

    return 1;
}

int smlua_func_cur_obj_lateral_dist_to_home(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern f32 cur_obj_lateral_dist_to_home(void);
    lua_pushnumber(L, cur_obj_lateral_dist_to_home());

    return 1;
}

int smlua_func_cur_obj_mario_far_away(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_mario_far_away(void);
    lua_pushinteger(L, cur_obj_mario_far_away());

    return 1;
}

int smlua_func_cur_obj_move_after_thrown_or_dropped(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 forwardVel = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 velY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_move_after_thrown_or_dropped(f32 forwardVel, f32 velY);
    cur_obj_move_after_thrown_or_dropped(forwardVel, velY);

    return 1;
}

int smlua_func_cur_obj_move_standard(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 steepSlopeAngleDegrees = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_move_standard(s16 steepSlopeAngleDegrees);
    cur_obj_move_standard(steepSlopeAngleDegrees);

    return 1;
}

int smlua_func_cur_obj_move_up_and_down(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 a0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_move_up_and_down(s32 a0);
    lua_pushinteger(L, cur_obj_move_up_and_down(a0));

    return 1;
}

int smlua_func_cur_obj_move_update_ground_air_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 gravity = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 bounciness = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_move_update_ground_air_flags(UNUSED f32 gravity, f32 bounciness);
    cur_obj_move_update_ground_air_flags(gravity, bounciness);

    return 1;
}

int smlua_func_cur_obj_move_update_underwater_flags(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_update_underwater_flags(void);
    cur_obj_move_update_underwater_flags();

    return 1;
}

int smlua_func_cur_obj_move_using_fvel_and_gravity(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_using_fvel_and_gravity(void);
    cur_obj_move_using_fvel_and_gravity();

    return 1;
}

int smlua_func_cur_obj_move_using_vel(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_using_vel(void);
    cur_obj_move_using_vel();

    return 1;
}

int smlua_func_cur_obj_move_using_vel_and_gravity(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_using_vel_and_gravity(void);
    cur_obj_move_using_vel_and_gravity();

    return 1;
}

int smlua_func_cur_obj_move_xz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 steepSlopeNormalY = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 careAboutEdgesAndSteepSlopes = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_move_xz(f32 steepSlopeNormalY, s32 careAboutEdgesAndSteepSlopes);
    lua_pushinteger(L, cur_obj_move_xz(steepSlopeNormalY, careAboutEdgesAndSteepSlopes));

    return 1;
}

int smlua_func_cur_obj_move_xz_using_fvel_and_yaw(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_xz_using_fvel_and_yaw(void);
    cur_obj_move_xz_using_fvel_and_yaw();

    return 1;
}

int smlua_func_cur_obj_move_y(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 gravity = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 bounciness = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 buoyancy = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_move_y(f32 gravity, f32 bounciness, f32 buoyancy);
    cur_obj_move_y(gravity, bounciness, buoyancy);

    return 1;
}

int smlua_func_cur_obj_move_y_and_get_water_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 gravity = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 buoyancy = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern f32 cur_obj_move_y_and_get_water_level(f32 gravity, f32 buoyancy);
    lua_pushnumber(L, cur_obj_move_y_and_get_water_level(gravity, buoyancy));

    return 1;
}

int smlua_func_cur_obj_move_y_with_terminal_vel(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_move_y_with_terminal_vel(void);
    cur_obj_move_y_with_terminal_vel();

    return 1;
}

int smlua_func_cur_obj_nearest_object_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct Object *cur_obj_nearest_object_with_behavior(const BehaviorScript *behavior);
    smlua_push_object(L, LOT_OBJECT, cur_obj_nearest_object_with_behavior(behavior));

    return 1;
}

int smlua_func_cur_obj_outside_home_rectangle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 minX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 maxX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 minZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 maxZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 cur_obj_outside_home_rectangle(f32 minX, f32 maxX, f32 minZ, f32 maxZ);
    lua_pushinteger(L, cur_obj_outside_home_rectangle(minX, maxX, minZ, maxZ));

    return 1;
}

int smlua_func_cur_obj_outside_home_square(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 halfLength = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_outside_home_square(f32 halfLength);
    lua_pushinteger(L, cur_obj_outside_home_square(halfLength));

    return 1;
}

int smlua_func_cur_obj_progress_direction_table(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_progress_direction_table(void);
    lua_pushinteger(L, cur_obj_progress_direction_table());

    return 1;
}

int smlua_func_cur_obj_push_mario_away(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 radius = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_push_mario_away(f32 radius);
    cur_obj_push_mario_away(radius);

    return 1;
}

int smlua_func_cur_obj_push_mario_away_from_cylinder(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 radius = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 extentY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_push_mario_away_from_cylinder(f32 radius, f32 extentY);
    cur_obj_push_mario_away_from_cylinder(radius, extentY);

    return 1;
}

int smlua_func_cur_obj_reflect_move_angle_off_wall(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s16 cur_obj_reflect_move_angle_off_wall(void);
    lua_pushinteger(L, cur_obj_reflect_move_angle_off_wall());

    return 1;
}

int smlua_func_cur_obj_reset_timer_and_subaction(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_reset_timer_and_subaction(void);
    cur_obj_reset_timer_and_subaction();

    return 1;
}

int smlua_func_cur_obj_resolve_wall_collisions(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_resolve_wall_collisions(void);
    lua_pushinteger(L, cur_obj_resolve_wall_collisions());

    return 1;
}

int smlua_func_cur_obj_reverse_animation(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_reverse_animation(void);
    cur_obj_reverse_animation();

    return 1;
}

int smlua_func_cur_obj_rotate_face_angle_using_vel(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_rotate_face_angle_using_vel(void);
    cur_obj_rotate_face_angle_using_vel();

    return 1;
}

int smlua_func_cur_obj_rotate_move_angle_using_vel(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_rotate_move_angle_using_vel(void);
    cur_obj_rotate_move_angle_using_vel();

    return 1;
}

int smlua_func_cur_obj_rotate_yaw_toward(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 target = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 increment = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_rotate_yaw_toward(s16 target, s16 increment);
    lua_pushinteger(L, cur_obj_rotate_yaw_toward(target, increment));

    return 1;
}

int smlua_func_cur_obj_scale(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 scale = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_scale(f32 scale);
    cur_obj_scale(scale);

    return 1;
}

int smlua_func_cur_obj_scale_over_time(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s32 a0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 a1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 sp10 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 sp14 = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void cur_obj_scale_over_time(s32 a0, s32 a1, f32 sp10, f32 sp14);
    cur_obj_scale_over_time(a0, a1, sp10, sp14);

    return 1;
}

int smlua_func_cur_obj_set_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_set_behavior(const BehaviorScript *behavior);
    cur_obj_set_behavior(behavior);

    return 1;
}

int smlua_func_cur_obj_set_direction_table(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s8 * a0 = (s8 *)smlua_to_cpointer(L, 1, LVT_S8_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 cur_obj_set_direction_table(s8 *a0);
    lua_pushinteger(L, cur_obj_set_direction_table(a0));

    return 1;
}

int smlua_func_cur_obj_set_face_angle_to_move_angle(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_set_face_angle_to_move_angle(void);
    cur_obj_set_face_angle_to_move_angle();

    return 1;
}

int smlua_func_cur_obj_set_hitbox_and_die_if_attacked(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct ObjectHitbox* hitbox = (struct ObjectHitbox*)smlua_to_cobject(L, 1, LOT_OBJECTHITBOX);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 deathSound = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 noLootCoins = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 cur_obj_set_hitbox_and_die_if_attacked(struct ObjectHitbox *hitbox, s32 deathSound, s32 noLootCoins);
    lua_pushinteger(L, cur_obj_set_hitbox_and_die_if_attacked(hitbox, deathSound, noLootCoins));

    return 1;
}

int smlua_func_cur_obj_set_hitbox_radius_and_height(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 radius = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 height = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_set_hitbox_radius_and_height(f32 radius, f32 height);
    cur_obj_set_hitbox_radius_and_height(radius, height);

    return 1;
}

int smlua_func_cur_obj_set_hurtbox_radius_and_height(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 radius = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 height = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_set_hurtbox_radius_and_height(f32 radius, f32 height);
    cur_obj_set_hurtbox_radius_and_height(radius, height);

    return 1;
}

int smlua_func_cur_obj_set_pos_relative(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* other = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 dleft = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 dy = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 dforward = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void cur_obj_set_pos_relative(struct Object *other, f32 dleft, f32 dy, f32 dforward);
    cur_obj_set_pos_relative(other, dleft, dy, dforward);

    return 1;
}

int smlua_func_cur_obj_set_pos_relative_to_parent(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 dleft = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 dy = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 dforward = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_set_pos_relative_to_parent(f32 dleft, f32 dy, f32 dforward);
    cur_obj_set_pos_relative_to_parent(dleft, dy, dforward);

    return 1;
}

int smlua_func_cur_obj_set_pos_to_home(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_set_pos_to_home(void);
    cur_obj_set_pos_to_home();

    return 1;
}

int smlua_func_cur_obj_set_pos_to_home_and_stop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_set_pos_to_home_and_stop(void);
    cur_obj_set_pos_to_home_and_stop();

    return 1;
}

int smlua_func_cur_obj_set_pos_to_home_with_debug(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_set_pos_to_home_with_debug(void);
    cur_obj_set_pos_to_home_with_debug();

    return 1;
}

int smlua_func_cur_obj_set_pos_via_transform(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_set_pos_via_transform(void);
    cur_obj_set_pos_via_transform();

    return 1;
}

int smlua_func_cur_obj_set_vel_from_mario_vel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 f12 = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 f14 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_set_vel_from_mario_vel(struct MarioState* m, f32 f12, f32 f14);
    cur_obj_set_vel_from_mario_vel(m, f12, f14);

    return 1;
}

int smlua_func_cur_obj_set_y_vel_and_animation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 sp18 = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp1C = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_set_y_vel_and_animation(f32 sp18, s32 sp1C);
    cur_obj_set_y_vel_and_animation(sp18, sp1C);

    return 1;
}

int smlua_func_cur_obj_shake_screen(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 shake = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_shake_screen(s32 shake);
    cur_obj_shake_screen(shake);

    return 1;
}

int smlua_func_cur_obj_shake_y(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 amount = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_shake_y(f32 amount);
    cur_obj_shake_y(amount);

    return 1;
}

int smlua_func_cur_obj_shake_y_until(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 cycles = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 amount = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_shake_y_until(s32 cycles, s32 amount);
    lua_pushinteger(L, cur_obj_shake_y_until(cycles, amount));

    return 1;
}

int smlua_func_cur_obj_spawn_loot_blue_coin(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_spawn_loot_blue_coin(void);
    cur_obj_spawn_loot_blue_coin();

    return 1;
}

int smlua_func_cur_obj_spawn_loot_coin_at_mario_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_spawn_loot_coin_at_mario_pos(struct MarioState* m);
    cur_obj_spawn_loot_coin_at_mario_pos(m);

    return 1;
}

int smlua_func_cur_obj_spawn_particles(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct SpawnParticlesInfo* info = (struct SpawnParticlesInfo*)smlua_to_cobject(L, 1, LOT_SPAWNPARTICLESINFO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_spawn_particles(struct SpawnParticlesInfo *info);
    cur_obj_spawn_particles(info);

    return 1;
}

int smlua_func_cur_obj_spawn_star_at_y_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 targetX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 targetY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 targetZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 offsetY = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void cur_obj_spawn_star_at_y_offset(f32 targetX, f32 targetY, f32 targetZ, f32 offsetY);
    cur_obj_spawn_star_at_y_offset(targetX, targetY, targetZ, offsetY);

    return 1;
}

int smlua_func_cur_obj_start_cam_event(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 cameraEvent = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_start_cam_event(UNUSED struct Object *obj, s32 cameraEvent);
    cur_obj_start_cam_event(obj, cameraEvent);

    return 1;
}

int smlua_func_cur_obj_unhide(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_unhide(void);
    cur_obj_unhide();

    return 1;
}

int smlua_func_cur_obj_unrender_and_reset_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 sp18 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp1C = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_unrender_and_reset_state(s32 sp18, s32 sp1C);
    cur_obj_unrender_and_reset_state(sp18, sp1C);

    return 1;
}

int smlua_func_cur_obj_unused_init_on_floor(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_unused_init_on_floor(void);
    cur_obj_unused_init_on_floor();

    return 1;
}

int smlua_func_cur_obj_unused_play_footstep_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 animFrame1 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animFrame2 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 sound = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void cur_obj_unused_play_footstep_sound(s32 animFrame1, s32 animFrame2, s32 sound);
    cur_obj_unused_play_footstep_sound(animFrame1, animFrame2, sound);

    return 1;
}

int smlua_func_cur_obj_unused_resolve_wall_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 offsetY = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 radius = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void cur_obj_unused_resolve_wall_collisions(f32 offsetY, f32 radius);
    cur_obj_unused_resolve_wall_collisions(offsetY, radius);

    return 1;
}

int smlua_func_cur_obj_update_floor(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_update_floor(void);
    cur_obj_update_floor();

    return 1;
}

int smlua_func_cur_obj_update_floor_and_resolve_wall_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 steepSlopeDegrees = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_update_floor_and_resolve_wall_collisions(s16 steepSlopeDegrees);
    cur_obj_update_floor_and_resolve_wall_collisions(steepSlopeDegrees);

    return 1;
}

int smlua_func_cur_obj_update_floor_and_walls(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_update_floor_and_walls(void);
    cur_obj_update_floor_and_walls();

    return 1;
}

int smlua_func_cur_obj_update_floor_height(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void cur_obj_update_floor_height(void);
    cur_obj_update_floor_height();

    return 1;
}

int smlua_func_cur_obj_update_floor_height_and_get_floor(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern struct Surface *cur_obj_update_floor_height_and_get_floor(void);
    smlua_push_object(L, LOT_SURFACE, cur_obj_update_floor_height_and_get_floor());

    return 1;
}

int smlua_func_cur_obj_wait_then_blink(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 timeUntilBlinking = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 numBlinks = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 cur_obj_wait_then_blink(s32 timeUntilBlinking, s32 numBlinks);
    lua_pushinteger(L, cur_obj_wait_then_blink(timeUntilBlinking, numBlinks));

    return 1;
}

int smlua_func_cur_obj_was_attacked_or_ground_pounded(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_was_attacked_or_ground_pounded(void);
    lua_pushinteger(L, cur_obj_was_attacked_or_ground_pounded());

    return 1;
}

int smlua_func_cur_obj_within_12k_bounds(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 cur_obj_within_12k_bounds(void);
    lua_pushinteger(L, cur_obj_within_12k_bounds());

    return 1;
}

int smlua_func_disable_time_stop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void disable_time_stop(void);
    disable_time_stop();

    return 1;
}

int smlua_func_disable_time_stop_including_mario(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void disable_time_stop_including_mario(void);
    disable_time_stop_including_mario();

    return 1;
}

int smlua_func_dist_between_object_and_point(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 pointX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 pointY = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 pointZ = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern f32 dist_between_object_and_point(struct Object *obj, f32 pointX, f32 pointY, f32 pointZ);
    lua_pushnumber(L, dist_between_object_and_point(obj, pointX, pointY, pointZ));

    return 1;
}

int smlua_func_dist_between_objects(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern f32 dist_between_objects(struct Object *obj1, struct Object *obj2);
    lua_pushnumber(L, dist_between_objects(obj1, obj2));

    return 1;
}

int smlua_func_enable_time_stop(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void enable_time_stop(void);
    enable_time_stop();

    return 1;
}

int smlua_func_enable_time_stop_if_alone(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void enable_time_stop_if_alone(void);
    enable_time_stop_if_alone();

    return 1;
}

int smlua_func_enable_time_stop_including_mario(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void enable_time_stop_including_mario(void);
    enable_time_stop_including_mario();

    return 1;
}

int smlua_func_find_object_with_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern struct Object *find_object_with_behavior(const BehaviorScript *behavior);
    smlua_push_object(L, LOT_OBJECT, find_object_with_behavior(behavior));

    return 1;
}

int smlua_func_find_unimportant_object(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern struct Object *find_unimportant_object(void);
    smlua_push_object(L, LOT_OBJECT, find_unimportant_object());

    return 1;
}

/*
int smlua_func_geo_choose_area_ext(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern Gfx *geo_choose_area_ext(UNUSED s32 callContext, struct GraphNode *node, UNUSED Mat4 mtx);
    UNIMPLEMENTED -->(L, geo_choose_area_ext(callContext, node, mtx));

    return 1;
}
*/

int smlua_func_geo_offset_klepto_debug(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* a1 = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 sp8 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s32 geo_offset_klepto_debug(s32 callContext, struct GraphNode *a1, UNUSED s32 sp8);
    lua_pushinteger(L, geo_offset_klepto_debug(callContext, a1, sp8));

    return 1;
}

/*
int smlua_func_geo_offset_klepto_held_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern Gfx *geo_offset_klepto_held_object(s32 callContext, struct GraphNode *node, UNUSED Mat4 mtx);
    UNIMPLEMENTED -->(L, geo_offset_klepto_held_object(callContext, node, mtx));

    return 1;
}
*/

/*
int smlua_func_geo_switch_anim_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern Gfx *geo_switch_anim_state(s32 callContext, struct GraphNode *node);
    UNIMPLEMENTED -->(L, geo_switch_anim_state(callContext, node));

    return 1;
}
*/

/*
int smlua_func_geo_switch_area(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern Gfx *geo_switch_area(s32 callContext, struct GraphNode *node);
    UNIMPLEMENTED -->(L, geo_switch_area(callContext, node));

    return 1;
}
*/

/*
int smlua_func_geo_update_layer_transparency(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  void * context = (void *)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern Gfx *geo_update_layer_transparency(s32 callContext, struct GraphNode *node, UNUSED void *context);
    UNIMPLEMENTED -->(L, geo_update_layer_transparency(callContext, node, context));

    return 1;
}
*/

/*
int smlua_func_geo_update_projectile_pos_from_parent(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 callContext = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct GraphNode* node = (struct GraphNode*)smlua_to_cobject(L, 2, LOT_GRAPHNODE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 mtx = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern Gfx *geo_update_projectile_pos_from_parent(s32 callContext, UNUSED struct GraphNode *node, Mat4 mtx);
    UNIMPLEMENTED -->(L, geo_update_projectile_pos_from_parent(callContext, node, mtx));

    return 1;
}
*/

int smlua_func_get_object_list_from_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 1, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern u32 get_object_list_from_behavior(const BehaviorScript *behavior);
    lua_pushinteger(L, get_object_list_from_behavior(behavior));

    return 1;
}

int smlua_func_increment_velocity_toward_range(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 value = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 center = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 zeroThreshold = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 increment = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern f32 increment_velocity_toward_range(f32 value, f32 center, f32 zeroThreshold, f32 increment);
    lua_pushnumber(L, increment_velocity_toward_range(value, center, zeroThreshold, increment));

    return 1;
}

int smlua_func_is_item_in_array(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s8 item = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s8 * array = (s8 *)smlua_to_cpointer(L, 2, LVT_S8_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 is_item_in_array(s8 item, s8 *array);
    lua_pushinteger(L, is_item_in_array(item, array));

    return 1;
}

int smlua_func_is_mario_moving_fast_or_in_air(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 speedThreshold = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 is_mario_moving_fast_or_in_air(s32 speedThreshold);
    lua_pushinteger(L, is_mario_moving_fast_or_in_air(speedThreshold));

    return 1;
}

int smlua_func_lateral_dist_between_objects(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern f32 lateral_dist_between_objects(struct Object *obj1, struct Object *obj2);
    lua_pushnumber(L, lateral_dist_between_objects(obj1, obj2));

    return 1;
}

/*
int smlua_func_linear_mtxf_mul_vec3f(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

//  Mat4 m = (Mat4)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(2, "x");
    dst[1] = smlua_get_number_field(2, "y");
    dst[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    f32* v = smlua_get_vec3f_from_buffer();
    v[0] = smlua_get_number_field(3, "x");
    v[1] = smlua_get_number_field(3, "y");
    v[2] = smlua_get_number_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void linear_mtxf_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);
    linear_mtxf_mul_vec3f(m, dst, v);

    smlua_push_number_field(2, "x", dst[0]);
    smlua_push_number_field(2, "y", dst[1]);
    smlua_push_number_field(2, "z", dst[2]);

    smlua_push_number_field(3, "x", v[0]);
    smlua_push_number_field(3, "y", v[1]);
    smlua_push_number_field(3, "z", v[2]);

    return 1;
}
*/

/*
int smlua_func_linear_mtxf_transpose_mul_vec3f(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

//  Mat4 m = (Mat4)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* dst = smlua_get_vec3f_from_buffer();
    dst[0] = smlua_get_number_field(2, "x");
    dst[1] = smlua_get_number_field(2, "y");
    dst[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    f32* v = smlua_get_vec3f_from_buffer();
    v[0] = smlua_get_number_field(3, "x");
    v[1] = smlua_get_number_field(3, "y");
    v[2] = smlua_get_number_field(3, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void linear_mtxf_transpose_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);
    linear_mtxf_transpose_mul_vec3f(m, dst, v);

    smlua_push_number_field(2, "x", dst[0]);
    smlua_push_number_field(2, "y", dst[1]);
    smlua_push_number_field(2, "z", dst[2]);

    smlua_push_number_field(3, "x", v[0]);
    smlua_push_number_field(3, "y", v[1]);
    smlua_push_number_field(3, "z", v[2]);

    return 1;
}
*/

int smlua_func_mario_is_dive_sliding(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_is_dive_sliding(struct MarioState* m);
    lua_pushinteger(L, mario_is_dive_sliding(m));

    return 1;
}

int smlua_func_mario_is_in_air_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 mario_is_in_air_action(struct MarioState* m);
    lua_pushinteger(L, mario_is_in_air_action(m));

    return 1;
}

int smlua_func_mario_is_within_rectangle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 minX = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 maxX = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 minZ = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 maxZ = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s32 mario_is_within_rectangle(s16 minX, s16 maxX, s16 minZ, s16 maxZ);
    lua_pushinteger(L, mario_is_within_rectangle(minX, maxX, minZ, maxZ));

    return 1;
}

int smlua_func_mario_set_flag(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 flag = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void mario_set_flag(s32 flag);
    mario_set_flag(flag);

    return 1;
}

int smlua_func_obj_angle_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s16 obj_angle_to_object(struct Object *obj1, struct Object *obj2);
    lua_pushinteger(L, obj_angle_to_object(obj1, obj2));

    return 1;
}

int smlua_func_obj_angle_to_point(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 pointX = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 pointZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern s16 obj_angle_to_point(struct Object *obj, f32 pointX, f32 pointZ);
    lua_pushinteger(L, obj_angle_to_point(obj, pointX, pointZ));

    return 1;
}

/*
int smlua_func_obj_apply_scale_to_matrix(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
//  Mat4 dst = (Mat4)smlua_to_cobject(L, 2, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  Mat4 src = (Mat4)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_apply_scale_to_matrix(struct Object *obj, Mat4 dst, Mat4 src);
    obj_apply_scale_to_matrix(obj, dst, src);

    return 1;
}
*/

int smlua_func_obj_apply_scale_to_transform(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_apply_scale_to_transform(struct Object *obj);
    obj_apply_scale_to_transform(obj);

    return 1;
}

int smlua_func_obj_attack_collided_from_other_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_attack_collided_from_other_object(struct Object *obj);
    lua_pushinteger(L, obj_attack_collided_from_other_object(obj));

    return 1;
}

int smlua_func_obj_become_tangible(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_become_tangible(struct Object *obj);
    obj_become_tangible(obj);

    return 1;
}

int smlua_func_obj_build_relative_transform(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_build_relative_transform(struct Object *obj);
    obj_build_relative_transform(obj);

    return 1;
}

int smlua_func_obj_build_transform_from_pos_and_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 posIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 angleIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_build_transform_from_pos_and_angle(struct Object *obj, s16 posIndex, s16 angleIndex);
    obj_build_transform_from_pos_and_angle(obj, posIndex, angleIndex);

    return 1;
}

int smlua_func_obj_build_transform_relative_to_parent(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_build_transform_relative_to_parent(struct Object *obj);
    obj_build_transform_relative_to_parent(obj);

    return 1;
}

int smlua_func_obj_build_vel_from_transform(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* a0 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_build_vel_from_transform(struct Object *a0);
    obj_build_vel_from_transform(a0);

    return 1;
}

int smlua_func_obj_check_if_collided_with_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_check_if_collided_with_object(struct Object *obj1, struct Object *obj2);
    lua_pushinteger(L, obj_check_if_collided_with_object(obj1, obj2));

    return 1;
}

int smlua_func_obj_copy_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_angle(struct Object *dst, struct Object *src);
    obj_copy_angle(dst, src);

    return 1;
}

int smlua_func_obj_copy_behavior_params(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_behavior_params(struct Object *dst, struct Object *src);
    obj_copy_behavior_params(dst, src);

    return 1;
}

int smlua_func_obj_copy_graph_y_offset(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_graph_y_offset(struct Object *dst, struct Object *src);
    obj_copy_graph_y_offset(dst, src);

    return 1;
}

int smlua_func_obj_copy_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_pos(struct Object *dst, struct Object *src);
    obj_copy_pos(dst, src);

    return 1;
}

int smlua_func_obj_copy_pos_and_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_pos_and_angle(struct Object *dst, struct Object *src);
    obj_copy_pos_and_angle(dst, src);

    return 1;
}

int smlua_func_obj_copy_scale(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* dst = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* src = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_copy_scale(struct Object *dst, struct Object *src);
    obj_copy_scale(dst, src);

    return 1;
}

int smlua_func_obj_create_transform_from_self(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_create_transform_from_self(struct Object *obj);
    obj_create_transform_from_self(obj);

    return 1;
}

int smlua_func_obj_explode_and_spawn_coins(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 sp18 = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp1C = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_explode_and_spawn_coins(f32 sp18, s32 sp1C);
    obj_explode_and_spawn_coins(sp18, sp1C);

    return 1;
}

int smlua_func_obj_has_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 2, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s32 obj_has_behavior(struct Object *obj, const BehaviorScript *behavior);
    lua_pushinteger(L, obj_has_behavior(obj, behavior));

    return 1;
}

int smlua_func_obj_init_animation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 animIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_init_animation(struct Object *obj, s32 animIndex);
    obj_init_animation(obj, animIndex);

    return 1;
}

/*
int smlua_func_obj_init_animation_with_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
//  const structAnimation*const* animations = (const structAnimation*const*)smlua_to_cobject(L, 2, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 animIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_init_animation_with_sound(struct Object *obj, const struct Animation * const* animations, s32 animIndex);
    obj_init_animation_with_sound(obj, animations, animIndex);

    return 1;
}
*/

int smlua_func_obj_is_hidden(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 obj_is_hidden(struct Object *obj);
    lua_pushinteger(L, obj_is_hidden(obj));

    return 1;
}

int smlua_func_obj_mark_for_deletion(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_mark_for_deletion(struct Object *obj);
    obj_mark_for_deletion(obj);

    return 1;
}

int smlua_func_obj_pitch_to_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* target = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern s16 obj_pitch_to_object(struct Object* obj, struct Object* target);
    lua_pushinteger(L, obj_pitch_to_object(obj, target));

    return 1;
}

int smlua_func_obj_scale(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 scale = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_scale(struct Object *obj, f32 scale);
    obj_scale(obj, scale);

    return 1;
}

int smlua_func_obj_scale_random(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 rangeLength = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 minScale = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_scale_random(struct Object *obj, f32 rangeLength, f32 minScale);
    obj_scale_random(obj, rangeLength, minScale);

    return 1;
}

int smlua_func_obj_scale_xyz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 xScale = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 yScale = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 zScale = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_scale_xyz(struct Object *obj, f32 xScale, f32 yScale, f32 zScale);
    obj_scale_xyz(obj, xScale, yScale, zScale);

    return 1;
}

int smlua_func_obj_set_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 pitch = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 yaw = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 roll = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_set_angle(struct Object *obj, s16 pitch, s16 yaw, s16 roll);
    obj_set_angle(obj, pitch, yaw, roll);

    return 1;
}

int smlua_func_obj_set_behavior(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const BehaviorScript* behavior = (const BehaviorScript*)smlua_to_cpointer(L, 2, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_set_behavior(struct Object *obj, const BehaviorScript *behavior);
    obj_set_behavior(obj, behavior);

    return 1;
}

int smlua_func_obj_set_billboard(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_billboard(struct Object *obj);
    obj_set_billboard(obj);

    return 1;
}

/*
int smlua_func_obj_set_collision_data(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
//  const void* segAddr = (const void*)smlua_to_cobject(L, 2, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_set_collision_data(struct Object *obj, const void *segAddr);
    obj_set_collision_data(obj, segAddr);

    return 1;
}
*/

int smlua_func_obj_set_cylboard(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_cylboard(struct Object *obj);
    obj_set_cylboard(obj);

    return 1;
}

int smlua_func_obj_set_face_angle_to_move_angle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_face_angle_to_move_angle(struct Object *obj);
    obj_set_face_angle_to_move_angle(obj);

    return 1;
}

int smlua_func_obj_set_gfx_pos_at_obj_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* obj2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_set_gfx_pos_at_obj_pos(struct Object *obj1, struct Object *obj2);
    obj_set_gfx_pos_at_obj_pos(obj1, obj2);

    return 1;
}

int smlua_func_obj_set_gfx_pos_from_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_gfx_pos_from_pos(struct Object *obj);
    obj_set_gfx_pos_from_pos(obj);

    return 1;
}

int smlua_func_obj_set_held_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const BehaviorScript* heldBehavior = (const BehaviorScript*)smlua_to_cpointer(L, 2, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_set_held_state(struct Object *obj, const BehaviorScript *heldBehavior);
    obj_set_held_state(obj, heldBehavior);

    return 1;
}

int smlua_func_obj_set_hitbox(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct ObjectHitbox* hitbox = (struct ObjectHitbox*)smlua_to_cobject(L, 2, LOT_OBJECTHITBOX);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_set_hitbox(struct Object *obj, struct ObjectHitbox *hitbox);
    obj_set_hitbox(obj, hitbox);

    return 1;
}

int smlua_func_obj_set_parent_relative_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 relX = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 relY = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 relZ = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_set_parent_relative_pos(struct Object *obj, s16 relX, s16 relY, s16 relZ);
    obj_set_parent_relative_pos(obj, relX, relY, relZ);

    return 1;
}

int smlua_func_obj_set_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 x = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 y = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 z = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_set_pos(struct Object *obj, s16 x, s16 y, s16 z);
    obj_set_pos(obj, x, y, z);

    return 1;
}

int smlua_func_obj_set_pos_relative(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* other = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 dleft = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 dy = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 dforward = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    extern void obj_set_pos_relative(struct Object *obj, struct Object *other, f32 dleft, f32 dy, f32 dforward);
    obj_set_pos_relative(obj, other, dleft, dy, dforward);

    return 1;
}

int smlua_func_obj_set_throw_matrix_from_transform(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void obj_set_throw_matrix_from_transform(struct Object *obj);
    obj_set_throw_matrix_from_transform(obj);

    return 1;
}

int smlua_func_obj_spawn_loot_blue_coins(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 numCoins = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 sp28 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 posJitter = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern void obj_spawn_loot_blue_coins(struct Object *obj, s32 numCoins, f32 sp28, s16 posJitter);
    obj_spawn_loot_blue_coins(obj, numCoins, sp28, posJitter);

    return 1;
}

int smlua_func_obj_spawn_loot_coins(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 numCoins = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 sp30 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    const BehaviorScript* coinBehavior = (const BehaviorScript*)smlua_to_cpointer(L, 4, LVT_BEHAVIORSCRIPT_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 posJitter = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    s16 model = smlua_to_integer(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    extern void obj_spawn_loot_coins(struct Object *obj, s32 numCoins, f32 sp30, const BehaviorScript *coinBehavior, s16 posJitter, s16 model);
    obj_spawn_loot_coins(obj, numCoins, sp30, coinBehavior, posJitter, model);

    return 1;
}

int smlua_func_obj_spawn_loot_yellow_coins(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 numCoins = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 sp28 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_spawn_loot_yellow_coins(struct Object *obj, s32 numCoins, f32 sp28);
    obj_spawn_loot_yellow_coins(obj, numCoins, sp28);

    return 1;
}

int smlua_func_obj_translate_local(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 posIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 localTranslateIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void obj_translate_local(struct Object *obj, s16 posIndex, s16 localTranslateIndex);
    obj_translate_local(obj, posIndex, localTranslateIndex);

    return 1;
}

int smlua_func_obj_translate_xyz_random(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 rangeLength = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_translate_xyz_random(struct Object *obj, f32 rangeLength);
    obj_translate_xyz_random(obj, rangeLength);

    return 1;
}

int smlua_func_obj_translate_xz_random(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 rangeLength = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_translate_xz_random(struct Object *obj, f32 rangeLength);
    obj_translate_xz_random(obj, rangeLength);

    return 1;
}

int smlua_func_obj_turn_toward_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* target = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 angleIndex = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 turnAmount = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    extern s16 obj_turn_toward_object(struct Object *obj, struct Object *target, s16 angleIndex, s16 turnAmount);
    lua_pushinteger(L, obj_turn_toward_object(obj, target, angleIndex, turnAmount));

    return 1;
}

/*
int smlua_func_obj_update_pos_from_parent_transformation(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

//  Mat4 a0 = (Mat4)smlua_to_cobject(L, 1, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* a1 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void obj_update_pos_from_parent_transformation(Mat4 a0, struct Object *a1);
    obj_update_pos_from_parent_transformation(a0, a1);

    return 1;
}
*/

int smlua_func_player_performed_grab_escape_action(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern s32 player_performed_grab_escape_action(void);
    lua_pushinteger(L, player_performed_grab_escape_action());

    return 1;
}

int smlua_func_random_f32_around_zero(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 diameter = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern f32 random_f32_around_zero(f32 diameter);
    lua_pushnumber(L, random_f32_around_zero(diameter));

    return 1;
}

int smlua_func_set_mario_interact_hoot_if_in_range(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 sp0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp4 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 sp8 = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void set_mario_interact_hoot_if_in_range(UNUSED s32 sp0, UNUSED s32 sp4, f32 sp8);
    set_mario_interact_hoot_if_in_range(sp0, sp4, sp8);

    return 1;
}

int smlua_func_set_time_stop_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void set_time_stop_flags(s32 flags);
    set_time_stop_flags(flags);

    return 1;
}

int smlua_func_set_time_stop_flags_if_alone(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void set_time_stop_flags_if_alone(s32 flags);
    set_time_stop_flags_if_alone(flags);

    return 1;
}

int smlua_func_signum_positive(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 x = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 signum_positive(s32 x);
    lua_pushinteger(L, signum_positive(x));

    return 1;
}

int smlua_func_spawn_base_star_with_no_lvl_exit(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void spawn_base_star_with_no_lvl_exit(void);
    spawn_base_star_with_no_lvl_exit();

    return 1;
}

int smlua_func_spawn_mist_particles(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void spawn_mist_particles(void);
    spawn_mist_particles();

    return 1;
}

int smlua_func_spawn_mist_particles_with_sound(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u32 sp18 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void spawn_mist_particles_with_sound(u32 sp18);
    spawn_mist_particles_with_sound(sp18);

    return 1;
}

int smlua_func_spawn_star_with_no_lvl_exit(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 sp20 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp24 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern struct Object *spawn_star_with_no_lvl_exit(s32 sp20, s32 sp24);
    smlua_push_object(L, LOT_OBJECT, spawn_star_with_no_lvl_exit(sp20, sp24));

    return 1;
}

int smlua_func_spawn_water_droplet(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* parent = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct WaterDropletParams* params = (struct WaterDropletParams*)smlua_to_cobject(L, 2, LOT_WATERDROPLETPARAMS);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern struct Object *spawn_water_droplet(struct Object *parent, struct WaterDropletParams *params);
    smlua_push_object(L, LOT_OBJECT, spawn_water_droplet(parent, params));

    return 1;
}

int smlua_func_stub_obj_helpers_3(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 sp0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 sp4 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void stub_obj_helpers_3(UNUSED s32 sp0, UNUSED s32 sp4);
    stub_obj_helpers_3(sp0, sp4);

    return 1;
}

int smlua_func_stub_obj_helpers_4(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    extern void stub_obj_helpers_4(void);
    stub_obj_helpers_4();

    return 1;
}

  /////////////////////////////
 // object_list_processor.h //
/////////////////////////////

int smlua_func_set_object_respawn_info_bits(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* obj = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 bits = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    set_object_respawn_info_bits(obj, bits);

    return 1;
}

  ///////////////////
 // rumble_init.c //
///////////////////

int smlua_func_queue_rumble_data(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 a0 = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 a1 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void queue_rumble_data(s16 a0, s16 a1);
    queue_rumble_data(a0, a1);

    return 1;
}

int smlua_func_queue_rumble_data_mario(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 a0 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 a1 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void queue_rumble_data_mario(struct MarioState* m, s16 a0, s16 a1);
    queue_rumble_data_mario(m, a0, a1);

    return 1;
}

int smlua_func_queue_rumble_data_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* object = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 a0 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 a1 = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    extern void queue_rumble_data_object(struct Object* object, s16 a0, s16 a1);
    queue_rumble_data_object(object, a0, a1);

    return 1;
}

int smlua_func_reset_rumble_timers(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void reset_rumble_timers(struct MarioState* m);
    reset_rumble_timers(m);

    return 1;
}

int smlua_func_reset_rumble_timers_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 a0 = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    extern void reset_rumble_timers_2(struct MarioState* m, s32 a0);
    reset_rumble_timers_2(m, a0);

    return 1;
}

  /////////////////
 // save_file.h //
/////////////////

int smlua_func_save_file_clear_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    save_file_clear_flags(flags);

    return 1;
}

int smlua_func_save_file_get_cap_pos(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }


    s16* capPos = smlua_get_vec3s_from_buffer();
    capPos[0] = smlua_get_integer_field(1, "x");
    capPos[1] = smlua_get_integer_field(1, "y");
    capPos[2] = smlua_get_integer_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, save_file_get_cap_pos(capPos));

    smlua_push_integer_field(1, "x", capPos[0]);
    smlua_push_integer_field(1, "y", capPos[1]);
    smlua_push_integer_field(1, "z", capPos[2]);

    return 1;
}

int smlua_func_save_file_get_course_coin_score(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 fileIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 courseIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, save_file_get_course_coin_score(fileIndex, courseIndex));

    return 1;
}

int smlua_func_save_file_get_course_star_count(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 fileIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 courseIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, save_file_get_course_star_count(fileIndex, courseIndex));

    return 1;
}

int smlua_func_save_file_get_flags(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, save_file_get_flags());

    return 1;
}

int smlua_func_save_file_get_max_coin_score(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 courseIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, save_file_get_max_coin_score(courseIndex));

    return 1;
}

int smlua_func_save_file_get_sound_mode(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, save_file_get_sound_mode());

    return 1;
}

int smlua_func_save_file_get_star_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s32 fileIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 courseIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, save_file_get_star_flags(fileIndex, courseIndex));

    return 1;
}

int smlua_func_save_file_get_total_star_count(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 fileIndex = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 minCourse = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 maxCourse = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushinteger(L, save_file_get_total_star_count(fileIndex, minCourse, maxCourse));

    return 1;
}

int smlua_func_save_file_set_flags(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u32 flags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    save_file_set_flags(flags);

    return 1;
}

  /////////////////////////
 // smlua_audio_utils.h //
/////////////////////////

int smlua_func_audio_sample_destroy(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    audio_sample_destroy(audio);

    return 1;
}

int smlua_func_audio_sample_load(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* filename = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_BASSAUDIO, audio_sample_load(filename));

    return 1;
}

int smlua_func_audio_sample_play(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* position = smlua_get_vec3f_from_buffer();
    position[0] = smlua_get_number_field(2, "x");
    position[1] = smlua_get_number_field(2, "y");
    position[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 volume = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    audio_sample_play(audio, position, volume);

    smlua_push_number_field(2, "x", position[0]);
    smlua_push_number_field(2, "y", position[1]);
    smlua_push_number_field(2, "z", position[2]);

    return 1;
}

int smlua_func_audio_stream_destroy(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    audio_stream_destroy(audio);

    return 1;
}

int smlua_func_audio_stream_get_frequency(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, audio_stream_get_frequency(audio));

    return 1;
}

int smlua_func_audio_stream_get_looping(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushboolean(L, audio_stream_get_looping(audio));

    return 1;
}

int smlua_func_audio_stream_get_position(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, audio_stream_get_position(audio));

    return 1;
}

int smlua_func_audio_stream_get_tempo(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, audio_stream_get_tempo(audio));

    return 1;
}

int smlua_func_audio_stream_get_volume(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, audio_stream_get_volume(audio));

    return 1;
}

int smlua_func_audio_stream_load(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* filename = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_BASSAUDIO, audio_stream_load(filename));

    return 1;
}

int smlua_func_audio_stream_loadURL(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* url = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_BASSAUDIO, audio_stream_loadURL(url));

    return 1;
}

int smlua_func_audio_stream_pause(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    audio_stream_pause(audio);

    return 1;
}

int smlua_func_audio_stream_play(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    bool restart = smlua_to_boolean(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 volume = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    audio_stream_play(audio, restart, volume);

    return 1;
}

int smlua_func_audio_stream_set_frequency(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 freq = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    audio_stream_set_frequency(audio, freq);

    return 1;
}

int smlua_func_audio_stream_set_looping(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    bool looping = smlua_to_boolean(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    audio_stream_set_looping(audio, looping);

    return 1;
}

int smlua_func_audio_stream_set_position(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 pos = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    audio_stream_set_position(audio, pos);

    return 1;
}

int smlua_func_audio_stream_set_speed(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 initial_freq = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 speed = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    bool pitch = smlua_to_boolean(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    audio_stream_set_speed(audio, initial_freq, speed, pitch);

    return 1;
}

int smlua_func_audio_stream_set_tempo(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 tempo = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    audio_stream_set_tempo(audio, tempo);

    return 1;
}

int smlua_func_audio_stream_set_volume(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 volume = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    audio_stream_set_volume(audio, volume);

    return 1;
}

int smlua_func_audio_stream_stop(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct BassAudio* audio = (struct BassAudio*)smlua_to_cobject(L, 1, LOT_BASSAUDIO);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    audio_stream_stop(audio);

    return 1;
}

int smlua_func_smlua_audio_utils_replace_sequence(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    u8 sequenceId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 bankId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 defaultVolume = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    const char* m64Name = smlua_to_string(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    smlua_audio_utils_replace_sequence(sequenceId, bankId, defaultVolume, m64Name);

    return 1;
}

int smlua_func_smlua_audio_utils_reset_all(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    smlua_audio_utils_reset_all();

    return 1;
}

  /////////////////////////////
 // smlua_collision_utils.h //
/////////////////////////////

int smlua_func_collision_find_surface_on_ray(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    f32 startX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 startY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 startZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 endX = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 endY = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    f32 endZ = smlua_to_number(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    smlua_push_object(L, LOT_RAYINTERSECTIONINFO, collision_find_surface_on_ray(startX, startY, startZ, endX, endY, endZ));

    return 1;
}

int smlua_func_get_water_surface_pseudo_floor(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    smlua_push_object(L, LOT_SURFACE, get_water_surface_pseudo_floor());

    return 1;
}

int smlua_func_smlua_collision_util_get(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_pointer(L, LVT_COLLISION_P, (void*)smlua_collision_util_get(name));

    return 1;
}

  ////////////////////////
 // smlua_misc_utils.h //
////////////////////////

int smlua_func_allocate_mario_action(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u32 actFlags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, allocate_mario_action(actFlags));

    return 1;
}

int smlua_func_camera_freeze(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    camera_freeze();

    return 1;
}

int smlua_func_camera_unfreeze(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    camera_unfreeze();

    return 1;
}

int smlua_func_deref_s32_pointer(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32* pointer = (s32*)smlua_to_cpointer(L, 1, LVT_S32_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, deref_s32_pointer(pointer));

    return 1;
}

int smlua_func_get_current_save_file_num(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_current_save_file_num());

    return 1;
}

int smlua_func_get_environment_region(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u8 index = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushnumber(L, get_environment_region(index));

    return 1;
}

int smlua_func_get_hand_foot_pos_x(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 index = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, get_hand_foot_pos_x(m, index));

    return 1;
}

int smlua_func_get_hand_foot_pos_y(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 index = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, get_hand_foot_pos_y(m, index));

    return 1;
}

int smlua_func_get_hand_foot_pos_z(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct MarioState* m = (struct MarioState*)smlua_to_cobject(L, 1, LOT_MARIOSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u8 index = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, get_hand_foot_pos_z(m, index));

    return 1;
}

int smlua_func_get_network_area_timer(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushinteger(L, get_network_area_timer());

    return 1;
}

int smlua_func_get_temp_s32_pointer(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 initialValue = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_pointer(L, LVT_S32_P, (void*)get_temp_s32_pointer(initialValue));

    return 1;
}

int smlua_func_hud_get_value(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int type = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, hud_get_value(type));

    return 1;
}

int smlua_func_hud_hide(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    hud_hide();

    return 1;
}

int smlua_func_hud_render_power_meter(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    s32 health = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 x = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 y = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 width = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 height = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    hud_render_power_meter(health, x, y, width, height);

    return 1;
}

int smlua_func_hud_set_value(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    int type = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 value = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    hud_set_value(type, value);

    return 1;
}

int smlua_func_hud_show(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    hud_show();

    return 1;
}

int smlua_func_is_game_paused(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushboolean(L, is_game_paused());

    return 1;
}

int smlua_func_movtexqc_register(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 level = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 area = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 type = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    movtexqc_register(name, level, area, type);

    return 1;
}

int smlua_func_play_transition(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 5)) { return 0; }

    s16 transType = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 time = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    u8 red = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    u8 green = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    u8 blue = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }

    play_transition(transType, time, red, green, blue);

    return 1;
}

int smlua_func_save_file_set_using_backup_slot(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    bool usingBackupSlot = smlua_to_boolean(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    save_file_set_using_backup_slot(usingBackupSlot);

    return 1;
}

int smlua_func_set_environment_region(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    u8 index = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 value = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    set_environment_region(index, value);

    return 1;
}

int smlua_func_set_override_far(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 far = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_override_far(far);

    return 1;
}

int smlua_func_set_override_fov(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 fov = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_override_fov(fov);

    return 1;
}

int smlua_func_set_override_near(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 near = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    set_override_near(near);

    return 1;
}

int smlua_func_warp_exit_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 aDelay = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushboolean(L, warp_exit_level(aDelay));

    return 1;
}

int smlua_func_warp_restart_level(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    lua_pushboolean(L, warp_restart_level());

    return 1;
}

int smlua_func_warp_to_castle(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 aLevel = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushboolean(L, warp_to_castle(aLevel));

    return 1;
}

int smlua_func_warp_to_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    s32 aLevel = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 aArea = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 aAct = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushboolean(L, warp_to_level(aLevel, aArea, aAct));

    return 1;
}

  /////////////////////////
 // smlua_model_utils.h //
/////////////////////////

int smlua_func_smlua_model_util_get_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, smlua_model_util_get_id(name));

    return 1;
}

  ///////////////////////
 // smlua_obj_utils.h //
///////////////////////

int smlua_func_get_temp_object_hitbox(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    smlua_push_object(L, LOT_OBJECTHITBOX, get_temp_object_hitbox());

    return 1;
}

int smlua_func_get_trajectory(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_pointer(L, LVT_TRAJECTORY_P, (void*)get_trajectory(name));

    return 1;
}

int smlua_func_obj_check_hitbox_overlap(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o1 = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    struct Object* o2 = (struct Object*)smlua_to_cobject(L, 2, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, obj_check_hitbox_overlap(o1, o2));

    return 1;
}

int smlua_func_obj_count_objects_with_behavior_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, obj_count_objects_with_behavior_id(behaviorId));

    return 1;
}

int smlua_func_obj_get_first(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int objList = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_first(objList));

    return 1;
}

int smlua_func_obj_get_first_with_behavior_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_first_with_behavior_id(behaviorId));

    return 1;
}

int smlua_func_obj_get_first_with_behavior_id_and_field_f32(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 fieldIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 value = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_first_with_behavior_id_and_field_f32(behaviorId, fieldIndex, value));

    return 1;
}

int smlua_func_obj_get_first_with_behavior_id_and_field_s32(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 fieldIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 value = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_first_with_behavior_id_and_field_s32(behaviorId, fieldIndex, value));

    return 1;
}

int smlua_func_obj_get_nearest_object_with_behavior_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int behaviorId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_nearest_object_with_behavior_id(o, behaviorId));

    return 1;
}

int smlua_func_obj_get_next(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_next(o));

    return 1;
}

int smlua_func_obj_get_next_with_same_behavior_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_next_with_same_behavior_id(o));

    return 1;
}

int smlua_func_obj_get_next_with_same_behavior_id_and_field_f32(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 fieldIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 value = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_next_with_same_behavior_id_and_field_f32(o, fieldIndex, value));

    return 1;
}

int smlua_func_obj_get_next_with_same_behavior_id_and_field_s32(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s32 fieldIndex = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s32 value = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    smlua_push_object(L, LOT_OBJECT, obj_get_next_with_same_behavior_id_and_field_s32(o, fieldIndex, value));

    return 1;
}

int smlua_func_obj_get_temp_spawn_particles_info(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    int modelId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_push_object(L, LOT_SPAWNPARTICLESINFO, obj_get_temp_spawn_particles_info(modelId));

    return 1;
}

int smlua_func_obj_has_behavior_id(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int behaviorId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, obj_has_behavior_id(o, behaviorId));

    return 1;
}

int smlua_func_obj_has_model_extended(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int modelId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushinteger(L, obj_has_model_extended(o, modelId));

    return 1;
}

int smlua_func_obj_is_valid_for_interaction(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, obj_is_valid_for_interaction(o));

    return 1;
}

int smlua_func_obj_move_xyz(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 dx = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 dy = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 dz = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    obj_move_xyz(o, dx, dy, dz);

    return 1;
}

int smlua_func_obj_set_model_extended(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int modelId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    obj_set_model_extended(o, modelId);

    return 1;
}

int smlua_func_obj_set_vel(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    struct Object* o = (struct Object*)smlua_to_cobject(L, 1, LOT_OBJECT);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 vx = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 vy = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 vz = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    obj_set_vel(o, vx, vy, vz);

    return 1;
}

int smlua_func_spawn_non_sync_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int modelId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 x = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 y = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 z = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    LuaFunction objSetupFunction = smlua_to_lua_function(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    smlua_push_object(L, LOT_OBJECT, spawn_non_sync_object(behaviorId, modelId, x, y, z, objSetupFunction));

    return 1;
}

int smlua_func_spawn_sync_object(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    int behaviorId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    int modelId = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 x = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    f32 y = smlua_to_number(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    f32 z = smlua_to_number(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    LuaFunction objSetupFunction = smlua_to_lua_function(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    smlua_push_object(L, LOT_OBJECT, spawn_sync_object(behaviorId, modelId, x, y, z, objSetupFunction));

    return 1;
}

  ////////////////////////
 // smlua_text_utils.h //
////////////////////////

int smlua_func_smlua_text_utils_castle_secret_stars_replace(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    const char* name = smlua_to_string(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    smlua_text_utils_castle_secret_stars_replace(name);

    return 1;
}

int smlua_func_smlua_text_utils_course_acts_replace(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 8)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const char* courseName = smlua_to_string(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    const char* act1 = smlua_to_string(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    const char* act2 = smlua_to_string(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    const char* act3 = smlua_to_string(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    const char* act4 = smlua_to_string(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }
    const char* act5 = smlua_to_string(L, 7);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 7"); return 0; }
    const char* act6 = smlua_to_string(L, 8);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 8"); return 0; }

    smlua_text_utils_course_acts_replace(courseNum, courseName, act1, act2, act3, act4, act5, act6);

    return 1;
}

int smlua_func_smlua_text_utils_dialog_replace(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 6)) { return 0; }

    int dialogId = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u32 unused = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s8 linesPerBox = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 leftOffset = smlua_to_integer(L, 4);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }
    s16 width = smlua_to_integer(L, 5);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 5"); return 0; }
    const char* str = smlua_to_string(L, 6);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 6"); return 0; }

    smlua_text_utils_dialog_replace(dialogId, unused, linesPerBox, leftOffset, width, str);

    return 1;
}

int smlua_func_smlua_text_utils_extra_text_replace(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 index = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const char* text = smlua_to_string(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    smlua_text_utils_extra_text_replace(index, text);

    return 1;
}

int smlua_func_smlua_text_utils_reset_all(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    smlua_text_utils_reset_all();

    return 1;
}

int smlua_func_smlua_text_utils_secret_star_replace(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    s16 courseNum = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    const char* courseName = smlua_to_string(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    smlua_text_utils_secret_star_replace(courseNum, courseName);

    return 1;
}

  //////////////////
 // sound_init.h //
//////////////////

int smlua_func_disable_background_sound(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    disable_background_sound();

    return 1;
}

int smlua_func_enable_background_sound(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    enable_background_sound();

    return 1;
}

int smlua_func_fadeout_cap_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    fadeout_cap_music();

    return 1;
}

int smlua_func_fadeout_level_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 fadeTimer = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    fadeout_level_music(fadeTimer);

    return 1;
}

int smlua_func_fadeout_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 fadeOutTime = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    fadeout_music(fadeOutTime);

    return 1;
}

int smlua_func_lower_background_noise(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 a = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lower_background_noise(a);

    return 1;
}

int smlua_func_play_cap_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u16 seqArgs = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_cap_music(seqArgs);

    return 1;
}

int smlua_func_play_cutscene_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    u16 seqArgs = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_cutscene_music(seqArgs);

    return 1;
}

int smlua_func_play_infinite_stairs_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_infinite_stairs_music();

    return 1;
}

int smlua_func_play_menu_sounds(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 soundMenuFlags = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    play_menu_sounds(soundMenuFlags);

    return 1;
}

int smlua_func_play_painting_eject_sound(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_painting_eject_sound();

    return 1;
}

int smlua_func_play_shell_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    play_shell_music();

    return 1;
}

int smlua_func_raise_background_noise(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 a = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    raise_background_noise(a);

    return 1;
}

int smlua_func_reset_volume(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    reset_volume();

    return 1;
}

int smlua_func_set_background_music(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    u16 a = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    u16 seqArgs = smlua_to_integer(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s16 fadeTimer = smlua_to_integer(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    set_background_music(a, seqArgs, fadeTimer);

    return 1;
}

int smlua_func_stop_cap_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    stop_cap_music();

    return 1;
}

int smlua_func_stop_shell_music(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    stop_shell_music();

    return 1;
}

  ///////////////////
 // spawn_sound.c //
///////////////////

int smlua_func_calc_dist_to_volume_range_1(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 distance = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 calc_dist_to_volume_range_1(f32 distance);
    lua_pushinteger(L, calc_dist_to_volume_range_1(distance));

    return 1;
}

int smlua_func_calc_dist_to_volume_range_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    f32 distance = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern s32 calc_dist_to_volume_range_2(f32 distance);
    lua_pushinteger(L, calc_dist_to_volume_range_2(distance));

    return 1;
}

int smlua_func_cur_obj_play_sound_1(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 soundMagic = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_play_sound_1(s32 soundMagic);
    cur_obj_play_sound_1(soundMagic);

    return 1;
}

int smlua_func_cur_obj_play_sound_2(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s32 soundMagic = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void cur_obj_play_sound_2(s32 soundMagic);
    cur_obj_play_sound_2(soundMagic);

    return 1;
}

int smlua_func_exec_anim_sound_state(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct SoundState* soundStates = (struct SoundState*)smlua_to_cobject(L, 1, LOT_SOUNDSTATE);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    extern void exec_anim_sound_state(struct SoundState *soundStates);
    exec_anim_sound_state(soundStates);

    return 1;
}

  /////////////////////////
 // surface_collision.h //
/////////////////////////

/*
int smlua_func_find_ceil(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 posX = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 posY = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 posZ = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
//  struct Surface** pceil = (struct Surface**)smlua_to_cobject(L, 4, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushnumber(L, find_ceil(posX, posY, posZ, pceil));

    return 1;
}
*/

int smlua_func_find_ceil_height(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, find_ceil_height(x, y, z));

    return 1;
}

/*
int smlua_func_find_floor(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 xPos = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 yPos = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 zPos = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
//  struct Surface** pfloor = (struct Surface**)smlua_to_cobject(L, 4, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushnumber(L, find_floor(xPos, yPos, zPos, pfloor));

    return 1;
}
*/

int smlua_func_find_floor_height(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 3)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 y = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 z = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    lua_pushnumber(L, find_floor_height(x, y, z));

    return 1;
}

/*
int smlua_func_find_floor_height_and_data(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    f32 xPos = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 yPos = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    f32 zPos = smlua_to_number(L, 3);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
//  struct FloorGeometry** floorGeo = (struct FloorGeometry**)smlua_to_cobject(L, 4, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    lua_pushnumber(L, find_floor_height_and_data(xPos, yPos, zPos, floorGeo));

    return 1;
}
*/

int smlua_func_find_poison_gas_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 z = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, find_poison_gas_level(x, z));

    return 1;
}

/*
int smlua_func_find_surface_on_ray(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }


    f32* orig = smlua_get_vec3f_from_buffer();
    orig[0] = smlua_get_number_field(1, "x");
    orig[1] = smlua_get_number_field(1, "y");
    orig[2] = smlua_get_number_field(1, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    f32* dir = smlua_get_vec3f_from_buffer();
    dir[0] = smlua_get_number_field(2, "x");
    dir[1] = smlua_get_number_field(2, "y");
    dir[2] = smlua_get_number_field(2, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
//  struct Surface** hit_surface = (struct Surface**)smlua_to_cobject(L, 3, LOT_???); <--- UNIMPLEMENTED
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }

    f32* hit_pos = smlua_get_vec3f_from_buffer();
    hit_pos[0] = smlua_get_number_field(4, "x");
    hit_pos[1] = smlua_get_number_field(4, "y");
    hit_pos[2] = smlua_get_number_field(4, "z");
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    find_surface_on_ray(orig, dir, hit_surface, hit_pos);

    smlua_push_number_field(1, "x", orig[0]);
    smlua_push_number_field(1, "y", orig[1]);
    smlua_push_number_field(1, "z", orig[2]);

    smlua_push_number_field(2, "x", dir[0]);
    smlua_push_number_field(2, "y", dir[1]);
    smlua_push_number_field(2, "z", dir[2]);

    smlua_push_number_field(4, "x", hit_pos[0]);
    smlua_push_number_field(4, "y", hit_pos[1]);
    smlua_push_number_field(4, "z", hit_pos[2]);

    return 1;
}
*/

int smlua_func_find_wall_collisions(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    struct WallCollisionData* colData = (struct WallCollisionData*)smlua_to_cobject(L, 1, LOT_WALLCOLLISIONDATA);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, find_wall_collisions(colData));

    return 1;
}

int smlua_func_find_water_level(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 2)) { return 0; }

    f32 x = smlua_to_number(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    f32 z = smlua_to_number(L, 2);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }

    lua_pushnumber(L, find_water_level(x, z));

    return 1;
}

  ////////////////////
 // surface_load.h //
////////////////////

int smlua_func_alloc_surface_pools(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    alloc_surface_pools();

    return 1;
}

int smlua_func_clear_dynamic_surfaces(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    clear_dynamic_surfaces();

    return 1;
}

int smlua_func_get_area_terrain_size(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 1)) { return 0; }

    s16 * data = (s16 *)smlua_to_cpointer(L, 1, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }

    lua_pushinteger(L, get_area_terrain_size(data));

    return 1;
}

int smlua_func_load_area_terrain(lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 4)) { return 0; }

    s16 index = smlua_to_integer(L, 1);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 1"); return 0; }
    s16 * data = (s16 *)smlua_to_cpointer(L, 2, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 2"); return 0; }
    s8 * surfaceRooms = (s8 *)smlua_to_cpointer(L, 3, LVT_S8_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 3"); return 0; }
    s16 * macroObjects = (s16 *)smlua_to_cpointer(L, 4, LVT_S16_P);
    if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter 4"); return 0; }

    load_area_terrain(index, data, surfaceRooms, macroObjects);

    return 1;
}

int smlua_func_load_object_collision_model(UNUSED lua_State* L) {
    if(!smlua_functions_valid_param_count(L, 0)) { return 0; }


    load_object_collision_model();

    return 1;
}



void smlua_bind_functions_autogen(void) {
    lua_State* L = gLuaState;

    // behavior_actions.h
    smlua_bind_function(L, "arc_to_goal_pos", smlua_func_arc_to_goal_pos);
    smlua_bind_function(L, "bhv_1up_common_init", smlua_func_bhv_1up_common_init);
    smlua_bind_function(L, "bhv_1up_hidden_in_pole_loop", smlua_func_bhv_1up_hidden_in_pole_loop);
    smlua_bind_function(L, "bhv_1up_hidden_in_pole_spawner_loop", smlua_func_bhv_1up_hidden_in_pole_spawner_loop);
    smlua_bind_function(L, "bhv_1up_hidden_in_pole_trigger_loop", smlua_func_bhv_1up_hidden_in_pole_trigger_loop);
    smlua_bind_function(L, "bhv_1up_hidden_loop", smlua_func_bhv_1up_hidden_loop);
    smlua_bind_function(L, "bhv_1up_hidden_trigger_loop", smlua_func_bhv_1up_hidden_trigger_loop);
    smlua_bind_function(L, "bhv_1up_init", smlua_func_bhv_1up_init);
    smlua_bind_function(L, "bhv_1up_jump_on_approach_loop", smlua_func_bhv_1up_jump_on_approach_loop);
    smlua_bind_function(L, "bhv_1up_loop", smlua_func_bhv_1up_loop);
    smlua_bind_function(L, "bhv_1up_running_away_loop", smlua_func_bhv_1up_running_away_loop);
    smlua_bind_function(L, "bhv_1up_sliding_loop", smlua_func_bhv_1up_sliding_loop);
    smlua_bind_function(L, "bhv_1up_walking_loop", smlua_func_bhv_1up_walking_loop);
    smlua_bind_function(L, "bhv_act_selector_init", smlua_func_bhv_act_selector_init);
    smlua_bind_function(L, "bhv_act_selector_loop", smlua_func_bhv_act_selector_loop);
    smlua_bind_function(L, "bhv_act_selector_star_type_loop", smlua_func_bhv_act_selector_star_type_loop);
    smlua_bind_function(L, "bhv_activated_back_and_forth_platform_init", smlua_func_bhv_activated_back_and_forth_platform_init);
    smlua_bind_function(L, "bhv_activated_back_and_forth_platform_update", smlua_func_bhv_activated_back_and_forth_platform_update);
    smlua_bind_function(L, "bhv_alpha_boo_key_loop", smlua_func_bhv_alpha_boo_key_loop);
    smlua_bind_function(L, "bhv_ambient_sounds_init", smlua_func_bhv_ambient_sounds_init);
    smlua_bind_function(L, "bhv_animated_texture_loop", smlua_func_bhv_animated_texture_loop);
    smlua_bind_function(L, "bhv_animates_on_floor_switch_press_init", smlua_func_bhv_animates_on_floor_switch_press_init);
    smlua_bind_function(L, "bhv_animates_on_floor_switch_press_loop", smlua_func_bhv_animates_on_floor_switch_press_loop);
    smlua_bind_function(L, "bhv_arrow_lift_loop", smlua_func_bhv_arrow_lift_loop);
    smlua_bind_function(L, "bhv_bbh_tilting_trap_platform_loop", smlua_func_bhv_bbh_tilting_trap_platform_loop);
    smlua_bind_function(L, "bhv_beta_boo_key_loop", smlua_func_bhv_beta_boo_key_loop);
    smlua_bind_function(L, "bhv_beta_bowser_anchor_loop", smlua_func_bhv_beta_bowser_anchor_loop);
    smlua_bind_function(L, "bhv_beta_chest_bottom_init", smlua_func_bhv_beta_chest_bottom_init);
    smlua_bind_function(L, "bhv_beta_chest_bottom_loop", smlua_func_bhv_beta_chest_bottom_loop);
    smlua_bind_function(L, "bhv_beta_chest_lid_loop", smlua_func_bhv_beta_chest_lid_loop);
    smlua_bind_function(L, "bhv_beta_fish_splash_spawner_loop", smlua_func_bhv_beta_fish_splash_spawner_loop);
    smlua_bind_function(L, "bhv_beta_holdable_object_init", smlua_func_bhv_beta_holdable_object_init);
    smlua_bind_function(L, "bhv_beta_holdable_object_loop", smlua_func_bhv_beta_holdable_object_loop);
    smlua_bind_function(L, "bhv_beta_moving_flames_loop", smlua_func_bhv_beta_moving_flames_loop);
    smlua_bind_function(L, "bhv_beta_moving_flames_spawn_loop", smlua_func_bhv_beta_moving_flames_spawn_loop);
    smlua_bind_function(L, "bhv_beta_trampoline_spring_loop", smlua_func_bhv_beta_trampoline_spring_loop);
    smlua_bind_function(L, "bhv_beta_trampoline_top_loop", smlua_func_bhv_beta_trampoline_top_loop);
    smlua_bind_function(L, "bhv_big_boo_loop", smlua_func_bhv_big_boo_loop);
    smlua_bind_function(L, "bhv_big_boulder_generator_loop", smlua_func_bhv_big_boulder_generator_loop);
    smlua_bind_function(L, "bhv_big_boulder_init", smlua_func_bhv_big_boulder_init);
    smlua_bind_function(L, "bhv_big_boulder_loop", smlua_func_bhv_big_boulder_loop);
    smlua_bind_function(L, "bhv_big_bully_init", smlua_func_bhv_big_bully_init);
    smlua_bind_function(L, "bhv_big_bully_with_minions_init", smlua_func_bhv_big_bully_with_minions_init);
    smlua_bind_function(L, "bhv_big_bully_with_minions_loop", smlua_func_bhv_big_bully_with_minions_loop);
    smlua_bind_function(L, "bhv_bird_update", smlua_func_bhv_bird_update);
    smlua_bind_function(L, "bhv_birds_sound_loop", smlua_func_bhv_birds_sound_loop);
    smlua_bind_function(L, "bhv_bitfs_sinking_cage_platform_loop", smlua_func_bhv_bitfs_sinking_cage_platform_loop);
    smlua_bind_function(L, "bhv_bitfs_sinking_platform_loop", smlua_func_bhv_bitfs_sinking_platform_loop);
    smlua_bind_function(L, "bhv_black_smoke_bowser_loop", smlua_func_bhv_black_smoke_bowser_loop);
    smlua_bind_function(L, "bhv_black_smoke_mario_loop", smlua_func_bhv_black_smoke_mario_loop);
    smlua_bind_function(L, "bhv_black_smoke_upward_loop", smlua_func_bhv_black_smoke_upward_loop);
    smlua_bind_function(L, "bhv_blue_bowser_flame_init", smlua_func_bhv_blue_bowser_flame_init);
    smlua_bind_function(L, "bhv_blue_bowser_flame_loop", smlua_func_bhv_blue_bowser_flame_loop);
    smlua_bind_function(L, "bhv_blue_coin_jumping_loop", smlua_func_bhv_blue_coin_jumping_loop);
    smlua_bind_function(L, "bhv_blue_coin_sliding_jumping_init", smlua_func_bhv_blue_coin_sliding_jumping_init);
    smlua_bind_function(L, "bhv_blue_coin_sliding_loop", smlua_func_bhv_blue_coin_sliding_loop);
    smlua_bind_function(L, "bhv_blue_coin_switch_loop", smlua_func_bhv_blue_coin_switch_loop);
    smlua_bind_function(L, "bhv_blue_fish_movement_loop", smlua_func_bhv_blue_fish_movement_loop);
    smlua_bind_function(L, "bhv_blue_flames_group_loop", smlua_func_bhv_blue_flames_group_loop);
    smlua_bind_function(L, "bhv_bob_pit_bowling_ball_init", smlua_func_bhv_bob_pit_bowling_ball_init);
    smlua_bind_function(L, "bhv_bob_pit_bowling_ball_loop", smlua_func_bhv_bob_pit_bowling_ball_loop);
    smlua_bind_function(L, "bhv_bobomb_anchor_mario_loop", smlua_func_bhv_bobomb_anchor_mario_loop);
    smlua_bind_function(L, "bhv_bobomb_buddy_init", smlua_func_bhv_bobomb_buddy_init);
    smlua_bind_function(L, "bhv_bobomb_buddy_loop", smlua_func_bhv_bobomb_buddy_loop);
    smlua_bind_function(L, "bhv_bobomb_bully_death_smoke_init", smlua_func_bhv_bobomb_bully_death_smoke_init);
    smlua_bind_function(L, "bhv_bobomb_explosion_bubble_init", smlua_func_bhv_bobomb_explosion_bubble_init);
    smlua_bind_function(L, "bhv_bobomb_explosion_bubble_loop", smlua_func_bhv_bobomb_explosion_bubble_loop);
    smlua_bind_function(L, "bhv_bobomb_fuse_smoke_init", smlua_func_bhv_bobomb_fuse_smoke_init);
    smlua_bind_function(L, "bhv_bobomb_init", smlua_func_bhv_bobomb_init);
    smlua_bind_function(L, "bhv_bobomb_loop", smlua_func_bhv_bobomb_loop);
    smlua_bind_function(L, "bhv_boo_boss_spawned_bridge_loop", smlua_func_bhv_boo_boss_spawned_bridge_loop);
    smlua_bind_function(L, "bhv_boo_cage_init", smlua_func_bhv_boo_cage_init);
    smlua_bind_function(L, "bhv_boo_cage_loop", smlua_func_bhv_boo_cage_loop);
    smlua_bind_function(L, "bhv_boo_in_castle_loop", smlua_func_bhv_boo_in_castle_loop);
    smlua_bind_function(L, "bhv_boo_init", smlua_func_bhv_boo_init);
    smlua_bind_function(L, "bhv_boo_loop", smlua_func_bhv_boo_loop);
    smlua_bind_function(L, "bhv_boo_with_cage_init", smlua_func_bhv_boo_with_cage_init);
    smlua_bind_function(L, "bhv_boo_with_cage_loop", smlua_func_bhv_boo_with_cage_loop);
    smlua_bind_function(L, "bhv_book_switch_loop", smlua_func_bhv_book_switch_loop);
    smlua_bind_function(L, "bhv_bookend_spawn_loop", smlua_func_bhv_bookend_spawn_loop);
    smlua_bind_function(L, "bhv_bouncing_fireball_flame_loop", smlua_func_bhv_bouncing_fireball_flame_loop);
    smlua_bind_function(L, "bhv_bouncing_fireball_loop", smlua_func_bhv_bouncing_fireball_loop);
    smlua_bind_function(L, "bhv_bowling_ball_init", smlua_func_bhv_bowling_ball_init);
    smlua_bind_function(L, "bhv_bowling_ball_loop", smlua_func_bhv_bowling_ball_loop);
    smlua_bind_function(L, "bhv_bowser_body_anchor_init", smlua_func_bhv_bowser_body_anchor_init);
    smlua_bind_function(L, "bhv_bowser_body_anchor_loop", smlua_func_bhv_bowser_body_anchor_loop);
    smlua_bind_function(L, "bhv_bowser_bomb_explosion_loop", smlua_func_bhv_bowser_bomb_explosion_loop);
    smlua_bind_function(L, "bhv_bowser_bomb_loop", smlua_func_bhv_bowser_bomb_loop);
    smlua_bind_function(L, "bhv_bowser_bomb_smoke_loop", smlua_func_bhv_bowser_bomb_smoke_loop);
    smlua_bind_function(L, "bhv_bowser_course_red_coin_star_loop", smlua_func_bhv_bowser_course_red_coin_star_loop);
    smlua_bind_function(L, "bhv_bowser_flame_spawn_loop", smlua_func_bhv_bowser_flame_spawn_loop);
    smlua_bind_function(L, "bhv_bowser_init", smlua_func_bhv_bowser_init);
    smlua_bind_function(L, "bhv_bowser_key_course_exit_loop", smlua_func_bhv_bowser_key_course_exit_loop);
    smlua_bind_function(L, "bhv_bowser_key_init", smlua_func_bhv_bowser_key_init);
    smlua_bind_function(L, "bhv_bowser_key_loop", smlua_func_bhv_bowser_key_loop);
    smlua_bind_function(L, "bhv_bowser_key_unlock_door_loop", smlua_func_bhv_bowser_key_unlock_door_loop);
    smlua_bind_function(L, "bhv_bowser_loop", smlua_func_bhv_bowser_loop);
    smlua_bind_function(L, "bhv_bowser_shock_wave_loop", smlua_func_bhv_bowser_shock_wave_loop);
    smlua_bind_function(L, "bhv_bowser_tail_anchor_init", smlua_func_bhv_bowser_tail_anchor_init);
    smlua_bind_function(L, "bhv_bowser_tail_anchor_loop", smlua_func_bhv_bowser_tail_anchor_loop);
    smlua_bind_function(L, "bhv_bowsers_sub_loop", smlua_func_bhv_bowsers_sub_loop);
    smlua_bind_function(L, "bhv_breakable_box_loop", smlua_func_bhv_breakable_box_loop);
    smlua_bind_function(L, "bhv_breakable_box_small_init", smlua_func_bhv_breakable_box_small_init);
    smlua_bind_function(L, "bhv_breakable_box_small_loop", smlua_func_bhv_breakable_box_small_loop);
    smlua_bind_function(L, "bhv_bub_loop", smlua_func_bhv_bub_loop);
    smlua_bind_function(L, "bhv_bub_spawner_loop", smlua_func_bhv_bub_spawner_loop);
    smlua_bind_function(L, "bhv_bubba_loop", smlua_func_bhv_bubba_loop);
    smlua_bind_function(L, "bhv_bubble_cannon_barrel_loop", smlua_func_bhv_bubble_cannon_barrel_loop);
    smlua_bind_function(L, "bhv_bubble_maybe_loop", smlua_func_bhv_bubble_maybe_loop);
    smlua_bind_function(L, "bhv_bubble_player_loop", smlua_func_bhv_bubble_player_loop);
    smlua_bind_function(L, "bhv_bubble_splash_init", smlua_func_bhv_bubble_splash_init);
    smlua_bind_function(L, "bhv_bubble_wave_init", smlua_func_bhv_bubble_wave_init);
    smlua_bind_function(L, "bhv_bullet_bill_init", smlua_func_bhv_bullet_bill_init);
    smlua_bind_function(L, "bhv_bullet_bill_loop", smlua_func_bhv_bullet_bill_loop);
    smlua_bind_function(L, "bhv_bully_loop", smlua_func_bhv_bully_loop);
    smlua_bind_function(L, "bhv_butterfly_init", smlua_func_bhv_butterfly_init);
    smlua_bind_function(L, "bhv_butterfly_loop", smlua_func_bhv_butterfly_loop);
    smlua_bind_function(L, "bhv_camera_lakitu_init", smlua_func_bhv_camera_lakitu_init);
    smlua_bind_function(L, "bhv_camera_lakitu_update", smlua_func_bhv_camera_lakitu_update);
    smlua_bind_function(L, "bhv_cannon_barrel_loop", smlua_func_bhv_cannon_barrel_loop);
    smlua_bind_function(L, "bhv_cannon_base_loop", smlua_func_bhv_cannon_base_loop);
    smlua_bind_function(L, "bhv_cannon_base_unused_loop", smlua_func_bhv_cannon_base_unused_loop);
    smlua_bind_function(L, "bhv_cannon_closed_init", smlua_func_bhv_cannon_closed_init);
    smlua_bind_function(L, "bhv_cannon_closed_loop", smlua_func_bhv_cannon_closed_loop);
    smlua_bind_function(L, "bhv_cap_switch_loop", smlua_func_bhv_cap_switch_loop);
    smlua_bind_function(L, "bhv_castle_cannon_grate_init", smlua_func_bhv_castle_cannon_grate_init);
    smlua_bind_function(L, "bhv_castle_flag_init", smlua_func_bhv_castle_flag_init);
    smlua_bind_function(L, "bhv_castle_floor_trap_init", smlua_func_bhv_castle_floor_trap_init);
    smlua_bind_function(L, "bhv_castle_floor_trap_loop", smlua_func_bhv_castle_floor_trap_loop);
    smlua_bind_function(L, "bhv_ccm_touched_star_spawn_loop", smlua_func_bhv_ccm_touched_star_spawn_loop);
    smlua_bind_function(L, "bhv_celebration_star_init", smlua_func_bhv_celebration_star_init);
    smlua_bind_function(L, "bhv_celebration_star_loop", smlua_func_bhv_celebration_star_loop);
    smlua_bind_function(L, "bhv_celebration_star_sparkle_loop", smlua_func_bhv_celebration_star_sparkle_loop);
    smlua_bind_function(L, "bhv_chain_chomp_chain_part_update", smlua_func_bhv_chain_chomp_chain_part_update);
    smlua_bind_function(L, "bhv_chain_chomp_gate_init", smlua_func_bhv_chain_chomp_gate_init);
    smlua_bind_function(L, "bhv_chain_chomp_gate_update", smlua_func_bhv_chain_chomp_gate_update);
    smlua_bind_function(L, "bhv_chain_chomp_update", smlua_func_bhv_chain_chomp_update);
    smlua_bind_function(L, "bhv_checkerboard_elevator_group_init", smlua_func_bhv_checkerboard_elevator_group_init);
    smlua_bind_function(L, "bhv_checkerboard_elevator_group_loop", smlua_func_bhv_checkerboard_elevator_group_loop);
    smlua_bind_function(L, "bhv_checkerboard_platform_init", smlua_func_bhv_checkerboard_platform_init);
    smlua_bind_function(L, "bhv_checkerboard_platform_loop", smlua_func_bhv_checkerboard_platform_loop);
    smlua_bind_function(L, "bhv_chuckya_anchor_mario_loop", smlua_func_bhv_chuckya_anchor_mario_loop);
    smlua_bind_function(L, "bhv_chuckya_loop", smlua_func_bhv_chuckya_loop);
    smlua_bind_function(L, "bhv_circling_amp_init", smlua_func_bhv_circling_amp_init);
    smlua_bind_function(L, "bhv_circling_amp_loop", smlua_func_bhv_circling_amp_loop);
    smlua_bind_function(L, "bhv_clam_loop", smlua_func_bhv_clam_loop);
    smlua_bind_function(L, "bhv_cloud_part_update", smlua_func_bhv_cloud_part_update);
    smlua_bind_function(L, "bhv_cloud_update", smlua_func_bhv_cloud_update);
    smlua_bind_function(L, "bhv_coffin_loop", smlua_func_bhv_coffin_loop);
    smlua_bind_function(L, "bhv_coffin_spawner_loop", smlua_func_bhv_coffin_spawner_loop);
    smlua_bind_function(L, "bhv_coin_formation_init", smlua_func_bhv_coin_formation_init);
    smlua_bind_function(L, "bhv_coin_formation_loop", smlua_func_bhv_coin_formation_loop);
    smlua_bind_function(L, "bhv_coin_formation_spawn_loop", smlua_func_bhv_coin_formation_spawn_loop);
    smlua_bind_function(L, "bhv_coin_init", smlua_func_bhv_coin_init);
    smlua_bind_function(L, "bhv_coin_inside_boo_loop", smlua_func_bhv_coin_inside_boo_loop);
    smlua_bind_function(L, "bhv_coin_loop", smlua_func_bhv_coin_loop);
    smlua_bind_function(L, "bhv_coin_sparkles_loop", smlua_func_bhv_coin_sparkles_loop);
    smlua_bind_function(L, "bhv_collect_star_init", smlua_func_bhv_collect_star_init);
    smlua_bind_function(L, "bhv_collect_star_loop", smlua_func_bhv_collect_star_loop);
    smlua_bind_function(L, "bhv_controllable_platform_init", smlua_func_bhv_controllable_platform_init);
    smlua_bind_function(L, "bhv_controllable_platform_loop", smlua_func_bhv_controllable_platform_loop);
    smlua_bind_function(L, "bhv_controllable_platform_sub_loop", smlua_func_bhv_controllable_platform_sub_loop);
    smlua_bind_function(L, "bhv_courtyard_boo_triplet_init", smlua_func_bhv_courtyard_boo_triplet_init);
    smlua_bind_function(L, "bhv_ddd_moving_pole_loop", smlua_func_bhv_ddd_moving_pole_loop);
    smlua_bind_function(L, "bhv_ddd_pole_init", smlua_func_bhv_ddd_pole_init);
    smlua_bind_function(L, "bhv_ddd_pole_update", smlua_func_bhv_ddd_pole_update);
    smlua_bind_function(L, "bhv_ddd_warp_loop", smlua_func_bhv_ddd_warp_loop);
    smlua_bind_function(L, "bhv_decorative_pendulum_init", smlua_func_bhv_decorative_pendulum_init);
    smlua_bind_function(L, "bhv_decorative_pendulum_loop", smlua_func_bhv_decorative_pendulum_loop);
    smlua_bind_function(L, "bhv_donut_platform_spawner_update", smlua_func_bhv_donut_platform_spawner_update);
    smlua_bind_function(L, "bhv_donut_platform_update", smlua_func_bhv_donut_platform_update);
    smlua_bind_function(L, "bhv_door_init", smlua_func_bhv_door_init);
    smlua_bind_function(L, "bhv_door_loop", smlua_func_bhv_door_loop);
    smlua_bind_function(L, "bhv_dorrie_update", smlua_func_bhv_dorrie_update);
    smlua_bind_function(L, "bhv_elevator_init", smlua_func_bhv_elevator_init);
    smlua_bind_function(L, "bhv_elevator_loop", smlua_func_bhv_elevator_loop);
    smlua_bind_function(L, "bhv_end_birds_1_loop", smlua_func_bhv_end_birds_1_loop);
    smlua_bind_function(L, "bhv_end_birds_2_loop", smlua_func_bhv_end_birds_2_loop);
    smlua_bind_function(L, "bhv_enemy_lakitu_update", smlua_func_bhv_enemy_lakitu_update);
    smlua_bind_function(L, "bhv_exclamation_box_init", smlua_func_bhv_exclamation_box_init);
    smlua_bind_function(L, "bhv_exclamation_box_loop", smlua_func_bhv_exclamation_box_loop);
    smlua_bind_function(L, "bhv_explosion_init", smlua_func_bhv_explosion_init);
    smlua_bind_function(L, "bhv_explosion_loop", smlua_func_bhv_explosion_loop);
    smlua_bind_function(L, "bhv_eyerok_boss_init", smlua_func_bhv_eyerok_boss_init);
    smlua_bind_function(L, "bhv_eyerok_boss_loop", smlua_func_bhv_eyerok_boss_loop);
    smlua_bind_function(L, "bhv_eyerok_hand_loop", smlua_func_bhv_eyerok_hand_loop);
    smlua_bind_function(L, "bhv_fading_warp_loop", smlua_func_bhv_fading_warp_loop);
    smlua_bind_function(L, "bhv_falling_bowser_platform_loop", smlua_func_bhv_falling_bowser_platform_loop);
    smlua_bind_function(L, "bhv_falling_pillar_hitbox_loop", smlua_func_bhv_falling_pillar_hitbox_loop);
    smlua_bind_function(L, "bhv_falling_pillar_init", smlua_func_bhv_falling_pillar_init);
    smlua_bind_function(L, "bhv_falling_pillar_loop", smlua_func_bhv_falling_pillar_loop);
    smlua_bind_function(L, "bhv_ferris_wheel_axle_init", smlua_func_bhv_ferris_wheel_axle_init);
    smlua_bind_function(L, "bhv_ferris_wheel_platform_update", smlua_func_bhv_ferris_wheel_platform_update);
    smlua_bind_function(L, "bhv_fire_piranha_plant_init", smlua_func_bhv_fire_piranha_plant_init);
    smlua_bind_function(L, "bhv_fire_piranha_plant_update", smlua_func_bhv_fire_piranha_plant_update);
    smlua_bind_function(L, "bhv_fire_spitter_update", smlua_func_bhv_fire_spitter_update);
    smlua_bind_function(L, "bhv_fish_group_loop", smlua_func_bhv_fish_group_loop);
    smlua_bind_function(L, "bhv_fish_loop", smlua_func_bhv_fish_loop);
    smlua_bind_function(L, "bhv_fish_spawner_loop", smlua_func_bhv_fish_spawner_loop);
    smlua_bind_function(L, "bhv_flame_bouncing_init", smlua_func_bhv_flame_bouncing_init);
    smlua_bind_function(L, "bhv_flame_bouncing_loop", smlua_func_bhv_flame_bouncing_loop);
    smlua_bind_function(L, "bhv_flame_bowser_init", smlua_func_bhv_flame_bowser_init);
    smlua_bind_function(L, "bhv_flame_bowser_loop", smlua_func_bhv_flame_bowser_loop);
    smlua_bind_function(L, "bhv_flame_floating_landing_init", smlua_func_bhv_flame_floating_landing_init);
    smlua_bind_function(L, "bhv_flame_floating_landing_loop", smlua_func_bhv_flame_floating_landing_loop);
    smlua_bind_function(L, "bhv_flame_large_burning_out_init", smlua_func_bhv_flame_large_burning_out_init);
    smlua_bind_function(L, "bhv_flame_mario_loop", smlua_func_bhv_flame_mario_loop);
    smlua_bind_function(L, "bhv_flame_moving_forward_growing_init", smlua_func_bhv_flame_moving_forward_growing_init);
    smlua_bind_function(L, "bhv_flame_moving_forward_growing_loop", smlua_func_bhv_flame_moving_forward_growing_loop);
    smlua_bind_function(L, "bhv_flamethrower_flame_loop", smlua_func_bhv_flamethrower_flame_loop);
    smlua_bind_function(L, "bhv_flamethrower_loop", smlua_func_bhv_flamethrower_loop);
    smlua_bind_function(L, "bhv_floating_platform_loop", smlua_func_bhv_floating_platform_loop);
    smlua_bind_function(L, "bhv_floor_trap_in_castle_loop", smlua_func_bhv_floor_trap_in_castle_loop);
    smlua_bind_function(L, "bhv_fly_guy_flame_loop", smlua_func_bhv_fly_guy_flame_loop);
    smlua_bind_function(L, "bhv_fly_guy_update", smlua_func_bhv_fly_guy_update);
    smlua_bind_function(L, "bhv_flying_bookend_loop", smlua_func_bhv_flying_bookend_loop);
    smlua_bind_function(L, "bhv_free_bowling_ball_init", smlua_func_bhv_free_bowling_ball_init);
    smlua_bind_function(L, "bhv_free_bowling_ball_loop", smlua_func_bhv_free_bowling_ball_loop);
    smlua_bind_function(L, "bhv_generic_bowling_ball_spawner_init", smlua_func_bhv_generic_bowling_ball_spawner_init);
    smlua_bind_function(L, "bhv_generic_bowling_ball_spawner_loop", smlua_func_bhv_generic_bowling_ball_spawner_loop);
    smlua_bind_function(L, "bhv_giant_pole_loop", smlua_func_bhv_giant_pole_loop);
    smlua_bind_function(L, "bhv_golden_coin_sparkles_loop", smlua_func_bhv_golden_coin_sparkles_loop);
    smlua_bind_function(L, "bhv_goomba_init", smlua_func_bhv_goomba_init);
    smlua_bind_function(L, "bhv_goomba_triplet_spawner_update", smlua_func_bhv_goomba_triplet_spawner_update);
    smlua_bind_function(L, "bhv_goomba_update", smlua_func_bhv_goomba_update);
    smlua_bind_function(L, "bhv_grand_star_init", smlua_func_bhv_grand_star_init);
    smlua_bind_function(L, "bhv_grand_star_loop", smlua_func_bhv_grand_star_loop);
    smlua_bind_function(L, "bhv_grindel_thwomp_loop", smlua_func_bhv_grindel_thwomp_loop);
    smlua_bind_function(L, "bhv_ground_sand_init", smlua_func_bhv_ground_sand_init);
    smlua_bind_function(L, "bhv_ground_snow_init", smlua_func_bhv_ground_snow_init);
    smlua_bind_function(L, "bhv_haunted_bookshelf_loop", smlua_func_bhv_haunted_bookshelf_loop);
    smlua_bind_function(L, "bhv_haunted_bookshelf_manager_loop", smlua_func_bhv_haunted_bookshelf_manager_loop);
    smlua_bind_function(L, "bhv_haunted_chair_init", smlua_func_bhv_haunted_chair_init);
    smlua_bind_function(L, "bhv_haunted_chair_loop", smlua_func_bhv_haunted_chair_loop);
    smlua_bind_function(L, "bhv_heave_ho_loop", smlua_func_bhv_heave_ho_loop);
    smlua_bind_function(L, "bhv_heave_ho_throw_mario_loop", smlua_func_bhv_heave_ho_throw_mario_loop);
    smlua_bind_function(L, "bhv_hidden_blue_coin_loop", smlua_func_bhv_hidden_blue_coin_loop);
    smlua_bind_function(L, "bhv_hidden_object_loop", smlua_func_bhv_hidden_object_loop);
    smlua_bind_function(L, "bhv_hidden_red_coin_star_init", smlua_func_bhv_hidden_red_coin_star_init);
    smlua_bind_function(L, "bhv_hidden_red_coin_star_loop", smlua_func_bhv_hidden_red_coin_star_loop);
    smlua_bind_function(L, "bhv_hidden_star_init", smlua_func_bhv_hidden_star_init);
    smlua_bind_function(L, "bhv_hidden_star_loop", smlua_func_bhv_hidden_star_loop);
    smlua_bind_function(L, "bhv_hidden_star_trigger_loop", smlua_func_bhv_hidden_star_trigger_loop);
    smlua_bind_function(L, "bhv_homing_amp_init", smlua_func_bhv_homing_amp_init);
    smlua_bind_function(L, "bhv_homing_amp_loop", smlua_func_bhv_homing_amp_loop);
    smlua_bind_function(L, "bhv_hoot_init", smlua_func_bhv_hoot_init);
    smlua_bind_function(L, "bhv_hoot_loop", smlua_func_bhv_hoot_loop);
    smlua_bind_function(L, "bhv_horizontal_grindel_init", smlua_func_bhv_horizontal_grindel_init);
    smlua_bind_function(L, "bhv_horizontal_grindel_update", smlua_func_bhv_horizontal_grindel_update);
    smlua_bind_function(L, "bhv_idle_water_wave_loop", smlua_func_bhv_idle_water_wave_loop);
    smlua_bind_function(L, "bhv_init_changing_water_level_loop", smlua_func_bhv_init_changing_water_level_loop);
    smlua_bind_function(L, "bhv_intro_lakitu_loop", smlua_func_bhv_intro_lakitu_loop);
    smlua_bind_function(L, "bhv_intro_peach_loop", smlua_func_bhv_intro_peach_loop);
    smlua_bind_function(L, "bhv_intro_scene_loop", smlua_func_bhv_intro_scene_loop);
    smlua_bind_function(L, "bhv_invisible_objects_under_bridge_init", smlua_func_bhv_invisible_objects_under_bridge_init);
    smlua_bind_function(L, "bhv_invisible_objects_under_bridge_loop", smlua_func_bhv_invisible_objects_under_bridge_loop);
    smlua_bind_function(L, "bhv_jet_stream_loop", smlua_func_bhv_jet_stream_loop);
    smlua_bind_function(L, "bhv_jet_stream_ring_spawner_loop", smlua_func_bhv_jet_stream_ring_spawner_loop);
    smlua_bind_function(L, "bhv_jet_stream_water_ring_init", smlua_func_bhv_jet_stream_water_ring_init);
    smlua_bind_function(L, "bhv_jet_stream_water_ring_loop", smlua_func_bhv_jet_stream_water_ring_loop);
    smlua_bind_function(L, "bhv_jrb_floating_box_loop", smlua_func_bhv_jrb_floating_box_loop);
    smlua_bind_function(L, "bhv_jrb_sliding_box_loop", smlua_func_bhv_jrb_sliding_box_loop);
    smlua_bind_function(L, "bhv_jumping_box_loop", smlua_func_bhv_jumping_box_loop);
    smlua_bind_function(L, "bhv_kickable_board_loop", smlua_func_bhv_kickable_board_loop);
    smlua_bind_function(L, "bhv_king_bobomb_loop", smlua_func_bhv_king_bobomb_loop);
    smlua_bind_function(L, "bhv_klepto_init", smlua_func_bhv_klepto_init);
    smlua_bind_function(L, "bhv_klepto_update", smlua_func_bhv_klepto_update);
    smlua_bind_function(L, "bhv_koopa_init", smlua_func_bhv_koopa_init);
    smlua_bind_function(L, "bhv_koopa_race_endpoint_update", smlua_func_bhv_koopa_race_endpoint_update);
    smlua_bind_function(L, "bhv_koopa_shell_flame_loop", smlua_func_bhv_koopa_shell_flame_loop);
    smlua_bind_function(L, "bhv_koopa_shell_loop", smlua_func_bhv_koopa_shell_loop);
    smlua_bind_function(L, "bhv_koopa_shell_underwater_loop", smlua_func_bhv_koopa_shell_underwater_loop);
    smlua_bind_function(L, "bhv_koopa_update", smlua_func_bhv_koopa_update);
    smlua_bind_function(L, "bhv_large_bomp_init", smlua_func_bhv_large_bomp_init);
    smlua_bind_function(L, "bhv_large_bomp_loop", smlua_func_bhv_large_bomp_loop);
    smlua_bind_function(L, "bhv_lll_bowser_puzzle_loop", smlua_func_bhv_lll_bowser_puzzle_loop);
    smlua_bind_function(L, "bhv_lll_bowser_puzzle_piece_loop", smlua_func_bhv_lll_bowser_puzzle_piece_loop);
    smlua_bind_function(L, "bhv_lll_drawbridge_loop", smlua_func_bhv_lll_drawbridge_loop);
    smlua_bind_function(L, "bhv_lll_drawbridge_spawner_init", smlua_func_bhv_lll_drawbridge_spawner_init);
    smlua_bind_function(L, "bhv_lll_drawbridge_spawner_loop", smlua_func_bhv_lll_drawbridge_spawner_loop);
    smlua_bind_function(L, "bhv_lll_floating_wood_bridge_loop", smlua_func_bhv_lll_floating_wood_bridge_loop);
    smlua_bind_function(L, "bhv_lll_moving_octagonal_mesh_platform_loop", smlua_func_bhv_lll_moving_octagonal_mesh_platform_loop);
    smlua_bind_function(L, "bhv_lll_rolling_log_init", smlua_func_bhv_lll_rolling_log_init);
    smlua_bind_function(L, "bhv_lll_rotating_block_fire_bars_loop", smlua_func_bhv_lll_rotating_block_fire_bars_loop);
    smlua_bind_function(L, "bhv_lll_rotating_hex_flame_loop", smlua_func_bhv_lll_rotating_hex_flame_loop);
    smlua_bind_function(L, "bhv_lll_rotating_hexagonal_ring_loop", smlua_func_bhv_lll_rotating_hexagonal_ring_loop);
    smlua_bind_function(L, "bhv_lll_sinking_rectangular_platform_loop", smlua_func_bhv_lll_sinking_rectangular_platform_loop);
    smlua_bind_function(L, "bhv_lll_sinking_rock_block_loop", smlua_func_bhv_lll_sinking_rock_block_loop);
    smlua_bind_function(L, "bhv_lll_sinking_square_platforms_loop", smlua_func_bhv_lll_sinking_square_platforms_loop);
    smlua_bind_function(L, "bhv_lll_wood_piece_loop", smlua_func_bhv_lll_wood_piece_loop);
    smlua_bind_function(L, "bhv_mad_piano_update", smlua_func_bhv_mad_piano_update);
    smlua_bind_function(L, "bhv_manta_ray_init", smlua_func_bhv_manta_ray_init);
    smlua_bind_function(L, "bhv_manta_ray_loop", smlua_func_bhv_manta_ray_loop);
    smlua_bind_function(L, "bhv_manta_ray_water_ring_init", smlua_func_bhv_manta_ray_water_ring_init);
    smlua_bind_function(L, "bhv_manta_ray_water_ring_loop", smlua_func_bhv_manta_ray_water_ring_loop);
    smlua_bind_function(L, "bhv_menu_button_init", smlua_func_bhv_menu_button_init);
    smlua_bind_function(L, "bhv_menu_button_loop", smlua_func_bhv_menu_button_loop);
    smlua_bind_function(L, "bhv_menu_button_manager_init", smlua_func_bhv_menu_button_manager_init);
    smlua_bind_function(L, "bhv_menu_button_manager_loop", smlua_func_bhv_menu_button_manager_loop);
    smlua_bind_function(L, "bhv_merry_go_round_boo_manager_loop", smlua_func_bhv_merry_go_round_boo_manager_loop);
    smlua_bind_function(L, "bhv_merry_go_round_loop", smlua_func_bhv_merry_go_round_loop);
    smlua_bind_function(L, "bhv_metal_cap_init", smlua_func_bhv_metal_cap_init);
    smlua_bind_function(L, "bhv_metal_cap_loop", smlua_func_bhv_metal_cap_loop);
    smlua_bind_function(L, "bhv_mips_init", smlua_func_bhv_mips_init);
    smlua_bind_function(L, "bhv_mips_loop", smlua_func_bhv_mips_loop);
    smlua_bind_function(L, "bhv_moat_grills_loop", smlua_func_bhv_moat_grills_loop);
    smlua_bind_function(L, "bhv_moneybag_hidden_loop", smlua_func_bhv_moneybag_hidden_loop);
    smlua_bind_function(L, "bhv_moneybag_init", smlua_func_bhv_moneybag_init);
    smlua_bind_function(L, "bhv_moneybag_loop", smlua_func_bhv_moneybag_loop);
    smlua_bind_function(L, "bhv_monty_mole_hole_update", smlua_func_bhv_monty_mole_hole_update);
    smlua_bind_function(L, "bhv_monty_mole_init", smlua_func_bhv_monty_mole_init);
    smlua_bind_function(L, "bhv_monty_mole_rock_update", smlua_func_bhv_monty_mole_rock_update);
    smlua_bind_function(L, "bhv_monty_mole_update", smlua_func_bhv_monty_mole_update);
    smlua_bind_function(L, "bhv_moving_blue_coin_init", smlua_func_bhv_moving_blue_coin_init);
    smlua_bind_function(L, "bhv_moving_blue_coin_loop", smlua_func_bhv_moving_blue_coin_loop);
    smlua_bind_function(L, "bhv_moving_yellow_coin_init", smlua_func_bhv_moving_yellow_coin_init);
    smlua_bind_function(L, "bhv_moving_yellow_coin_loop", smlua_func_bhv_moving_yellow_coin_loop);
    smlua_bind_function(L, "bhv_mr_blizzard_init", smlua_func_bhv_mr_blizzard_init);
    smlua_bind_function(L, "bhv_mr_blizzard_snowball", smlua_func_bhv_mr_blizzard_snowball);
    smlua_bind_function(L, "bhv_mr_blizzard_update", smlua_func_bhv_mr_blizzard_update);
    smlua_bind_function(L, "bhv_mr_i_body_loop", smlua_func_bhv_mr_i_body_loop);
    smlua_bind_function(L, "bhv_mr_i_loop", smlua_func_bhv_mr_i_loop);
    smlua_bind_function(L, "bhv_mr_i_particle_loop", smlua_func_bhv_mr_i_particle_loop);
    smlua_bind_function(L, "bhv_normal_cap_init", smlua_func_bhv_normal_cap_init);
    smlua_bind_function(L, "bhv_normal_cap_loop", smlua_func_bhv_normal_cap_loop);
    smlua_bind_function(L, "bhv_object_bubble_init", smlua_func_bhv_object_bubble_init);
    smlua_bind_function(L, "bhv_object_bubble_loop", smlua_func_bhv_object_bubble_loop);
    smlua_bind_function(L, "bhv_object_water_wave_init", smlua_func_bhv_object_water_wave_init);
    smlua_bind_function(L, "bhv_object_water_wave_loop", smlua_func_bhv_object_water_wave_loop);
    smlua_bind_function(L, "bhv_openable_cage_door_loop", smlua_func_bhv_openable_cage_door_loop);
    smlua_bind_function(L, "bhv_openable_grill_loop", smlua_func_bhv_openable_grill_loop);
    smlua_bind_function(L, "bhv_orange_number_init", smlua_func_bhv_orange_number_init);
    smlua_bind_function(L, "bhv_orange_number_loop", smlua_func_bhv_orange_number_loop);
    smlua_bind_function(L, "bhv_particle_init", smlua_func_bhv_particle_init);
    smlua_bind_function(L, "bhv_particle_loop", smlua_func_bhv_particle_loop);
    smlua_bind_function(L, "bhv_penguin_race_finish_line_update", smlua_func_bhv_penguin_race_finish_line_update);
    smlua_bind_function(L, "bhv_penguin_race_shortcut_check_update", smlua_func_bhv_penguin_race_shortcut_check_update);
    smlua_bind_function(L, "bhv_piranha_particle_loop", smlua_func_bhv_piranha_particle_loop);
    smlua_bind_function(L, "bhv_piranha_plant_bubble_loop", smlua_func_bhv_piranha_plant_bubble_loop);
    smlua_bind_function(L, "bhv_piranha_plant_loop", smlua_func_bhv_piranha_plant_loop);
    smlua_bind_function(L, "bhv_piranha_plant_waking_bubbles_loop", smlua_func_bhv_piranha_plant_waking_bubbles_loop);
    smlua_bind_function(L, "bhv_platform_normals_init", smlua_func_bhv_platform_normals_init);
    smlua_bind_function(L, "bhv_platform_on_track_init", smlua_func_bhv_platform_on_track_init);
    smlua_bind_function(L, "bhv_platform_on_track_update", smlua_func_bhv_platform_on_track_update);
    smlua_bind_function(L, "bhv_play_music_track_when_touched_loop", smlua_func_bhv_play_music_track_when_touched_loop);
    smlua_bind_function(L, "bhv_pokey_body_part_update", smlua_func_bhv_pokey_body_part_update);
    smlua_bind_function(L, "bhv_pokey_update", smlua_func_bhv_pokey_update);
    smlua_bind_function(L, "bhv_pole_base_loop", smlua_func_bhv_pole_base_loop);
    smlua_bind_function(L, "bhv_pole_init", smlua_func_bhv_pole_init);
    smlua_bind_function(L, "bhv_pound_tiny_star_particle_init", smlua_func_bhv_pound_tiny_star_particle_init);
    smlua_bind_function(L, "bhv_pound_tiny_star_particle_loop", smlua_func_bhv_pound_tiny_star_particle_loop);
    smlua_bind_function(L, "bhv_pound_white_puffs_init", smlua_func_bhv_pound_white_puffs_init);
    smlua_bind_function(L, "bhv_punch_tiny_triangle_init", smlua_func_bhv_punch_tiny_triangle_init);
    smlua_bind_function(L, "bhv_punch_tiny_triangle_loop", smlua_func_bhv_punch_tiny_triangle_loop);
    smlua_bind_function(L, "bhv_purple_switch_loop", smlua_func_bhv_purple_switch_loop);
    smlua_bind_function(L, "bhv_pushable_loop", smlua_func_bhv_pushable_loop);
    smlua_bind_function(L, "bhv_pyramid_elevator_init", smlua_func_bhv_pyramid_elevator_init);
    smlua_bind_function(L, "bhv_pyramid_elevator_loop", smlua_func_bhv_pyramid_elevator_loop);
    smlua_bind_function(L, "bhv_pyramid_elevator_trajectory_marker_ball_loop", smlua_func_bhv_pyramid_elevator_trajectory_marker_ball_loop);
    smlua_bind_function(L, "bhv_pyramid_pillar_touch_detector_loop", smlua_func_bhv_pyramid_pillar_touch_detector_loop);
    smlua_bind_function(L, "bhv_pyramid_top_fragment_init", smlua_func_bhv_pyramid_top_fragment_init);
    smlua_bind_function(L, "bhv_pyramid_top_fragment_loop", smlua_func_bhv_pyramid_top_fragment_loop);
    smlua_bind_function(L, "bhv_pyramid_top_init", smlua_func_bhv_pyramid_top_init);
    smlua_bind_function(L, "bhv_pyramid_top_loop", smlua_func_bhv_pyramid_top_loop);
    smlua_bind_function(L, "bhv_racing_penguin_init", smlua_func_bhv_racing_penguin_init);
    smlua_bind_function(L, "bhv_racing_penguin_update", smlua_func_bhv_racing_penguin_update);
    smlua_bind_function(L, "bhv_recovery_heart_loop", smlua_func_bhv_recovery_heart_loop);
    smlua_bind_function(L, "bhv_red_coin_init", smlua_func_bhv_red_coin_init);
    smlua_bind_function(L, "bhv_red_coin_loop", smlua_func_bhv_red_coin_loop);
    smlua_bind_function(L, "bhv_red_coin_star_marker_init", smlua_func_bhv_red_coin_star_marker_init);
    smlua_bind_function(L, "bhv_respawner_loop", smlua_func_bhv_respawner_loop);
    smlua_bind_function(L, "bhv_rolling_log_loop", smlua_func_bhv_rolling_log_loop);
    smlua_bind_function(L, "bhv_rotating_clock_arm_loop", smlua_func_bhv_rotating_clock_arm_loop);
    smlua_bind_function(L, "bhv_rotating_exclamation_box_loop", smlua_func_bhv_rotating_exclamation_box_loop);
    smlua_bind_function(L, "bhv_rotating_octagonal_plat_init", smlua_func_bhv_rotating_octagonal_plat_init);
    smlua_bind_function(L, "bhv_rotating_octagonal_plat_loop", smlua_func_bhv_rotating_octagonal_plat_loop);
    smlua_bind_function(L, "bhv_rotating_platform_loop", smlua_func_bhv_rotating_platform_loop);
    smlua_bind_function(L, "bhv_rr_cruiser_wing_init", smlua_func_bhv_rr_cruiser_wing_init);
    smlua_bind_function(L, "bhv_rr_cruiser_wing_loop", smlua_func_bhv_rr_cruiser_wing_loop);
    smlua_bind_function(L, "bhv_rr_rotating_bridge_platform_loop", smlua_func_bhv_rr_rotating_bridge_platform_loop);
    smlua_bind_function(L, "bhv_sand_sound_loop", smlua_func_bhv_sand_sound_loop);
    smlua_bind_function(L, "bhv_scuttlebug_loop", smlua_func_bhv_scuttlebug_loop);
    smlua_bind_function(L, "bhv_scuttlebug_spawn_loop", smlua_func_bhv_scuttlebug_spawn_loop);
    smlua_bind_function(L, "bhv_seaweed_bundle_init", smlua_func_bhv_seaweed_bundle_init);
    smlua_bind_function(L, "bhv_seaweed_init", smlua_func_bhv_seaweed_init);
    smlua_bind_function(L, "bhv_seesaw_platform_init", smlua_func_bhv_seesaw_platform_init);
    smlua_bind_function(L, "bhv_seesaw_platform_update", smlua_func_bhv_seesaw_platform_update);
    smlua_bind_function(L, "bhv_shallow_water_splash_init", smlua_func_bhv_shallow_water_splash_init);
    smlua_bind_function(L, "bhv_ship_part_3_loop", smlua_func_bhv_ship_part_3_loop);
    smlua_bind_function(L, "bhv_skeeter_update", smlua_func_bhv_skeeter_update);
    smlua_bind_function(L, "bhv_skeeter_wave_update", smlua_func_bhv_skeeter_wave_update);
    smlua_bind_function(L, "bhv_sl_snowman_wind_loop", smlua_func_bhv_sl_snowman_wind_loop);
    smlua_bind_function(L, "bhv_sl_walking_penguin_loop", smlua_func_bhv_sl_walking_penguin_loop);
    smlua_bind_function(L, "bhv_sliding_plat_2_init", smlua_func_bhv_sliding_plat_2_init);
    smlua_bind_function(L, "bhv_sliding_plat_2_loop", smlua_func_bhv_sliding_plat_2_loop);
    smlua_bind_function(L, "bhv_sliding_snow_mound_loop", smlua_func_bhv_sliding_snow_mound_loop);
    smlua_bind_function(L, "bhv_small_bomp_init", smlua_func_bhv_small_bomp_init);
    smlua_bind_function(L, "bhv_small_bomp_loop", smlua_func_bhv_small_bomp_loop);
    smlua_bind_function(L, "bhv_small_bubbles_loop", smlua_func_bhv_small_bubbles_loop);
    smlua_bind_function(L, "bhv_small_bully_init", smlua_func_bhv_small_bully_init);
    smlua_bind_function(L, "bhv_small_penguin_loop", smlua_func_bhv_small_penguin_loop);
    smlua_bind_function(L, "bhv_small_piranha_flame_loop", smlua_func_bhv_small_piranha_flame_loop);
    smlua_bind_function(L, "bhv_small_water_wave_loop", smlua_func_bhv_small_water_wave_loop);
    smlua_bind_function(L, "bhv_snow_leaf_particle_spawn_init", smlua_func_bhv_snow_leaf_particle_spawn_init);
    smlua_bind_function(L, "bhv_snow_mound_spawn_loop", smlua_func_bhv_snow_mound_spawn_loop);
    smlua_bind_function(L, "bhv_snowmans_body_checkpoint_loop", smlua_func_bhv_snowmans_body_checkpoint_loop);
    smlua_bind_function(L, "bhv_snowmans_bottom_init", smlua_func_bhv_snowmans_bottom_init);
    smlua_bind_function(L, "bhv_snowmans_bottom_loop", smlua_func_bhv_snowmans_bottom_loop);
    smlua_bind_function(L, "bhv_snowmans_head_init", smlua_func_bhv_snowmans_head_init);
    smlua_bind_function(L, "bhv_snowmans_head_loop", smlua_func_bhv_snowmans_head_loop);
    smlua_bind_function(L, "bhv_snufit_balls_loop", smlua_func_bhv_snufit_balls_loop);
    smlua_bind_function(L, "bhv_snufit_loop", smlua_func_bhv_snufit_loop);
    smlua_bind_function(L, "bhv_sound_spawner_init", smlua_func_bhv_sound_spawner_init);
    smlua_bind_function(L, "bhv_sparkle_spawn_loop", smlua_func_bhv_sparkle_spawn_loop);
    smlua_bind_function(L, "bhv_spawn_star_no_level_exit", smlua_func_bhv_spawn_star_no_level_exit);
    smlua_bind_function(L, "bhv_spawned_star_init", smlua_func_bhv_spawned_star_init);
    smlua_bind_function(L, "bhv_spawned_star_loop", smlua_func_bhv_spawned_star_loop);
    smlua_bind_function(L, "bhv_spindel_init", smlua_func_bhv_spindel_init);
    smlua_bind_function(L, "bhv_spindel_loop", smlua_func_bhv_spindel_loop);
    smlua_bind_function(L, "bhv_spindrift_loop", smlua_func_bhv_spindrift_loop);
    smlua_bind_function(L, "bhv_spiny_update", smlua_func_bhv_spiny_update);
    smlua_bind_function(L, "bhv_squarish_path_moving_loop", smlua_func_bhv_squarish_path_moving_loop);
    smlua_bind_function(L, "bhv_squarish_path_parent_init", smlua_func_bhv_squarish_path_parent_init);
    smlua_bind_function(L, "bhv_squarish_path_parent_loop", smlua_func_bhv_squarish_path_parent_loop);
    smlua_bind_function(L, "bhv_squishable_platform_loop", smlua_func_bhv_squishable_platform_loop);
    smlua_bind_function(L, "bhv_ssl_moving_pyramid_wall_init", smlua_func_bhv_ssl_moving_pyramid_wall_init);
    smlua_bind_function(L, "bhv_ssl_moving_pyramid_wall_loop", smlua_func_bhv_ssl_moving_pyramid_wall_loop);
    smlua_bind_function(L, "bhv_star_door_loop", smlua_func_bhv_star_door_loop);
    smlua_bind_function(L, "bhv_star_door_loop_2", smlua_func_bhv_star_door_loop_2);
    smlua_bind_function(L, "bhv_star_key_collection_puff_spawner_loop", smlua_func_bhv_star_key_collection_puff_spawner_loop);
    smlua_bind_function(L, "bhv_star_spawn_init", smlua_func_bhv_star_spawn_init);
    smlua_bind_function(L, "bhv_star_spawn_loop", smlua_func_bhv_star_spawn_loop);
    smlua_bind_function(L, "bhv_static_checkered_platform_loop", smlua_func_bhv_static_checkered_platform_loop);
    smlua_bind_function(L, "bhv_strong_wind_particle_loop", smlua_func_bhv_strong_wind_particle_loop);
    smlua_bind_function(L, "bhv_sunken_ship_part_loop", smlua_func_bhv_sunken_ship_part_loop);
    smlua_bind_function(L, "bhv_sushi_shark_collision_loop", smlua_func_bhv_sushi_shark_collision_loop);
    smlua_bind_function(L, "bhv_sushi_shark_loop", smlua_func_bhv_sushi_shark_loop);
    smlua_bind_function(L, "bhv_swing_platform_init", smlua_func_bhv_swing_platform_init);
    smlua_bind_function(L, "bhv_swing_platform_update", smlua_func_bhv_swing_platform_update);
    smlua_bind_function(L, "bhv_swoop_update", smlua_func_bhv_swoop_update);
    smlua_bind_function(L, "bhv_tank_fish_group_loop", smlua_func_bhv_tank_fish_group_loop);
    smlua_bind_function(L, "bhv_temp_coin_loop", smlua_func_bhv_temp_coin_loop);
    smlua_bind_function(L, "bhv_thi_bowling_ball_spawner_loop", smlua_func_bhv_thi_bowling_ball_spawner_loop);
    smlua_bind_function(L, "bhv_thi_huge_island_top_loop", smlua_func_bhv_thi_huge_island_top_loop);
    smlua_bind_function(L, "bhv_thi_tiny_island_top_loop", smlua_func_bhv_thi_tiny_island_top_loop);
    smlua_bind_function(L, "bhv_tilting_bowser_lava_platform_init", smlua_func_bhv_tilting_bowser_lava_platform_init);
    smlua_bind_function(L, "bhv_tilting_inverted_pyramid_loop", smlua_func_bhv_tilting_inverted_pyramid_loop);
    smlua_bind_function(L, "bhv_tiny_star_particles_init", smlua_func_bhv_tiny_star_particles_init);
    smlua_bind_function(L, "bhv_tower_door_loop", smlua_func_bhv_tower_door_loop);
    smlua_bind_function(L, "bhv_tower_platform_group_init", smlua_func_bhv_tower_platform_group_init);
    smlua_bind_function(L, "bhv_tower_platform_group_loop", smlua_func_bhv_tower_platform_group_loop);
    smlua_bind_function(L, "bhv_tox_box_loop", smlua_func_bhv_tox_box_loop);
    smlua_bind_function(L, "bhv_track_ball_update", smlua_func_bhv_track_ball_update);
    smlua_bind_function(L, "bhv_treasure_chest_bottom_init", smlua_func_bhv_treasure_chest_bottom_init);
    smlua_bind_function(L, "bhv_treasure_chest_bottom_loop", smlua_func_bhv_treasure_chest_bottom_loop);
    smlua_bind_function(L, "bhv_treasure_chest_init", smlua_func_bhv_treasure_chest_init);
    smlua_bind_function(L, "bhv_treasure_chest_jrb_init", smlua_func_bhv_treasure_chest_jrb_init);
    smlua_bind_function(L, "bhv_treasure_chest_jrb_loop", smlua_func_bhv_treasure_chest_jrb_loop);
    smlua_bind_function(L, "bhv_treasure_chest_loop", smlua_func_bhv_treasure_chest_loop);
    smlua_bind_function(L, "bhv_treasure_chest_ship_init", smlua_func_bhv_treasure_chest_ship_init);
    smlua_bind_function(L, "bhv_treasure_chest_ship_loop", smlua_func_bhv_treasure_chest_ship_loop);
    smlua_bind_function(L, "bhv_treasure_chest_top_loop", smlua_func_bhv_treasure_chest_top_loop);
    smlua_bind_function(L, "bhv_tree_snow_or_leaf_loop", smlua_func_bhv_tree_snow_or_leaf_loop);
    smlua_bind_function(L, "bhv_triplet_butterfly_update", smlua_func_bhv_triplet_butterfly_update);
    smlua_bind_function(L, "bhv_ttc_2d_rotator_init", smlua_func_bhv_ttc_2d_rotator_init);
    smlua_bind_function(L, "bhv_ttc_2d_rotator_update", smlua_func_bhv_ttc_2d_rotator_update);
    smlua_bind_function(L, "bhv_ttc_cog_init", smlua_func_bhv_ttc_cog_init);
    smlua_bind_function(L, "bhv_ttc_cog_update", smlua_func_bhv_ttc_cog_update);
    smlua_bind_function(L, "bhv_ttc_elevator_init", smlua_func_bhv_ttc_elevator_init);
    smlua_bind_function(L, "bhv_ttc_elevator_update", smlua_func_bhv_ttc_elevator_update);
    smlua_bind_function(L, "bhv_ttc_moving_bar_init", smlua_func_bhv_ttc_moving_bar_init);
    smlua_bind_function(L, "bhv_ttc_moving_bar_update", smlua_func_bhv_ttc_moving_bar_update);
    smlua_bind_function(L, "bhv_ttc_pendulum_init", smlua_func_bhv_ttc_pendulum_init);
    smlua_bind_function(L, "bhv_ttc_pendulum_update", smlua_func_bhv_ttc_pendulum_update);
    smlua_bind_function(L, "bhv_ttc_pit_block_init", smlua_func_bhv_ttc_pit_block_init);
    smlua_bind_function(L, "bhv_ttc_pit_block_update", smlua_func_bhv_ttc_pit_block_update);
    smlua_bind_function(L, "bhv_ttc_rotating_solid_init", smlua_func_bhv_ttc_rotating_solid_init);
    smlua_bind_function(L, "bhv_ttc_rotating_solid_update", smlua_func_bhv_ttc_rotating_solid_update);
    smlua_bind_function(L, "bhv_ttc_spinner_update", smlua_func_bhv_ttc_spinner_update);
    smlua_bind_function(L, "bhv_ttc_treadmill_init", smlua_func_bhv_ttc_treadmill_init);
    smlua_bind_function(L, "bhv_ttc_treadmill_update", smlua_func_bhv_ttc_treadmill_update);
    smlua_bind_function(L, "bhv_ttm_rolling_log_init", smlua_func_bhv_ttm_rolling_log_init);
    smlua_bind_function(L, "bhv_tumbling_bridge_loop", smlua_func_bhv_tumbling_bridge_loop);
    smlua_bind_function(L, "bhv_tumbling_bridge_platform_loop", smlua_func_bhv_tumbling_bridge_platform_loop);
    smlua_bind_function(L, "bhv_tuxies_mother_loop", smlua_func_bhv_tuxies_mother_loop);
    smlua_bind_function(L, "bhv_tweester_loop", smlua_func_bhv_tweester_loop);
    smlua_bind_function(L, "bhv_tweester_sand_particle_loop", smlua_func_bhv_tweester_sand_particle_loop);
    smlua_bind_function(L, "bhv_ukiki_cage_loop", smlua_func_bhv_ukiki_cage_loop);
    smlua_bind_function(L, "bhv_ukiki_cage_star_loop", smlua_func_bhv_ukiki_cage_star_loop);
    smlua_bind_function(L, "bhv_ukiki_init", smlua_func_bhv_ukiki_init);
    smlua_bind_function(L, "bhv_ukiki_loop", smlua_func_bhv_ukiki_loop);
    smlua_bind_function(L, "bhv_unagi_init", smlua_func_bhv_unagi_init);
    smlua_bind_function(L, "bhv_unagi_loop", smlua_func_bhv_unagi_loop);
    smlua_bind_function(L, "bhv_unagi_subobject_loop", smlua_func_bhv_unagi_subobject_loop);
    smlua_bind_function(L, "bhv_unused_particle_spawn_loop", smlua_func_bhv_unused_particle_spawn_loop);
    smlua_bind_function(L, "bhv_unused_poundable_platform", smlua_func_bhv_unused_poundable_platform);
    smlua_bind_function(L, "bhv_vanish_cap_init", smlua_func_bhv_vanish_cap_init);
    smlua_bind_function(L, "bhv_volcano_flames_loop", smlua_func_bhv_volcano_flames_loop);
    smlua_bind_function(L, "bhv_volcano_sound_loop", smlua_func_bhv_volcano_sound_loop);
    smlua_bind_function(L, "bhv_volcano_trap_loop", smlua_func_bhv_volcano_trap_loop);
    smlua_bind_function(L, "bhv_wall_tiny_star_particle_loop", smlua_func_bhv_wall_tiny_star_particle_loop);
    smlua_bind_function(L, "bhv_warp_loop", smlua_func_bhv_warp_loop);
    smlua_bind_function(L, "bhv_water_air_bubble_init", smlua_func_bhv_water_air_bubble_init);
    smlua_bind_function(L, "bhv_water_air_bubble_loop", smlua_func_bhv_water_air_bubble_loop);
    smlua_bind_function(L, "bhv_water_bomb_cannon_loop", smlua_func_bhv_water_bomb_cannon_loop);
    smlua_bind_function(L, "bhv_water_bomb_shadow_update", smlua_func_bhv_water_bomb_shadow_update);
    smlua_bind_function(L, "bhv_water_bomb_spawner_update", smlua_func_bhv_water_bomb_spawner_update);
    smlua_bind_function(L, "bhv_water_bomb_update", smlua_func_bhv_water_bomb_update);
    smlua_bind_function(L, "bhv_water_droplet_loop", smlua_func_bhv_water_droplet_loop);
    smlua_bind_function(L, "bhv_water_droplet_splash_init", smlua_func_bhv_water_droplet_splash_init);
    smlua_bind_function(L, "bhv_water_level_diamond_loop", smlua_func_bhv_water_level_diamond_loop);
    smlua_bind_function(L, "bhv_water_level_pillar_init", smlua_func_bhv_water_level_pillar_init);
    smlua_bind_function(L, "bhv_water_level_pillar_loop", smlua_func_bhv_water_level_pillar_loop);
    smlua_bind_function(L, "bhv_water_mist_2_loop", smlua_func_bhv_water_mist_2_loop);
    smlua_bind_function(L, "bhv_water_mist_loop", smlua_func_bhv_water_mist_loop);
    smlua_bind_function(L, "bhv_water_mist_spawn_loop", smlua_func_bhv_water_mist_spawn_loop);
    smlua_bind_function(L, "bhv_water_splash_spawn_droplets", smlua_func_bhv_water_splash_spawn_droplets);
    smlua_bind_function(L, "bhv_water_waves_init", smlua_func_bhv_water_waves_init);
    smlua_bind_function(L, "bhv_waterfall_sound_loop", smlua_func_bhv_waterfall_sound_loop);
    smlua_bind_function(L, "bhv_wave_trail_shrink", smlua_func_bhv_wave_trail_shrink);
    smlua_bind_function(L, "bhv_wdw_express_elevator_loop", smlua_func_bhv_wdw_express_elevator_loop);
    smlua_bind_function(L, "bhv_wf_breakable_wall_loop", smlua_func_bhv_wf_breakable_wall_loop);
    smlua_bind_function(L, "bhv_wf_elevator_tower_platform_loop", smlua_func_bhv_wf_elevator_tower_platform_loop);
    smlua_bind_function(L, "bhv_wf_rotating_wooden_platform_init", smlua_func_bhv_wf_rotating_wooden_platform_init);
    smlua_bind_function(L, "bhv_wf_rotating_wooden_platform_loop", smlua_func_bhv_wf_rotating_wooden_platform_loop);
    smlua_bind_function(L, "bhv_wf_sliding_platform_init", smlua_func_bhv_wf_sliding_platform_init);
    smlua_bind_function(L, "bhv_wf_sliding_platform_loop", smlua_func_bhv_wf_sliding_platform_loop);
    smlua_bind_function(L, "bhv_wf_sliding_tower_platform_loop", smlua_func_bhv_wf_sliding_tower_platform_loop);
    smlua_bind_function(L, "bhv_wf_solid_tower_platform_loop", smlua_func_bhv_wf_solid_tower_platform_loop);
    smlua_bind_function(L, "bhv_whirlpool_init", smlua_func_bhv_whirlpool_init);
    smlua_bind_function(L, "bhv_whirlpool_loop", smlua_func_bhv_whirlpool_loop);
    smlua_bind_function(L, "bhv_white_puff_1_loop", smlua_func_bhv_white_puff_1_loop);
    smlua_bind_function(L, "bhv_white_puff_2_loop", smlua_func_bhv_white_puff_2_loop);
    smlua_bind_function(L, "bhv_white_puff_exploding_loop", smlua_func_bhv_white_puff_exploding_loop);
    smlua_bind_function(L, "bhv_white_puff_smoke_init", smlua_func_bhv_white_puff_smoke_init);
    smlua_bind_function(L, "bhv_whomp_loop", smlua_func_bhv_whomp_loop);
    smlua_bind_function(L, "bhv_wiggler_body_part_update", smlua_func_bhv_wiggler_body_part_update);
    smlua_bind_function(L, "bhv_wiggler_update", smlua_func_bhv_wiggler_update);
    smlua_bind_function(L, "bhv_wind_loop", smlua_func_bhv_wind_loop);
    smlua_bind_function(L, "bhv_wing_cap_init", smlua_func_bhv_wing_cap_init);
    smlua_bind_function(L, "bhv_wing_vanish_cap_loop", smlua_func_bhv_wing_vanish_cap_loop);
    smlua_bind_function(L, "bhv_wooden_post_update", smlua_func_bhv_wooden_post_update);
    smlua_bind_function(L, "bhv_yellow_coin_init", smlua_func_bhv_yellow_coin_init);
    smlua_bind_function(L, "bhv_yellow_coin_loop", smlua_func_bhv_yellow_coin_loop);
    smlua_bind_function(L, "bhv_yoshi_init", smlua_func_bhv_yoshi_init);
    smlua_bind_function(L, "bhv_yoshi_loop", smlua_func_bhv_yoshi_loop);
    smlua_bind_function(L, "check_if_moving_over_floor", smlua_func_check_if_moving_over_floor);
    smlua_bind_function(L, "clear_particle_flags", smlua_func_clear_particle_flags);
    smlua_bind_function(L, "common_anchor_mario_behavior", smlua_func_common_anchor_mario_behavior);
    smlua_bind_function(L, "cur_obj_spawn_strong_wind_particles", smlua_func_cur_obj_spawn_strong_wind_particles);
    //smlua_bind_function(L, "geo_bits_bowser_coloring", smlua_func_geo_bits_bowser_coloring); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_move_mario_part_from_parent", smlua_func_geo_move_mario_part_from_parent); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_scale_bowser_key", smlua_func_geo_scale_bowser_key); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_snufit_move_mask", smlua_func_geo_snufit_move_mask); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_snufit_scale_body", smlua_func_geo_snufit_scale_body); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_switch_bowser_eyes", smlua_func_geo_switch_bowser_eyes); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_switch_tuxie_mother_eyes", smlua_func_geo_switch_tuxie_mother_eyes); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_update_body_rot_from_parent", smlua_func_geo_update_body_rot_from_parent); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_update_held_mario_pos", smlua_func_geo_update_held_mario_pos); <--- UNIMPLEMENTED
    smlua_bind_function(L, "mario_moving_fast_enough_to_make_piranha_plant_bite", smlua_func_mario_moving_fast_enough_to_make_piranha_plant_bite);
    smlua_bind_function(L, "obj_set_secondary_camera_focus", smlua_func_obj_set_secondary_camera_focus);
    smlua_bind_function(L, "play_penguin_walking_sound", smlua_func_play_penguin_walking_sound);
    smlua_bind_function(L, "spawn_default_star", smlua_func_spawn_default_star);
    smlua_bind_function(L, "spawn_mist_from_global", smlua_func_spawn_mist_from_global);
    smlua_bind_function(L, "spawn_mist_particles_variable", smlua_func_spawn_mist_particles_variable);
    smlua_bind_function(L, "spawn_no_exit_star", smlua_func_spawn_no_exit_star);
    smlua_bind_function(L, "spawn_red_coin_cutscene_star", smlua_func_spawn_red_coin_cutscene_star);
    smlua_bind_function(L, "spawn_triangle_break_particles", smlua_func_spawn_triangle_break_particles);
    smlua_bind_function(L, "spawn_wind_particles", smlua_func_spawn_wind_particles);
    smlua_bind_function(L, "tox_box_move", smlua_func_tox_box_move);
    smlua_bind_function(L, "update_angle_from_move_flags", smlua_func_update_angle_from_move_flags);
    smlua_bind_function(L, "vec3f_copy_2", smlua_func_vec3f_copy_2);

    // behavior_table.h
    smlua_bind_function(L, "get_behavior_from_id", smlua_func_get_behavior_from_id);
    smlua_bind_function(L, "get_behavior_name_from_id", smlua_func_get_behavior_name_from_id);
    smlua_bind_function(L, "get_id_from_behavior", smlua_func_get_id_from_behavior);
    smlua_bind_function(L, "get_id_from_behavior_name", smlua_func_get_id_from_behavior_name);
    smlua_bind_function(L, "get_id_from_vanilla_behavior", smlua_func_get_id_from_vanilla_behavior);

    // camera.h
    smlua_bind_function(L, "approach_camera_height", smlua_func_approach_camera_height);
    smlua_bind_function(L, "approach_f32_asymptotic", smlua_func_approach_f32_asymptotic);
    smlua_bind_function(L, "approach_f32_asymptotic_bool", smlua_func_approach_f32_asymptotic_bool);
    smlua_bind_function(L, "approach_s16_asymptotic", smlua_func_approach_s16_asymptotic);
    smlua_bind_function(L, "approach_s16_asymptotic_bool", smlua_func_approach_s16_asymptotic_bool);
    smlua_bind_function(L, "approach_vec3f_asymptotic", smlua_func_approach_vec3f_asymptotic);
    smlua_bind_function(L, "calc_abs_dist", smlua_func_calc_abs_dist);
    smlua_bind_function(L, "calc_hor_dist", smlua_func_calc_hor_dist);
    smlua_bind_function(L, "calculate_angles", smlua_func_calculate_angles);
    smlua_bind_function(L, "calculate_pitch", smlua_func_calculate_pitch);
    smlua_bind_function(L, "calculate_yaw", smlua_func_calculate_yaw);
    smlua_bind_function(L, "cam_select_alt_mode", smlua_func_cam_select_alt_mode);
    smlua_bind_function(L, "camera_approach_f32_symmetric", smlua_func_camera_approach_f32_symmetric);
    smlua_bind_function(L, "camera_approach_f32_symmetric_bool", smlua_func_camera_approach_f32_symmetric_bool);
    smlua_bind_function(L, "camera_approach_s16_symmetric_bool", smlua_func_camera_approach_s16_symmetric_bool);
    smlua_bind_function(L, "camera_course_processing", smlua_func_camera_course_processing);
    smlua_bind_function(L, "camera_set_use_course_specific_settings", smlua_func_camera_set_use_course_specific_settings);
    smlua_bind_function(L, "clamp_pitch", smlua_func_clamp_pitch);
    smlua_bind_function(L, "clamp_positions_and_find_yaw", smlua_func_clamp_positions_and_find_yaw);
    smlua_bind_function(L, "collide_with_walls", smlua_func_collide_with_walls);
    //smlua_bind_function(L, "cutscene_event", smlua_func_cutscene_event); <--- UNIMPLEMENTED
    smlua_bind_function(L, "cutscene_object", smlua_func_cutscene_object);
    smlua_bind_function(L, "cutscene_object_with_dialog", smlua_func_cutscene_object_with_dialog);
    smlua_bind_function(L, "cutscene_object_without_dialog", smlua_func_cutscene_object_without_dialog);
    smlua_bind_function(L, "cutscene_set_fov_shake_preset", smlua_func_cutscene_set_fov_shake_preset);
    smlua_bind_function(L, "cutscene_spawn_obj", smlua_func_cutscene_spawn_obj);
    smlua_bind_function(L, "find_c_buttons_pressed", smlua_func_find_c_buttons_pressed);
    smlua_bind_function(L, "find_mario_floor_and_ceil", smlua_func_find_mario_floor_and_ceil);
    //smlua_bind_function(L, "geo_camera_fov", smlua_func_geo_camera_fov); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_camera_main", smlua_func_geo_camera_main); <--- UNIMPLEMENTED
    smlua_bind_function(L, "get_cutscene_from_mario_status", smlua_func_get_cutscene_from_mario_status);
    smlua_bind_function(L, "handle_c_button_movement", smlua_func_handle_c_button_movement);
    smlua_bind_function(L, "is_range_behind_surface", smlua_func_is_range_behind_surface);
    smlua_bind_function(L, "is_within_100_units_of_mario", smlua_func_is_within_100_units_of_mario);
    smlua_bind_function(L, "move_mario_head_c_up", smlua_func_move_mario_head_c_up);
    smlua_bind_function(L, "next_lakitu_state", smlua_func_next_lakitu_state);
    smlua_bind_function(L, "obj_rotate_towards_point", smlua_func_obj_rotate_towards_point);
    smlua_bind_function(L, "object_pos_to_vec3f", smlua_func_object_pos_to_vec3f);
    smlua_bind_function(L, "offset_rotated", smlua_func_offset_rotated);
    smlua_bind_function(L, "offset_yaw_outward_radial", smlua_func_offset_yaw_outward_radial);
    smlua_bind_function(L, "play_camera_buzz_if_c_sideways", smlua_func_play_camera_buzz_if_c_sideways);
    smlua_bind_function(L, "play_camera_buzz_if_cbutton", smlua_func_play_camera_buzz_if_cbutton);
    smlua_bind_function(L, "play_camera_buzz_if_cdown", smlua_func_play_camera_buzz_if_cdown);
    smlua_bind_function(L, "play_cutscene", smlua_func_play_cutscene);
    smlua_bind_function(L, "play_sound_button_change_blocked", smlua_func_play_sound_button_change_blocked);
    smlua_bind_function(L, "play_sound_cbutton_down", smlua_func_play_sound_cbutton_down);
    smlua_bind_function(L, "play_sound_cbutton_side", smlua_func_play_sound_cbutton_side);
    smlua_bind_function(L, "play_sound_cbutton_up", smlua_func_play_sound_cbutton_up);
    smlua_bind_function(L, "play_sound_if_cam_switched_to_lakitu_or_mario", smlua_func_play_sound_if_cam_switched_to_lakitu_or_mario);
    smlua_bind_function(L, "play_sound_rbutton_changed", smlua_func_play_sound_rbutton_changed);
    smlua_bind_function(L, "radial_camera_input", smlua_func_radial_camera_input);
    smlua_bind_function(L, "random_vec3s", smlua_func_random_vec3s);
    smlua_bind_function(L, "reset_camera", smlua_func_reset_camera);
    smlua_bind_function(L, "resolve_geometry_collisions", smlua_func_resolve_geometry_collisions);
    smlua_bind_function(L, "rotate_camera_around_walls", smlua_func_rotate_camera_around_walls);
    smlua_bind_function(L, "rotate_in_xz", smlua_func_rotate_in_xz);
    smlua_bind_function(L, "rotate_in_yz", smlua_func_rotate_in_yz);
    smlua_bind_function(L, "scale_along_line", smlua_func_scale_along_line);
    smlua_bind_function(L, "select_mario_cam_mode", smlua_func_select_mario_cam_mode);
    smlua_bind_function(L, "set_cam_angle", smlua_func_set_cam_angle);
    smlua_bind_function(L, "set_camera_mode", smlua_func_set_camera_mode);
    smlua_bind_function(L, "set_camera_mode_fixed", smlua_func_set_camera_mode_fixed);
    smlua_bind_function(L, "set_camera_pitch_shake", smlua_func_set_camera_pitch_shake);
    smlua_bind_function(L, "set_camera_roll_shake", smlua_func_set_camera_roll_shake);
    smlua_bind_function(L, "set_camera_shake_from_hit", smlua_func_set_camera_shake_from_hit);
    smlua_bind_function(L, "set_camera_shake_from_point", smlua_func_set_camera_shake_from_point);
    smlua_bind_function(L, "set_camera_yaw_shake", smlua_func_set_camera_yaw_shake);
    smlua_bind_function(L, "set_environmental_camera_shake", smlua_func_set_environmental_camera_shake);
    smlua_bind_function(L, "set_fixed_cam_axis_sa_lobby", smlua_func_set_fixed_cam_axis_sa_lobby);
    smlua_bind_function(L, "set_fov_function", smlua_func_set_fov_function);
    smlua_bind_function(L, "set_fov_shake", smlua_func_set_fov_shake);
    smlua_bind_function(L, "set_fov_shake_from_point_preset", smlua_func_set_fov_shake_from_point_preset);
    smlua_bind_function(L, "set_handheld_shake", smlua_func_set_handheld_shake);
    smlua_bind_function(L, "set_or_approach_f32_asymptotic", smlua_func_set_or_approach_f32_asymptotic);
    smlua_bind_function(L, "set_or_approach_s16_symmetric", smlua_func_set_or_approach_s16_symmetric);
    smlua_bind_function(L, "set_or_approach_vec3f_asymptotic", smlua_func_set_or_approach_vec3f_asymptotic);
    smlua_bind_function(L, "set_pitch_shake_from_point", smlua_func_set_pitch_shake_from_point);
    smlua_bind_function(L, "shake_camera_handheld", smlua_func_shake_camera_handheld);
    smlua_bind_function(L, "shake_camera_pitch", smlua_func_shake_camera_pitch);
    smlua_bind_function(L, "shake_camera_roll", smlua_func_shake_camera_roll);
    smlua_bind_function(L, "shake_camera_yaw", smlua_func_shake_camera_yaw);
    smlua_bind_function(L, "soft_reset_camera", smlua_func_soft_reset_camera);
    smlua_bind_function(L, "start_cutscene", smlua_func_start_cutscene);
    smlua_bind_function(L, "start_object_cutscene_without_focus", smlua_func_start_object_cutscene_without_focus);
    smlua_bind_function(L, "transition_next_state", smlua_func_transition_next_state);
    smlua_bind_function(L, "trigger_cutscene_dialog", smlua_func_trigger_cutscene_dialog);
    smlua_bind_function(L, "vec3f_sub", smlua_func_vec3f_sub);
    smlua_bind_function(L, "vec3f_to_object_pos", smlua_func_vec3f_to_object_pos);
    smlua_bind_function(L, "warp_camera", smlua_func_warp_camera);

    // characters.h
    smlua_bind_function(L, "get_character", smlua_func_get_character);
    smlua_bind_function(L, "get_character_anim_offset", smlua_func_get_character_anim_offset);
    smlua_bind_function(L, "play_character_sound", smlua_func_play_character_sound);
    smlua_bind_function(L, "play_character_sound_if_no_flag", smlua_func_play_character_sound_if_no_flag);
    smlua_bind_function(L, "play_character_sound_offset", smlua_func_play_character_sound_offset);
    smlua_bind_function(L, "update_character_anim_offset", smlua_func_update_character_anim_offset);

    // djui_chat_message.h
    smlua_bind_function(L, "djui_chat_message_create", smlua_func_djui_chat_message_create);

    // djui_hud_utils.h
    smlua_bind_function(L, "djui_hud_get_mouse_x", smlua_func_djui_hud_get_mouse_x);
    smlua_bind_function(L, "djui_hud_get_mouse_y", smlua_func_djui_hud_get_mouse_y);
    smlua_bind_function(L, "djui_hud_get_raw_mouse_x", smlua_func_djui_hud_get_raw_mouse_x);
    smlua_bind_function(L, "djui_hud_get_raw_mouse_y", smlua_func_djui_hud_get_raw_mouse_y);
    smlua_bind_function(L, "djui_hud_get_screen_height", smlua_func_djui_hud_get_screen_height);
    smlua_bind_function(L, "djui_hud_get_screen_width", smlua_func_djui_hud_get_screen_width);
    smlua_bind_function(L, "djui_hud_measure_text", smlua_func_djui_hud_measure_text);
    smlua_bind_function(L, "djui_hud_print_text", smlua_func_djui_hud_print_text);
    smlua_bind_function(L, "djui_hud_render_rect", smlua_func_djui_hud_render_rect);
    smlua_bind_function(L, "djui_hud_render_rect_interpolated", smlua_func_djui_hud_render_rect_interpolated);
    smlua_bind_function(L, "djui_hud_set_color", smlua_func_djui_hud_set_color);
    smlua_bind_function(L, "djui_hud_set_font", smlua_func_djui_hud_set_font);
    smlua_bind_function(L, "djui_hud_set_mouse_locked", smlua_func_djui_hud_set_mouse_locked);
    smlua_bind_function(L, "djui_hud_set_resolution", smlua_func_djui_hud_set_resolution);
    smlua_bind_function(L, "djui_hud_world_pos_to_screen_pos", smlua_func_djui_hud_world_pos_to_screen_pos);

    // djui_popup.h
    smlua_bind_function(L, "djui_popup_create", smlua_func_djui_popup_create);

    // external.h
    smlua_bind_function(L, "fade_volume_scale", smlua_func_fade_volume_scale);
    smlua_bind_function(L, "fadeout_background_music", smlua_func_fadeout_background_music);
    smlua_bind_function(L, "get_current_background_music", smlua_func_get_current_background_music);
    smlua_bind_function(L, "get_current_background_music_default_volume", smlua_func_get_current_background_music_default_volume);
    smlua_bind_function(L, "get_current_background_music_max_target_volume", smlua_func_get_current_background_music_max_target_volume);
    smlua_bind_function(L, "get_current_background_music_target_volume", smlua_func_get_current_background_music_target_volume);
    smlua_bind_function(L, "is_current_background_music_volume_lowered", smlua_func_is_current_background_music_volume_lowered);
    smlua_bind_function(L, "play_course_clear", smlua_func_play_course_clear);
    smlua_bind_function(L, "play_dialog_sound", smlua_func_play_dialog_sound);
    smlua_bind_function(L, "play_music", smlua_func_play_music);
    smlua_bind_function(L, "play_peachs_jingle", smlua_func_play_peachs_jingle);
    smlua_bind_function(L, "play_power_star_jingle", smlua_func_play_power_star_jingle);
    smlua_bind_function(L, "play_puzzle_jingle", smlua_func_play_puzzle_jingle);
    smlua_bind_function(L, "play_race_fanfare", smlua_func_play_race_fanfare);
    smlua_bind_function(L, "play_secondary_music", smlua_func_play_secondary_music);
    smlua_bind_function(L, "play_sound", smlua_func_play_sound);
    smlua_bind_function(L, "play_sound_with_freq_scale", smlua_func_play_sound_with_freq_scale);
    smlua_bind_function(L, "play_star_fanfare", smlua_func_play_star_fanfare);
    smlua_bind_function(L, "play_toads_jingle", smlua_func_play_toads_jingle);
    smlua_bind_function(L, "seq_player_fade_out", smlua_func_seq_player_fade_out);
    smlua_bind_function(L, "seq_player_lower_volume", smlua_func_seq_player_lower_volume);
    smlua_bind_function(L, "seq_player_unlower_volume", smlua_func_seq_player_unlower_volume);

    // interaction.h
    smlua_bind_function(L, "does_mario_have_normal_cap_on_head", smlua_func_does_mario_have_normal_cap_on_head);
    smlua_bind_function(L, "get_door_save_file_flag", smlua_func_get_door_save_file_flag);
    smlua_bind_function(L, "interact_damage", smlua_func_interact_damage);
    smlua_bind_function(L, "mario_blow_off_cap", smlua_func_mario_blow_off_cap);
    smlua_bind_function(L, "mario_check_object_grab", smlua_func_mario_check_object_grab);
    smlua_bind_function(L, "mario_drop_held_object", smlua_func_mario_drop_held_object);
    smlua_bind_function(L, "mario_get_collided_object", smlua_func_mario_get_collided_object);
    smlua_bind_function(L, "mario_grab_used_object", smlua_func_mario_grab_used_object);
    smlua_bind_function(L, "mario_lose_cap_to_enemy", smlua_func_mario_lose_cap_to_enemy);
    smlua_bind_function(L, "mario_obj_angle_to_object", smlua_func_mario_obj_angle_to_object);
    smlua_bind_function(L, "mario_retrieve_cap", smlua_func_mario_retrieve_cap);
    smlua_bind_function(L, "mario_stop_riding_and_holding", smlua_func_mario_stop_riding_and_holding);
    smlua_bind_function(L, "mario_stop_riding_object", smlua_func_mario_stop_riding_object);
    smlua_bind_function(L, "mario_throw_held_object", smlua_func_mario_throw_held_object);
    smlua_bind_function(L, "passes_pvp_interaction_checks", smlua_func_passes_pvp_interaction_checks);
    smlua_bind_function(L, "take_damage_and_knock_back", smlua_func_take_damage_and_knock_back);

    // level_info.h
    smlua_bind_function(L, "get_level_name", smlua_func_get_level_name);
    smlua_bind_function(L, "get_level_name_ascii", smlua_func_get_level_name_ascii);
    smlua_bind_function(L, "get_level_name_sm64", smlua_func_get_level_name_sm64);
    smlua_bind_function(L, "get_star_name", smlua_func_get_star_name);
    smlua_bind_function(L, "get_star_name_ascii", smlua_func_get_star_name_ascii);
    smlua_bind_function(L, "get_star_name_sm64", smlua_func_get_star_name_sm64);

    // mario.h
    smlua_bind_function(L, "adjust_sound_for_speed", smlua_func_adjust_sound_for_speed);
    smlua_bind_function(L, "check_common_action_exits", smlua_func_check_common_action_exits);
    smlua_bind_function(L, "check_common_hold_action_exits", smlua_func_check_common_hold_action_exits);
    smlua_bind_function(L, "drop_and_set_mario_action", smlua_func_drop_and_set_mario_action);
    smlua_bind_function(L, "execute_mario_action", smlua_func_execute_mario_action);
    smlua_bind_function(L, "find_floor_height_relative_polar", smlua_func_find_floor_height_relative_polar);
    smlua_bind_function(L, "find_floor_slope", smlua_func_find_floor_slope);
    smlua_bind_function(L, "find_mario_anim_flags_and_translation", smlua_func_find_mario_anim_flags_and_translation);
    smlua_bind_function(L, "force_idle_state", smlua_func_force_idle_state);
    smlua_bind_function(L, "hurt_and_set_mario_action", smlua_func_hurt_and_set_mario_action);
    smlua_bind_function(L, "init_single_mario", smlua_func_init_single_mario);
    smlua_bind_function(L, "is_anim_at_end", smlua_func_is_anim_at_end);
    smlua_bind_function(L, "is_anim_past_end", smlua_func_is_anim_past_end);
    smlua_bind_function(L, "is_anim_past_frame", smlua_func_is_anim_past_frame);
    smlua_bind_function(L, "mario_can_bubble", smlua_func_mario_can_bubble);
    smlua_bind_function(L, "mario_facing_downhill", smlua_func_mario_facing_downhill);
    smlua_bind_function(L, "mario_floor_is_slippery", smlua_func_mario_floor_is_slippery);
    smlua_bind_function(L, "mario_floor_is_slope", smlua_func_mario_floor_is_slope);
    smlua_bind_function(L, "mario_floor_is_steep", smlua_func_mario_floor_is_steep);
    smlua_bind_function(L, "mario_get_floor_class", smlua_func_mario_get_floor_class);
    smlua_bind_function(L, "mario_get_terrain_sound_addend", smlua_func_mario_get_terrain_sound_addend);
    smlua_bind_function(L, "mario_set_bubbled", smlua_func_mario_set_bubbled);
    smlua_bind_function(L, "mario_set_forward_vel", smlua_func_mario_set_forward_vel);
    smlua_bind_function(L, "play_mario_action_sound", smlua_func_play_mario_action_sound);
    smlua_bind_function(L, "play_mario_heavy_landing_sound", smlua_func_play_mario_heavy_landing_sound);
    smlua_bind_function(L, "play_mario_heavy_landing_sound_once", smlua_func_play_mario_heavy_landing_sound_once);
    smlua_bind_function(L, "play_mario_jump_sound", smlua_func_play_mario_jump_sound);
    smlua_bind_function(L, "play_mario_landing_sound", smlua_func_play_mario_landing_sound);
    smlua_bind_function(L, "play_mario_landing_sound_once", smlua_func_play_mario_landing_sound_once);
    smlua_bind_function(L, "play_mario_sound", smlua_func_play_mario_sound);
    smlua_bind_function(L, "play_sound_and_spawn_particles", smlua_func_play_sound_and_spawn_particles);
    smlua_bind_function(L, "play_sound_if_no_flag", smlua_func_play_sound_if_no_flag);
    smlua_bind_function(L, "resolve_and_return_wall_collisions", smlua_func_resolve_and_return_wall_collisions);
    smlua_bind_function(L, "return_mario_anim_y_translation", smlua_func_return_mario_anim_y_translation);
    smlua_bind_function(L, "set_anim_to_frame", smlua_func_set_anim_to_frame);
    smlua_bind_function(L, "set_jump_from_landing", smlua_func_set_jump_from_landing);
    smlua_bind_function(L, "set_jumping_action", smlua_func_set_jumping_action);
    smlua_bind_function(L, "set_mario_action", smlua_func_set_mario_action);
    smlua_bind_function(L, "set_mario_anim_with_accel", smlua_func_set_mario_anim_with_accel);
    smlua_bind_function(L, "set_mario_animation", smlua_func_set_mario_animation);
    smlua_bind_function(L, "set_mario_particle_flags", smlua_func_set_mario_particle_flags);
    smlua_bind_function(L, "set_mario_y_vel_based_on_fspeed", smlua_func_set_mario_y_vel_based_on_fspeed);
    smlua_bind_function(L, "set_steep_jump_action", smlua_func_set_steep_jump_action);
    smlua_bind_function(L, "set_water_plunge_action", smlua_func_set_water_plunge_action);
    smlua_bind_function(L, "transition_submerged_to_walking", smlua_func_transition_submerged_to_walking);
    smlua_bind_function(L, "update_mario_pos_for_anim", smlua_func_update_mario_pos_for_anim);
    smlua_bind_function(L, "update_mario_sound_and_camera", smlua_func_update_mario_sound_and_camera);
    //smlua_bind_function(L, "vec3f_find_ceil", smlua_func_vec3f_find_ceil); <--- UNIMPLEMENTED

    // mario_actions_airborne.c
    smlua_bind_function(L, "check_common_airborne_cancels", smlua_func_check_common_airborne_cancels);
    smlua_bind_function(L, "check_fall_damage", smlua_func_check_fall_damage);
    smlua_bind_function(L, "check_fall_damage_or_get_stuck", smlua_func_check_fall_damage_or_get_stuck);
    smlua_bind_function(L, "check_horizontal_wind", smlua_func_check_horizontal_wind);
    smlua_bind_function(L, "check_kick_or_dive_in_air", smlua_func_check_kick_or_dive_in_air);
    smlua_bind_function(L, "check_wall_kick", smlua_func_check_wall_kick);
    smlua_bind_function(L, "common_air_action_step", smlua_func_common_air_action_step);
    smlua_bind_function(L, "common_air_knockback_step", smlua_func_common_air_knockback_step);
    smlua_bind_function(L, "lava_boost_on_wall", smlua_func_lava_boost_on_wall);
    smlua_bind_function(L, "mario_execute_airborne_action", smlua_func_mario_execute_airborne_action);
    smlua_bind_function(L, "play_far_fall_sound", smlua_func_play_far_fall_sound);
    smlua_bind_function(L, "play_flip_sounds", smlua_func_play_flip_sounds);
    smlua_bind_function(L, "play_knockback_sound", smlua_func_play_knockback_sound);
    smlua_bind_function(L, "should_get_stuck_in_ground", smlua_func_should_get_stuck_in_ground);
    smlua_bind_function(L, "update_air_with_turn", smlua_func_update_air_with_turn);
    smlua_bind_function(L, "update_air_without_turn", smlua_func_update_air_without_turn);
    smlua_bind_function(L, "update_flying", smlua_func_update_flying);
    smlua_bind_function(L, "update_flying_pitch", smlua_func_update_flying_pitch);
    smlua_bind_function(L, "update_flying_yaw", smlua_func_update_flying_yaw);
    smlua_bind_function(L, "update_lava_boost_or_twirling", smlua_func_update_lava_boost_or_twirling);

    // mario_actions_automatic.c
    smlua_bind_function(L, "add_tree_leaf_particles", smlua_func_add_tree_leaf_particles);
    smlua_bind_function(L, "check_common_automatic_cancels", smlua_func_check_common_automatic_cancels);
    smlua_bind_function(L, "climb_up_ledge", smlua_func_climb_up_ledge);
    smlua_bind_function(L, "let_go_of_ledge", smlua_func_let_go_of_ledge);
    smlua_bind_function(L, "mario_execute_automatic_action", smlua_func_mario_execute_automatic_action);
    smlua_bind_function(L, "perform_hanging_step", smlua_func_perform_hanging_step);
    smlua_bind_function(L, "play_climbing_sounds", smlua_func_play_climbing_sounds);
    smlua_bind_function(L, "set_pole_position", smlua_func_set_pole_position);
    smlua_bind_function(L, "update_hang_moving", smlua_func_update_hang_moving);
    smlua_bind_function(L, "update_hang_stationary", smlua_func_update_hang_stationary);
    smlua_bind_function(L, "update_ledge_climb", smlua_func_update_ledge_climb);
    smlua_bind_function(L, "update_ledge_climb_camera", smlua_func_update_ledge_climb_camera);

    // mario_actions_cutscene.c
    smlua_bind_function(L, "bhv_end_peach_loop", smlua_func_bhv_end_peach_loop);
    smlua_bind_function(L, "bhv_end_toad_loop", smlua_func_bhv_end_toad_loop);
    smlua_bind_function(L, "common_death_handler", smlua_func_common_death_handler);
    smlua_bind_function(L, "cutscene_put_cap_on", smlua_func_cutscene_put_cap_on);
    smlua_bind_function(L, "cutscene_take_cap_off", smlua_func_cutscene_take_cap_off);
    smlua_bind_function(L, "general_star_dance_handler", smlua_func_general_star_dance_handler);
    smlua_bind_function(L, "generate_yellow_sparkles", smlua_func_generate_yellow_sparkles);
    //smlua_bind_function(L, "get_credits_str_width", smlua_func_get_credits_str_width); <--- UNIMPLEMENTED
    smlua_bind_function(L, "get_star_collection_dialog", smlua_func_get_star_collection_dialog);
    smlua_bind_function(L, "handle_save_menu", smlua_func_handle_save_menu);
    smlua_bind_function(L, "launch_mario_until_land", smlua_func_launch_mario_until_land);
    smlua_bind_function(L, "mario_execute_cutscene_action", smlua_func_mario_execute_cutscene_action);
    smlua_bind_function(L, "mario_ready_to_speak", smlua_func_mario_ready_to_speak);
    smlua_bind_function(L, "print_displaying_credits_entry", smlua_func_print_displaying_credits_entry);
    smlua_bind_function(L, "should_start_or_continue_dialog", smlua_func_should_start_or_continue_dialog);
    smlua_bind_function(L, "stuck_in_ground_handler", smlua_func_stuck_in_ground_handler);

    // mario_actions_moving.c
    smlua_bind_function(L, "align_with_floor", smlua_func_align_with_floor);
    smlua_bind_function(L, "analog_stick_held_back", smlua_func_analog_stick_held_back);
    smlua_bind_function(L, "anim_and_audio_for_heavy_walk", smlua_func_anim_and_audio_for_heavy_walk);
    smlua_bind_function(L, "anim_and_audio_for_hold_walk", smlua_func_anim_and_audio_for_hold_walk);
    smlua_bind_function(L, "anim_and_audio_for_walk", smlua_func_anim_and_audio_for_walk);
    smlua_bind_function(L, "apply_landing_accel", smlua_func_apply_landing_accel);
    smlua_bind_function(L, "apply_slope_accel", smlua_func_apply_slope_accel);
    smlua_bind_function(L, "apply_slope_decel", smlua_func_apply_slope_decel);
    smlua_bind_function(L, "begin_braking_action", smlua_func_begin_braking_action);
    smlua_bind_function(L, "begin_walking_action", smlua_func_begin_walking_action);
    smlua_bind_function(L, "check_common_moving_cancels", smlua_func_check_common_moving_cancels);
    smlua_bind_function(L, "check_ground_dive_or_punch", smlua_func_check_ground_dive_or_punch);
    smlua_bind_function(L, "check_ledge_climb_down", smlua_func_check_ledge_climb_down);
    smlua_bind_function(L, "common_ground_knockback_action", smlua_func_common_ground_knockback_action);
    smlua_bind_function(L, "common_landing_action", smlua_func_common_landing_action);
    //smlua_bind_function(L, "common_landing_cancels", smlua_func_common_landing_cancels); <--- UNIMPLEMENTED
    smlua_bind_function(L, "common_slide_action", smlua_func_common_slide_action);
    smlua_bind_function(L, "common_slide_action_with_jump", smlua_func_common_slide_action_with_jump);
    smlua_bind_function(L, "mario_execute_moving_action", smlua_func_mario_execute_moving_action);
    smlua_bind_function(L, "play_step_sound", smlua_func_play_step_sound);
    smlua_bind_function(L, "push_or_sidle_wall", smlua_func_push_or_sidle_wall);
    smlua_bind_function(L, "quicksand_jump_land_action", smlua_func_quicksand_jump_land_action);
    smlua_bind_function(L, "set_triple_jump_action", smlua_func_set_triple_jump_action);
    smlua_bind_function(L, "should_begin_sliding", smlua_func_should_begin_sliding);
    smlua_bind_function(L, "slide_bonk", smlua_func_slide_bonk);
    smlua_bind_function(L, "stomach_slide_action", smlua_func_stomach_slide_action);
    smlua_bind_function(L, "tilt_body_butt_slide", smlua_func_tilt_body_butt_slide);
    smlua_bind_function(L, "tilt_body_ground_shell", smlua_func_tilt_body_ground_shell);
    smlua_bind_function(L, "tilt_body_running", smlua_func_tilt_body_running);
    smlua_bind_function(L, "tilt_body_walking", smlua_func_tilt_body_walking);
    smlua_bind_function(L, "update_decelerating_speed", smlua_func_update_decelerating_speed);
    smlua_bind_function(L, "update_shell_speed", smlua_func_update_shell_speed);
    smlua_bind_function(L, "update_sliding", smlua_func_update_sliding);
    smlua_bind_function(L, "update_sliding_angle", smlua_func_update_sliding_angle);
    smlua_bind_function(L, "update_walking_speed", smlua_func_update_walking_speed);

    // mario_actions_object.c
    smlua_bind_function(L, "animated_stationary_ground_step", smlua_func_animated_stationary_ground_step);
    smlua_bind_function(L, "check_common_object_cancels", smlua_func_check_common_object_cancels);
    smlua_bind_function(L, "mario_execute_object_action", smlua_func_mario_execute_object_action);
    smlua_bind_function(L, "mario_update_punch_sequence", smlua_func_mario_update_punch_sequence);

    // mario_actions_stationary.c
    smlua_bind_function(L, "check_common_hold_idle_cancels", smlua_func_check_common_hold_idle_cancels);
    smlua_bind_function(L, "check_common_idle_cancels", smlua_func_check_common_idle_cancels);
    smlua_bind_function(L, "check_common_landing_cancels", smlua_func_check_common_landing_cancels);
    smlua_bind_function(L, "check_common_stationary_cancels", smlua_func_check_common_stationary_cancels);
    smlua_bind_function(L, "landing_step", smlua_func_landing_step);
    smlua_bind_function(L, "mario_execute_stationary_action", smlua_func_mario_execute_stationary_action);
    smlua_bind_function(L, "play_anim_sound", smlua_func_play_anim_sound);
    smlua_bind_function(L, "stopping_step", smlua_func_stopping_step);

    // mario_actions_submerged.c
    smlua_bind_function(L, "apply_water_current", smlua_func_apply_water_current);
    smlua_bind_function(L, "float_surface_gfx", smlua_func_float_surface_gfx);
    smlua_bind_function(L, "mario_execute_submerged_action", smlua_func_mario_execute_submerged_action);
    smlua_bind_function(L, "perform_water_full_step", smlua_func_perform_water_full_step);
    smlua_bind_function(L, "perform_water_step", smlua_func_perform_water_step);
    smlua_bind_function(L, "set_swimming_at_surface_particles", smlua_func_set_swimming_at_surface_particles);

    // mario_misc.h
    smlua_bind_function(L, "bhv_toad_message_init", smlua_func_bhv_toad_message_init);
    smlua_bind_function(L, "bhv_toad_message_loop", smlua_func_bhv_toad_message_loop);
    smlua_bind_function(L, "bhv_unlock_door_star_init", smlua_func_bhv_unlock_door_star_init);
    smlua_bind_function(L, "bhv_unlock_door_star_loop", smlua_func_bhv_unlock_door_star_loop);

    // mario_step.h
    smlua_bind_function(L, "get_additive_y_vel_for_jumps", smlua_func_get_additive_y_vel_for_jumps);
    smlua_bind_function(L, "init_bully_collision_data", smlua_func_init_bully_collision_data);
    smlua_bind_function(L, "mario_bonk_reflection", smlua_func_mario_bonk_reflection);
    smlua_bind_function(L, "mario_push_off_steep_floor", smlua_func_mario_push_off_steep_floor);
    smlua_bind_function(L, "mario_update_moving_sand", smlua_func_mario_update_moving_sand);
    smlua_bind_function(L, "mario_update_quicksand", smlua_func_mario_update_quicksand);
    smlua_bind_function(L, "mario_update_windy_ground", smlua_func_mario_update_windy_ground);
    smlua_bind_function(L, "perform_air_step", smlua_func_perform_air_step);
    smlua_bind_function(L, "perform_ground_step", smlua_func_perform_ground_step);
    smlua_bind_function(L, "set_vel_from_pitch_and_yaw", smlua_func_set_vel_from_pitch_and_yaw);
    smlua_bind_function(L, "stationary_ground_step", smlua_func_stationary_ground_step);
    smlua_bind_function(L, "stop_and_set_height_to_floor", smlua_func_stop_and_set_height_to_floor);

    // network_player.h
    smlua_bind_function(L, "get_network_player_from_area", smlua_func_get_network_player_from_area);
    smlua_bind_function(L, "get_network_player_from_level", smlua_func_get_network_player_from_level);
    smlua_bind_function(L, "get_network_player_smallest_global", smlua_func_get_network_player_smallest_global);
    smlua_bind_function(L, "network_player_connected_count", smlua_func_network_player_connected_count);
    smlua_bind_function(L, "network_player_from_global_index", smlua_func_network_player_from_global_index);
    smlua_bind_function(L, "network_player_set_description", smlua_func_network_player_set_description);

    // network_utils.h
    smlua_bind_function(L, "network_get_player_text_color_string", smlua_func_network_get_player_text_color_string);
    smlua_bind_function(L, "network_global_index_from_local", smlua_func_network_global_index_from_local);
    smlua_bind_function(L, "network_is_server", smlua_func_network_is_server);
    smlua_bind_function(L, "network_local_index_from_global", smlua_func_network_local_index_from_global);

    // obj_behaviors.c
    smlua_bind_function(L, "absf_2", smlua_func_absf_2);
    smlua_bind_function(L, "calc_new_obj_vel_and_pos_y", smlua_func_calc_new_obj_vel_and_pos_y);
    smlua_bind_function(L, "calc_new_obj_vel_and_pos_y_underwater", smlua_func_calc_new_obj_vel_and_pos_y_underwater);
    smlua_bind_function(L, "calc_obj_friction", smlua_func_calc_obj_friction);
    smlua_bind_function(L, "current_mario_room_check", smlua_func_current_mario_room_check);
    //smlua_bind_function(L, "geo_obj_transparency_something", smlua_func_geo_obj_transparency_something); <--- UNIMPLEMENTED
    smlua_bind_function(L, "is_nearest_mario_state_to_object", smlua_func_is_nearest_mario_state_to_object);
    smlua_bind_function(L, "is_nearest_player_to_object", smlua_func_is_nearest_player_to_object);
    smlua_bind_function(L, "is_other_player_active", smlua_func_is_other_player_active);
    smlua_bind_function(L, "is_player_active", smlua_func_is_player_active);
    smlua_bind_function(L, "is_player_in_local_area", smlua_func_is_player_in_local_area);
    smlua_bind_function(L, "is_point_close_to_object", smlua_func_is_point_close_to_object);
    smlua_bind_function(L, "is_point_within_radius_of_mario", smlua_func_is_point_within_radius_of_mario);
    smlua_bind_function(L, "nearest_interacting_mario_state_to_object", smlua_func_nearest_interacting_mario_state_to_object);
    smlua_bind_function(L, "nearest_interacting_player_to_object", smlua_func_nearest_interacting_player_to_object);
    smlua_bind_function(L, "nearest_mario_state_to_object", smlua_func_nearest_mario_state_to_object);
    smlua_bind_function(L, "nearest_player_to_object", smlua_func_nearest_player_to_object);
    smlua_bind_function(L, "obj_check_floor_death", smlua_func_obj_check_floor_death);
    smlua_bind_function(L, "obj_check_if_facing_toward_angle", smlua_func_obj_check_if_facing_toward_angle);
    smlua_bind_function(L, "obj_find_wall", smlua_func_obj_find_wall);
    smlua_bind_function(L, "obj_find_wall_displacement", smlua_func_obj_find_wall_displacement);
    smlua_bind_function(L, "obj_flicker_and_disappear", smlua_func_obj_flicker_and_disappear);
    smlua_bind_function(L, "obj_lava_death", smlua_func_obj_lava_death);
    smlua_bind_function(L, "obj_move_xyz_using_fvel_and_yaw", smlua_func_obj_move_xyz_using_fvel_and_yaw);
    smlua_bind_function(L, "obj_orient_graph", smlua_func_obj_orient_graph);
    smlua_bind_function(L, "obj_return_and_displace_home", smlua_func_obj_return_and_displace_home);
    smlua_bind_function(L, "obj_return_home_if_safe", smlua_func_obj_return_home_if_safe);
    smlua_bind_function(L, "obj_spawn_yellow_coins", smlua_func_obj_spawn_yellow_coins);
    smlua_bind_function(L, "obj_splash", smlua_func_obj_splash);
    smlua_bind_function(L, "obj_update_pos_vel_xz", smlua_func_obj_update_pos_vel_xz);
    smlua_bind_function(L, "object_step", smlua_func_object_step);
    smlua_bind_function(L, "object_step_without_floor_orient", smlua_func_object_step_without_floor_orient);
    smlua_bind_function(L, "set_object_visibility", smlua_func_set_object_visibility);
    smlua_bind_function(L, "set_yoshi_as_not_dead", smlua_func_set_yoshi_as_not_dead);
    smlua_bind_function(L, "spawn_orange_number", smlua_func_spawn_orange_number);
    smlua_bind_function(L, "turn_obj_away_from_steep_floor", smlua_func_turn_obj_away_from_steep_floor);
    smlua_bind_function(L, "turn_obj_away_from_surface", smlua_func_turn_obj_away_from_surface);

    // obj_behaviors_2.c
    smlua_bind_function(L, "approach_f32_ptr", smlua_func_approach_f32_ptr);
    smlua_bind_function(L, "cur_obj_init_anim_and_check_if_end", smlua_func_cur_obj_init_anim_and_check_if_end);
    smlua_bind_function(L, "cur_obj_init_anim_check_frame", smlua_func_cur_obj_init_anim_check_frame);
    smlua_bind_function(L, "cur_obj_init_anim_extend", smlua_func_cur_obj_init_anim_extend);
    smlua_bind_function(L, "cur_obj_play_sound_at_anim_range", smlua_func_cur_obj_play_sound_at_anim_range);
    smlua_bind_function(L, "cur_obj_set_anim_if_at_end", smlua_func_cur_obj_set_anim_if_at_end);
    smlua_bind_function(L, "cur_obj_spin_all_dimensions", smlua_func_cur_obj_spin_all_dimensions);
    smlua_bind_function(L, "obj_act_knockback", smlua_func_obj_act_knockback);
    smlua_bind_function(L, "obj_act_squished", smlua_func_obj_act_squished);
    smlua_bind_function(L, "obj_bounce_off_walls_edges_objects", smlua_func_obj_bounce_off_walls_edges_objects);
    smlua_bind_function(L, "obj_check_attacks", smlua_func_obj_check_attacks);
    smlua_bind_function(L, "obj_compute_vel_from_move_pitch", smlua_func_obj_compute_vel_from_move_pitch);
    smlua_bind_function(L, "obj_die_if_above_lava_and_health_non_positive", smlua_func_obj_die_if_above_lava_and_health_non_positive);
    smlua_bind_function(L, "obj_die_if_health_non_positive", smlua_func_obj_die_if_health_non_positive);
    smlua_bind_function(L, "obj_face_pitch_approach", smlua_func_obj_face_pitch_approach);
    smlua_bind_function(L, "obj_face_roll_approach", smlua_func_obj_face_roll_approach);
    smlua_bind_function(L, "obj_face_yaw_approach", smlua_func_obj_face_yaw_approach);
    smlua_bind_function(L, "obj_forward_vel_approach", smlua_func_obj_forward_vel_approach);
    smlua_bind_function(L, "obj_get_pitch_from_vel", smlua_func_obj_get_pitch_from_vel);
    smlua_bind_function(L, "obj_get_pitch_to_home", smlua_func_obj_get_pitch_to_home);
    smlua_bind_function(L, "obj_grow_then_shrink", smlua_func_obj_grow_then_shrink);
    smlua_bind_function(L, "obj_handle_attacks", smlua_func_obj_handle_attacks);
    smlua_bind_function(L, "obj_is_near_to_and_facing_mario", smlua_func_obj_is_near_to_and_facing_mario);
    smlua_bind_function(L, "obj_is_rendering_enabled", smlua_func_obj_is_rendering_enabled);
    smlua_bind_function(L, "obj_move_for_one_second", smlua_func_obj_move_for_one_second);
    smlua_bind_function(L, "obj_move_pitch_approach", smlua_func_obj_move_pitch_approach);
    smlua_bind_function(L, "obj_random_fixed_turn", smlua_func_obj_random_fixed_turn);
    smlua_bind_function(L, "obj_resolve_collisions_and_turn", smlua_func_obj_resolve_collisions_and_turn);
    smlua_bind_function(L, "obj_resolve_object_collisions", smlua_func_obj_resolve_object_collisions);
    smlua_bind_function(L, "obj_roll_to_match_yaw_turn", smlua_func_obj_roll_to_match_yaw_turn);
    smlua_bind_function(L, "obj_rotate_yaw_and_bounce_off_walls", smlua_func_obj_rotate_yaw_and_bounce_off_walls);
    smlua_bind_function(L, "obj_set_dist_from_home", smlua_func_obj_set_dist_from_home);
    smlua_bind_function(L, "obj_set_knockback_action", smlua_func_obj_set_knockback_action);
    smlua_bind_function(L, "obj_set_squished_action", smlua_func_obj_set_squished_action);
    smlua_bind_function(L, "obj_smooth_turn", smlua_func_obj_smooth_turn);
    smlua_bind_function(L, "obj_spit_fire", smlua_func_obj_spit_fire);
    smlua_bind_function(L, "obj_turn_pitch_toward_mario", smlua_func_obj_turn_pitch_toward_mario);
    smlua_bind_function(L, "obj_unused_die", smlua_func_obj_unused_die);
    smlua_bind_function(L, "obj_update_blinking", smlua_func_obj_update_blinking);
    smlua_bind_function(L, "obj_update_standard_actions", smlua_func_obj_update_standard_actions);
    smlua_bind_function(L, "obj_y_vel_approach", smlua_func_obj_y_vel_approach);
    smlua_bind_function(L, "oscillate_toward", smlua_func_oscillate_toward);
    smlua_bind_function(L, "platform_on_track_update_pos_or_spawn_ball", smlua_func_platform_on_track_update_pos_or_spawn_ball);
    smlua_bind_function(L, "random_linear_offset", smlua_func_random_linear_offset);
    smlua_bind_function(L, "random_mod_offset", smlua_func_random_mod_offset);
    smlua_bind_function(L, "treat_far_home_as_mario", smlua_func_treat_far_home_as_mario);

    // object_helpers.c
    smlua_bind_function(L, "abs_angle_diff", smlua_func_abs_angle_diff);
    smlua_bind_function(L, "apply_drag_to_value", smlua_func_apply_drag_to_value);
    smlua_bind_function(L, "approach_f32_signed", smlua_func_approach_f32_signed);
    smlua_bind_function(L, "approach_f32_symmetric", smlua_func_approach_f32_symmetric);
    smlua_bind_function(L, "approach_s16_symmetric", smlua_func_approach_s16_symmetric);
    smlua_bind_function(L, "bhv_dust_smoke_loop", smlua_func_bhv_dust_smoke_loop);
    smlua_bind_function(L, "bhv_init_room", smlua_func_bhv_init_room);
    smlua_bind_function(L, "bit_shift_left", smlua_func_bit_shift_left);
    smlua_bind_function(L, "chain_segment_init", smlua_func_chain_segment_init);
    smlua_bind_function(L, "clear_move_flag", smlua_func_clear_move_flag);
    smlua_bind_function(L, "clear_time_stop_flags", smlua_func_clear_time_stop_flags);
    smlua_bind_function(L, "count_objects_with_behavior", smlua_func_count_objects_with_behavior);
    smlua_bind_function(L, "count_unimportant_objects", smlua_func_count_unimportant_objects);
    //smlua_bind_function(L, "create_transformation_from_matrices", smlua_func_create_transformation_from_matrices); <--- UNIMPLEMENTED
    smlua_bind_function(L, "cur_obj_abs_y_dist_to_home", smlua_func_cur_obj_abs_y_dist_to_home);
    smlua_bind_function(L, "cur_obj_advance_looping_anim", smlua_func_cur_obj_advance_looping_anim);
    smlua_bind_function(L, "cur_obj_align_gfx_with_floor", smlua_func_cur_obj_align_gfx_with_floor);
    smlua_bind_function(L, "cur_obj_angle_to_home", smlua_func_cur_obj_angle_to_home);
    smlua_bind_function(L, "cur_obj_apply_drag_xz", smlua_func_cur_obj_apply_drag_xz);
    smlua_bind_function(L, "cur_obj_become_intangible", smlua_func_cur_obj_become_intangible);
    smlua_bind_function(L, "cur_obj_become_tangible", smlua_func_cur_obj_become_tangible);
    smlua_bind_function(L, "cur_obj_can_mario_activate_textbox", smlua_func_cur_obj_can_mario_activate_textbox);
    smlua_bind_function(L, "cur_obj_can_mario_activate_textbox_2", smlua_func_cur_obj_can_mario_activate_textbox_2);
    smlua_bind_function(L, "cur_obj_change_action", smlua_func_cur_obj_change_action);
    smlua_bind_function(L, "cur_obj_check_anim_frame", smlua_func_cur_obj_check_anim_frame);
    smlua_bind_function(L, "cur_obj_check_anim_frame_in_range", smlua_func_cur_obj_check_anim_frame_in_range);
    smlua_bind_function(L, "cur_obj_check_frame_prior_current_frame", smlua_func_cur_obj_check_frame_prior_current_frame);
    smlua_bind_function(L, "cur_obj_check_grabbed_mario", smlua_func_cur_obj_check_grabbed_mario);
    smlua_bind_function(L, "cur_obj_check_if_at_animation_end", smlua_func_cur_obj_check_if_at_animation_end);
    smlua_bind_function(L, "cur_obj_check_if_near_animation_end", smlua_func_cur_obj_check_if_near_animation_end);
    smlua_bind_function(L, "cur_obj_check_interacted", smlua_func_cur_obj_check_interacted);
    smlua_bind_function(L, "cur_obj_clear_interact_status_flag", smlua_func_cur_obj_clear_interact_status_flag);
    smlua_bind_function(L, "cur_obj_compute_vel_xz", smlua_func_cur_obj_compute_vel_xz);
    smlua_bind_function(L, "cur_obj_count_objects_with_behavior", smlua_func_cur_obj_count_objects_with_behavior);
    smlua_bind_function(L, "cur_obj_detect_steep_floor", smlua_func_cur_obj_detect_steep_floor);
    smlua_bind_function(L, "cur_obj_disable", smlua_func_cur_obj_disable);
    smlua_bind_function(L, "cur_obj_disable_rendering", smlua_func_cur_obj_disable_rendering);
    smlua_bind_function(L, "cur_obj_disable_rendering_and_become_intangible", smlua_func_cur_obj_disable_rendering_and_become_intangible);
    smlua_bind_function(L, "cur_obj_dist_to_nearest_object_with_behavior", smlua_func_cur_obj_dist_to_nearest_object_with_behavior);
    smlua_bind_function(L, "cur_obj_enable_rendering", smlua_func_cur_obj_enable_rendering);
    smlua_bind_function(L, "cur_obj_enable_rendering_2", smlua_func_cur_obj_enable_rendering_2);
    smlua_bind_function(L, "cur_obj_enable_rendering_and_become_tangible", smlua_func_cur_obj_enable_rendering_and_become_tangible);
    smlua_bind_function(L, "cur_obj_enable_rendering_if_mario_in_room", smlua_func_cur_obj_enable_rendering_if_mario_in_room);
    smlua_bind_function(L, "cur_obj_end_dialog", smlua_func_cur_obj_end_dialog);
    smlua_bind_function(L, "cur_obj_extend_animation_if_at_end", smlua_func_cur_obj_extend_animation_if_at_end);
    smlua_bind_function(L, "cur_obj_find_nearby_held_actor", smlua_func_cur_obj_find_nearby_held_actor);
    smlua_bind_function(L, "cur_obj_find_nearest_object_with_behavior", smlua_func_cur_obj_find_nearest_object_with_behavior);
    smlua_bind_function(L, "cur_obj_find_nearest_pole", smlua_func_cur_obj_find_nearest_pole);
    smlua_bind_function(L, "cur_obj_follow_path", smlua_func_cur_obj_follow_path);
    smlua_bind_function(L, "cur_obj_forward_vel_approach_upward", smlua_func_cur_obj_forward_vel_approach_upward);
    smlua_bind_function(L, "cur_obj_get_dropped", smlua_func_cur_obj_get_dropped);
    smlua_bind_function(L, "cur_obj_get_thrown_or_placed", smlua_func_cur_obj_get_thrown_or_placed);
    smlua_bind_function(L, "cur_obj_has_behavior", smlua_func_cur_obj_has_behavior);
    smlua_bind_function(L, "cur_obj_has_model", smlua_func_cur_obj_has_model);
    smlua_bind_function(L, "cur_obj_hide", smlua_func_cur_obj_hide);
    smlua_bind_function(L, "cur_obj_hide_if_mario_far_away_y", smlua_func_cur_obj_hide_if_mario_far_away_y);
    smlua_bind_function(L, "cur_obj_if_hit_wall_bounce_away", smlua_func_cur_obj_if_hit_wall_bounce_away);
    smlua_bind_function(L, "cur_obj_init_animation", smlua_func_cur_obj_init_animation);
    smlua_bind_function(L, "cur_obj_init_animation_and_anim_frame", smlua_func_cur_obj_init_animation_and_anim_frame);
    smlua_bind_function(L, "cur_obj_init_animation_and_check_if_near_end", smlua_func_cur_obj_init_animation_and_check_if_near_end);
    smlua_bind_function(L, "cur_obj_init_animation_and_extend_if_at_end", smlua_func_cur_obj_init_animation_and_extend_if_at_end);
    smlua_bind_function(L, "cur_obj_init_animation_with_accel_and_sound", smlua_func_cur_obj_init_animation_with_accel_and_sound);
    smlua_bind_function(L, "cur_obj_init_animation_with_sound", smlua_func_cur_obj_init_animation_with_sound);
    smlua_bind_function(L, "cur_obj_is_any_player_on_platform", smlua_func_cur_obj_is_any_player_on_platform);
    smlua_bind_function(L, "cur_obj_is_mario_ground_pounding_platform", smlua_func_cur_obj_is_mario_ground_pounding_platform);
    smlua_bind_function(L, "cur_obj_is_mario_on_platform", smlua_func_cur_obj_is_mario_on_platform);
    smlua_bind_function(L, "cur_obj_lateral_dist_from_mario_to_home", smlua_func_cur_obj_lateral_dist_from_mario_to_home);
    smlua_bind_function(L, "cur_obj_lateral_dist_from_obj_to_home", smlua_func_cur_obj_lateral_dist_from_obj_to_home);
    smlua_bind_function(L, "cur_obj_lateral_dist_to_home", smlua_func_cur_obj_lateral_dist_to_home);
    smlua_bind_function(L, "cur_obj_mario_far_away", smlua_func_cur_obj_mario_far_away);
    smlua_bind_function(L, "cur_obj_move_after_thrown_or_dropped", smlua_func_cur_obj_move_after_thrown_or_dropped);
    smlua_bind_function(L, "cur_obj_move_standard", smlua_func_cur_obj_move_standard);
    smlua_bind_function(L, "cur_obj_move_up_and_down", smlua_func_cur_obj_move_up_and_down);
    smlua_bind_function(L, "cur_obj_move_update_ground_air_flags", smlua_func_cur_obj_move_update_ground_air_flags);
    smlua_bind_function(L, "cur_obj_move_update_underwater_flags", smlua_func_cur_obj_move_update_underwater_flags);
    smlua_bind_function(L, "cur_obj_move_using_fvel_and_gravity", smlua_func_cur_obj_move_using_fvel_and_gravity);
    smlua_bind_function(L, "cur_obj_move_using_vel", smlua_func_cur_obj_move_using_vel);
    smlua_bind_function(L, "cur_obj_move_using_vel_and_gravity", smlua_func_cur_obj_move_using_vel_and_gravity);
    smlua_bind_function(L, "cur_obj_move_xz", smlua_func_cur_obj_move_xz);
    smlua_bind_function(L, "cur_obj_move_xz_using_fvel_and_yaw", smlua_func_cur_obj_move_xz_using_fvel_and_yaw);
    smlua_bind_function(L, "cur_obj_move_y", smlua_func_cur_obj_move_y);
    smlua_bind_function(L, "cur_obj_move_y_and_get_water_level", smlua_func_cur_obj_move_y_and_get_water_level);
    smlua_bind_function(L, "cur_obj_move_y_with_terminal_vel", smlua_func_cur_obj_move_y_with_terminal_vel);
    smlua_bind_function(L, "cur_obj_nearest_object_with_behavior", smlua_func_cur_obj_nearest_object_with_behavior);
    smlua_bind_function(L, "cur_obj_outside_home_rectangle", smlua_func_cur_obj_outside_home_rectangle);
    smlua_bind_function(L, "cur_obj_outside_home_square", smlua_func_cur_obj_outside_home_square);
    smlua_bind_function(L, "cur_obj_progress_direction_table", smlua_func_cur_obj_progress_direction_table);
    smlua_bind_function(L, "cur_obj_push_mario_away", smlua_func_cur_obj_push_mario_away);
    smlua_bind_function(L, "cur_obj_push_mario_away_from_cylinder", smlua_func_cur_obj_push_mario_away_from_cylinder);
    smlua_bind_function(L, "cur_obj_reflect_move_angle_off_wall", smlua_func_cur_obj_reflect_move_angle_off_wall);
    smlua_bind_function(L, "cur_obj_reset_timer_and_subaction", smlua_func_cur_obj_reset_timer_and_subaction);
    smlua_bind_function(L, "cur_obj_resolve_wall_collisions", smlua_func_cur_obj_resolve_wall_collisions);
    smlua_bind_function(L, "cur_obj_reverse_animation", smlua_func_cur_obj_reverse_animation);
    smlua_bind_function(L, "cur_obj_rotate_face_angle_using_vel", smlua_func_cur_obj_rotate_face_angle_using_vel);
    smlua_bind_function(L, "cur_obj_rotate_move_angle_using_vel", smlua_func_cur_obj_rotate_move_angle_using_vel);
    smlua_bind_function(L, "cur_obj_rotate_yaw_toward", smlua_func_cur_obj_rotate_yaw_toward);
    smlua_bind_function(L, "cur_obj_scale", smlua_func_cur_obj_scale);
    smlua_bind_function(L, "cur_obj_scale_over_time", smlua_func_cur_obj_scale_over_time);
    smlua_bind_function(L, "cur_obj_set_behavior", smlua_func_cur_obj_set_behavior);
    smlua_bind_function(L, "cur_obj_set_direction_table", smlua_func_cur_obj_set_direction_table);
    smlua_bind_function(L, "cur_obj_set_face_angle_to_move_angle", smlua_func_cur_obj_set_face_angle_to_move_angle);
    smlua_bind_function(L, "cur_obj_set_hitbox_and_die_if_attacked", smlua_func_cur_obj_set_hitbox_and_die_if_attacked);
    smlua_bind_function(L, "cur_obj_set_hitbox_radius_and_height", smlua_func_cur_obj_set_hitbox_radius_and_height);
    smlua_bind_function(L, "cur_obj_set_hurtbox_radius_and_height", smlua_func_cur_obj_set_hurtbox_radius_and_height);
    smlua_bind_function(L, "cur_obj_set_pos_relative", smlua_func_cur_obj_set_pos_relative);
    smlua_bind_function(L, "cur_obj_set_pos_relative_to_parent", smlua_func_cur_obj_set_pos_relative_to_parent);
    smlua_bind_function(L, "cur_obj_set_pos_to_home", smlua_func_cur_obj_set_pos_to_home);
    smlua_bind_function(L, "cur_obj_set_pos_to_home_and_stop", smlua_func_cur_obj_set_pos_to_home_and_stop);
    smlua_bind_function(L, "cur_obj_set_pos_to_home_with_debug", smlua_func_cur_obj_set_pos_to_home_with_debug);
    smlua_bind_function(L, "cur_obj_set_pos_via_transform", smlua_func_cur_obj_set_pos_via_transform);
    smlua_bind_function(L, "cur_obj_set_vel_from_mario_vel", smlua_func_cur_obj_set_vel_from_mario_vel);
    smlua_bind_function(L, "cur_obj_set_y_vel_and_animation", smlua_func_cur_obj_set_y_vel_and_animation);
    smlua_bind_function(L, "cur_obj_shake_screen", smlua_func_cur_obj_shake_screen);
    smlua_bind_function(L, "cur_obj_shake_y", smlua_func_cur_obj_shake_y);
    smlua_bind_function(L, "cur_obj_shake_y_until", smlua_func_cur_obj_shake_y_until);
    smlua_bind_function(L, "cur_obj_spawn_loot_blue_coin", smlua_func_cur_obj_spawn_loot_blue_coin);
    smlua_bind_function(L, "cur_obj_spawn_loot_coin_at_mario_pos", smlua_func_cur_obj_spawn_loot_coin_at_mario_pos);
    smlua_bind_function(L, "cur_obj_spawn_particles", smlua_func_cur_obj_spawn_particles);
    smlua_bind_function(L, "cur_obj_spawn_star_at_y_offset", smlua_func_cur_obj_spawn_star_at_y_offset);
    smlua_bind_function(L, "cur_obj_start_cam_event", smlua_func_cur_obj_start_cam_event);
    smlua_bind_function(L, "cur_obj_unhide", smlua_func_cur_obj_unhide);
    smlua_bind_function(L, "cur_obj_unrender_and_reset_state", smlua_func_cur_obj_unrender_and_reset_state);
    smlua_bind_function(L, "cur_obj_unused_init_on_floor", smlua_func_cur_obj_unused_init_on_floor);
    smlua_bind_function(L, "cur_obj_unused_play_footstep_sound", smlua_func_cur_obj_unused_play_footstep_sound);
    smlua_bind_function(L, "cur_obj_unused_resolve_wall_collisions", smlua_func_cur_obj_unused_resolve_wall_collisions);
    smlua_bind_function(L, "cur_obj_update_floor", smlua_func_cur_obj_update_floor);
    smlua_bind_function(L, "cur_obj_update_floor_and_resolve_wall_collisions", smlua_func_cur_obj_update_floor_and_resolve_wall_collisions);
    smlua_bind_function(L, "cur_obj_update_floor_and_walls", smlua_func_cur_obj_update_floor_and_walls);
    smlua_bind_function(L, "cur_obj_update_floor_height", smlua_func_cur_obj_update_floor_height);
    smlua_bind_function(L, "cur_obj_update_floor_height_and_get_floor", smlua_func_cur_obj_update_floor_height_and_get_floor);
    smlua_bind_function(L, "cur_obj_wait_then_blink", smlua_func_cur_obj_wait_then_blink);
    smlua_bind_function(L, "cur_obj_was_attacked_or_ground_pounded", smlua_func_cur_obj_was_attacked_or_ground_pounded);
    smlua_bind_function(L, "cur_obj_within_12k_bounds", smlua_func_cur_obj_within_12k_bounds);
    smlua_bind_function(L, "disable_time_stop", smlua_func_disable_time_stop);
    smlua_bind_function(L, "disable_time_stop_including_mario", smlua_func_disable_time_stop_including_mario);
    smlua_bind_function(L, "dist_between_object_and_point", smlua_func_dist_between_object_and_point);
    smlua_bind_function(L, "dist_between_objects", smlua_func_dist_between_objects);
    smlua_bind_function(L, "enable_time_stop", smlua_func_enable_time_stop);
    smlua_bind_function(L, "enable_time_stop_if_alone", smlua_func_enable_time_stop_if_alone);
    smlua_bind_function(L, "enable_time_stop_including_mario", smlua_func_enable_time_stop_including_mario);
    smlua_bind_function(L, "find_object_with_behavior", smlua_func_find_object_with_behavior);
    smlua_bind_function(L, "find_unimportant_object", smlua_func_find_unimportant_object);
    //smlua_bind_function(L, "geo_choose_area_ext", smlua_func_geo_choose_area_ext); <--- UNIMPLEMENTED
    smlua_bind_function(L, "geo_offset_klepto_debug", smlua_func_geo_offset_klepto_debug);
    //smlua_bind_function(L, "geo_offset_klepto_held_object", smlua_func_geo_offset_klepto_held_object); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_switch_anim_state", smlua_func_geo_switch_anim_state); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_switch_area", smlua_func_geo_switch_area); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_update_layer_transparency", smlua_func_geo_update_layer_transparency); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "geo_update_projectile_pos_from_parent", smlua_func_geo_update_projectile_pos_from_parent); <--- UNIMPLEMENTED
    smlua_bind_function(L, "get_object_list_from_behavior", smlua_func_get_object_list_from_behavior);
    smlua_bind_function(L, "increment_velocity_toward_range", smlua_func_increment_velocity_toward_range);
    smlua_bind_function(L, "is_item_in_array", smlua_func_is_item_in_array);
    smlua_bind_function(L, "is_mario_moving_fast_or_in_air", smlua_func_is_mario_moving_fast_or_in_air);
    smlua_bind_function(L, "lateral_dist_between_objects", smlua_func_lateral_dist_between_objects);
    //smlua_bind_function(L, "linear_mtxf_mul_vec3f", smlua_func_linear_mtxf_mul_vec3f); <--- UNIMPLEMENTED
    //smlua_bind_function(L, "linear_mtxf_transpose_mul_vec3f", smlua_func_linear_mtxf_transpose_mul_vec3f); <--- UNIMPLEMENTED
    smlua_bind_function(L, "mario_is_dive_sliding", smlua_func_mario_is_dive_sliding);
    smlua_bind_function(L, "mario_is_in_air_action", smlua_func_mario_is_in_air_action);
    smlua_bind_function(L, "mario_is_within_rectangle", smlua_func_mario_is_within_rectangle);
    smlua_bind_function(L, "mario_set_flag", smlua_func_mario_set_flag);
    smlua_bind_function(L, "obj_angle_to_object", smlua_func_obj_angle_to_object);
    smlua_bind_function(L, "obj_angle_to_point", smlua_func_obj_angle_to_point);
    //smlua_bind_function(L, "obj_apply_scale_to_matrix", smlua_func_obj_apply_scale_to_matrix); <--- UNIMPLEMENTED
    smlua_bind_function(L, "obj_apply_scale_to_transform", smlua_func_obj_apply_scale_to_transform);
    smlua_bind_function(L, "obj_attack_collided_from_other_object", smlua_func_obj_attack_collided_from_other_object);
    smlua_bind_function(L, "obj_become_tangible", smlua_func_obj_become_tangible);
    smlua_bind_function(L, "obj_build_relative_transform", smlua_func_obj_build_relative_transform);
    smlua_bind_function(L, "obj_build_transform_from_pos_and_angle", smlua_func_obj_build_transform_from_pos_and_angle);
    smlua_bind_function(L, "obj_build_transform_relative_to_parent", smlua_func_obj_build_transform_relative_to_parent);
    smlua_bind_function(L, "obj_build_vel_from_transform", smlua_func_obj_build_vel_from_transform);
    smlua_bind_function(L, "obj_check_if_collided_with_object", smlua_func_obj_check_if_collided_with_object);
    smlua_bind_function(L, "obj_copy_angle", smlua_func_obj_copy_angle);
    smlua_bind_function(L, "obj_copy_behavior_params", smlua_func_obj_copy_behavior_params);
    smlua_bind_function(L, "obj_copy_graph_y_offset", smlua_func_obj_copy_graph_y_offset);
    smlua_bind_function(L, "obj_copy_pos", smlua_func_obj_copy_pos);
    smlua_bind_function(L, "obj_copy_pos_and_angle", smlua_func_obj_copy_pos_and_angle);
    smlua_bind_function(L, "obj_copy_scale", smlua_func_obj_copy_scale);
    smlua_bind_function(L, "obj_create_transform_from_self", smlua_func_obj_create_transform_from_self);
    smlua_bind_function(L, "obj_explode_and_spawn_coins", smlua_func_obj_explode_and_spawn_coins);
    smlua_bind_function(L, "obj_has_behavior", smlua_func_obj_has_behavior);
    smlua_bind_function(L, "obj_init_animation", smlua_func_obj_init_animation);
    //smlua_bind_function(L, "obj_init_animation_with_sound", smlua_func_obj_init_animation_with_sound); <--- UNIMPLEMENTED
    smlua_bind_function(L, "obj_is_hidden", smlua_func_obj_is_hidden);
    smlua_bind_function(L, "obj_mark_for_deletion", smlua_func_obj_mark_for_deletion);
    smlua_bind_function(L, "obj_pitch_to_object", smlua_func_obj_pitch_to_object);
    smlua_bind_function(L, "obj_scale", smlua_func_obj_scale);
    smlua_bind_function(L, "obj_scale_random", smlua_func_obj_scale_random);
    smlua_bind_function(L, "obj_scale_xyz", smlua_func_obj_scale_xyz);
    smlua_bind_function(L, "obj_set_angle", smlua_func_obj_set_angle);
    smlua_bind_function(L, "obj_set_behavior", smlua_func_obj_set_behavior);
    smlua_bind_function(L, "obj_set_billboard", smlua_func_obj_set_billboard);
    //smlua_bind_function(L, "obj_set_collision_data", smlua_func_obj_set_collision_data); <--- UNIMPLEMENTED
    smlua_bind_function(L, "obj_set_cylboard", smlua_func_obj_set_cylboard);
    smlua_bind_function(L, "obj_set_face_angle_to_move_angle", smlua_func_obj_set_face_angle_to_move_angle);
    smlua_bind_function(L, "obj_set_gfx_pos_at_obj_pos", smlua_func_obj_set_gfx_pos_at_obj_pos);
    smlua_bind_function(L, "obj_set_gfx_pos_from_pos", smlua_func_obj_set_gfx_pos_from_pos);
    smlua_bind_function(L, "obj_set_held_state", smlua_func_obj_set_held_state);
    smlua_bind_function(L, "obj_set_hitbox", smlua_func_obj_set_hitbox);
    smlua_bind_function(L, "obj_set_parent_relative_pos", smlua_func_obj_set_parent_relative_pos);
    smlua_bind_function(L, "obj_set_pos", smlua_func_obj_set_pos);
    smlua_bind_function(L, "obj_set_pos_relative", smlua_func_obj_set_pos_relative);
    smlua_bind_function(L, "obj_set_throw_matrix_from_transform", smlua_func_obj_set_throw_matrix_from_transform);
    smlua_bind_function(L, "obj_spawn_loot_blue_coins", smlua_func_obj_spawn_loot_blue_coins);
    smlua_bind_function(L, "obj_spawn_loot_coins", smlua_func_obj_spawn_loot_coins);
    smlua_bind_function(L, "obj_spawn_loot_yellow_coins", smlua_func_obj_spawn_loot_yellow_coins);
    smlua_bind_function(L, "obj_translate_local", smlua_func_obj_translate_local);
    smlua_bind_function(L, "obj_translate_xyz_random", smlua_func_obj_translate_xyz_random);
    smlua_bind_function(L, "obj_translate_xz_random", smlua_func_obj_translate_xz_random);
    smlua_bind_function(L, "obj_turn_toward_object", smlua_func_obj_turn_toward_object);
    //smlua_bind_function(L, "obj_update_pos_from_parent_transformation", smlua_func_obj_update_pos_from_parent_transformation); <--- UNIMPLEMENTED
    smlua_bind_function(L, "player_performed_grab_escape_action", smlua_func_player_performed_grab_escape_action);
    smlua_bind_function(L, "random_f32_around_zero", smlua_func_random_f32_around_zero);
    smlua_bind_function(L, "set_mario_interact_hoot_if_in_range", smlua_func_set_mario_interact_hoot_if_in_range);
    smlua_bind_function(L, "set_time_stop_flags", smlua_func_set_time_stop_flags);
    smlua_bind_function(L, "set_time_stop_flags_if_alone", smlua_func_set_time_stop_flags_if_alone);
    smlua_bind_function(L, "signum_positive", smlua_func_signum_positive);
    smlua_bind_function(L, "spawn_base_star_with_no_lvl_exit", smlua_func_spawn_base_star_with_no_lvl_exit);
    smlua_bind_function(L, "spawn_mist_particles", smlua_func_spawn_mist_particles);
    smlua_bind_function(L, "spawn_mist_particles_with_sound", smlua_func_spawn_mist_particles_with_sound);
    smlua_bind_function(L, "spawn_star_with_no_lvl_exit", smlua_func_spawn_star_with_no_lvl_exit);
    smlua_bind_function(L, "spawn_water_droplet", smlua_func_spawn_water_droplet);
    smlua_bind_function(L, "stub_obj_helpers_3", smlua_func_stub_obj_helpers_3);
    smlua_bind_function(L, "stub_obj_helpers_4", smlua_func_stub_obj_helpers_4);

    // object_list_processor.h
    smlua_bind_function(L, "set_object_respawn_info_bits", smlua_func_set_object_respawn_info_bits);

    // rumble_init.c
    smlua_bind_function(L, "queue_rumble_data", smlua_func_queue_rumble_data);
    smlua_bind_function(L, "queue_rumble_data_mario", smlua_func_queue_rumble_data_mario);
    smlua_bind_function(L, "queue_rumble_data_object", smlua_func_queue_rumble_data_object);
    smlua_bind_function(L, "reset_rumble_timers", smlua_func_reset_rumble_timers);
    smlua_bind_function(L, "reset_rumble_timers_2", smlua_func_reset_rumble_timers_2);

    // save_file.h
    smlua_bind_function(L, "save_file_clear_flags", smlua_func_save_file_clear_flags);
    smlua_bind_function(L, "save_file_get_cap_pos", smlua_func_save_file_get_cap_pos);
    smlua_bind_function(L, "save_file_get_course_coin_score", smlua_func_save_file_get_course_coin_score);
    smlua_bind_function(L, "save_file_get_course_star_count", smlua_func_save_file_get_course_star_count);
    smlua_bind_function(L, "save_file_get_flags", smlua_func_save_file_get_flags);
    smlua_bind_function(L, "save_file_get_max_coin_score", smlua_func_save_file_get_max_coin_score);
    smlua_bind_function(L, "save_file_get_sound_mode", smlua_func_save_file_get_sound_mode);
    smlua_bind_function(L, "save_file_get_star_flags", smlua_func_save_file_get_star_flags);
    smlua_bind_function(L, "save_file_get_total_star_count", smlua_func_save_file_get_total_star_count);
    smlua_bind_function(L, "save_file_set_flags", smlua_func_save_file_set_flags);

    // smlua_audio_utils.h
    smlua_bind_function(L, "audio_sample_destroy", smlua_func_audio_sample_destroy);
    smlua_bind_function(L, "audio_sample_load", smlua_func_audio_sample_load);
    smlua_bind_function(L, "audio_sample_play", smlua_func_audio_sample_play);
    smlua_bind_function(L, "audio_stream_destroy", smlua_func_audio_stream_destroy);
    smlua_bind_function(L, "audio_stream_get_frequency", smlua_func_audio_stream_get_frequency);
    smlua_bind_function(L, "audio_stream_get_looping", smlua_func_audio_stream_get_looping);
    smlua_bind_function(L, "audio_stream_get_position", smlua_func_audio_stream_get_position);
    smlua_bind_function(L, "audio_stream_get_tempo", smlua_func_audio_stream_get_tempo);
    smlua_bind_function(L, "audio_stream_get_volume", smlua_func_audio_stream_get_volume);
    smlua_bind_function(L, "audio_stream_load", smlua_func_audio_stream_load);
    smlua_bind_function(L, "audio_stream_loadURL", smlua_func_audio_stream_loadURL);
    smlua_bind_function(L, "audio_stream_pause", smlua_func_audio_stream_pause);
    smlua_bind_function(L, "audio_stream_play", smlua_func_audio_stream_play);
    smlua_bind_function(L, "audio_stream_set_frequency", smlua_func_audio_stream_set_frequency);
    smlua_bind_function(L, "audio_stream_set_looping", smlua_func_audio_stream_set_looping);
    smlua_bind_function(L, "audio_stream_set_position", smlua_func_audio_stream_set_position);
    smlua_bind_function(L, "audio_stream_set_speed", smlua_func_audio_stream_set_speed);
    smlua_bind_function(L, "audio_stream_set_tempo", smlua_func_audio_stream_set_tempo);
    smlua_bind_function(L, "audio_stream_set_volume", smlua_func_audio_stream_set_volume);
    smlua_bind_function(L, "audio_stream_stop", smlua_func_audio_stream_stop);
    smlua_bind_function(L, "smlua_audio_utils_replace_sequence", smlua_func_smlua_audio_utils_replace_sequence);
    smlua_bind_function(L, "smlua_audio_utils_reset_all", smlua_func_smlua_audio_utils_reset_all);

    // smlua_collision_utils.h
    smlua_bind_function(L, "collision_find_surface_on_ray", smlua_func_collision_find_surface_on_ray);
    smlua_bind_function(L, "get_water_surface_pseudo_floor", smlua_func_get_water_surface_pseudo_floor);
    smlua_bind_function(L, "smlua_collision_util_get", smlua_func_smlua_collision_util_get);

    // smlua_misc_utils.h
    smlua_bind_function(L, "allocate_mario_action", smlua_func_allocate_mario_action);
    smlua_bind_function(L, "camera_freeze", smlua_func_camera_freeze);
    smlua_bind_function(L, "camera_unfreeze", smlua_func_camera_unfreeze);
    smlua_bind_function(L, "deref_s32_pointer", smlua_func_deref_s32_pointer);
    smlua_bind_function(L, "get_current_save_file_num", smlua_func_get_current_save_file_num);
    smlua_bind_function(L, "get_environment_region", smlua_func_get_environment_region);
    smlua_bind_function(L, "get_hand_foot_pos_x", smlua_func_get_hand_foot_pos_x);
    smlua_bind_function(L, "get_hand_foot_pos_y", smlua_func_get_hand_foot_pos_y);
    smlua_bind_function(L, "get_hand_foot_pos_z", smlua_func_get_hand_foot_pos_z);
    smlua_bind_function(L, "get_network_area_timer", smlua_func_get_network_area_timer);
    smlua_bind_function(L, "get_temp_s32_pointer", smlua_func_get_temp_s32_pointer);
    smlua_bind_function(L, "hud_get_value", smlua_func_hud_get_value);
    smlua_bind_function(L, "hud_hide", smlua_func_hud_hide);
    smlua_bind_function(L, "hud_render_power_meter", smlua_func_hud_render_power_meter);
    smlua_bind_function(L, "hud_set_value", smlua_func_hud_set_value);
    smlua_bind_function(L, "hud_show", smlua_func_hud_show);
    smlua_bind_function(L, "is_game_paused", smlua_func_is_game_paused);
    smlua_bind_function(L, "movtexqc_register", smlua_func_movtexqc_register);
    smlua_bind_function(L, "play_transition", smlua_func_play_transition);
    smlua_bind_function(L, "save_file_set_using_backup_slot", smlua_func_save_file_set_using_backup_slot);
    smlua_bind_function(L, "set_environment_region", smlua_func_set_environment_region);
    smlua_bind_function(L, "set_override_far", smlua_func_set_override_far);
    smlua_bind_function(L, "set_override_fov", smlua_func_set_override_fov);
    smlua_bind_function(L, "set_override_near", smlua_func_set_override_near);
    smlua_bind_function(L, "warp_exit_level", smlua_func_warp_exit_level);
    smlua_bind_function(L, "warp_restart_level", smlua_func_warp_restart_level);
    smlua_bind_function(L, "warp_to_castle", smlua_func_warp_to_castle);
    smlua_bind_function(L, "warp_to_level", smlua_func_warp_to_level);

    // smlua_model_utils.h
    smlua_bind_function(L, "smlua_model_util_get_id", smlua_func_smlua_model_util_get_id);

    // smlua_obj_utils.h
    smlua_bind_function(L, "get_temp_object_hitbox", smlua_func_get_temp_object_hitbox);
    smlua_bind_function(L, "get_trajectory", smlua_func_get_trajectory);
    smlua_bind_function(L, "obj_check_hitbox_overlap", smlua_func_obj_check_hitbox_overlap);
    smlua_bind_function(L, "obj_count_objects_with_behavior_id", smlua_func_obj_count_objects_with_behavior_id);
    smlua_bind_function(L, "obj_get_first", smlua_func_obj_get_first);
    smlua_bind_function(L, "obj_get_first_with_behavior_id", smlua_func_obj_get_first_with_behavior_id);
    smlua_bind_function(L, "obj_get_first_with_behavior_id_and_field_f32", smlua_func_obj_get_first_with_behavior_id_and_field_f32);
    smlua_bind_function(L, "obj_get_first_with_behavior_id_and_field_s32", smlua_func_obj_get_first_with_behavior_id_and_field_s32);
    smlua_bind_function(L, "obj_get_nearest_object_with_behavior_id", smlua_func_obj_get_nearest_object_with_behavior_id);
    smlua_bind_function(L, "obj_get_next", smlua_func_obj_get_next);
    smlua_bind_function(L, "obj_get_next_with_same_behavior_id", smlua_func_obj_get_next_with_same_behavior_id);
    smlua_bind_function(L, "obj_get_next_with_same_behavior_id_and_field_f32", smlua_func_obj_get_next_with_same_behavior_id_and_field_f32);
    smlua_bind_function(L, "obj_get_next_with_same_behavior_id_and_field_s32", smlua_func_obj_get_next_with_same_behavior_id_and_field_s32);
    smlua_bind_function(L, "obj_get_temp_spawn_particles_info", smlua_func_obj_get_temp_spawn_particles_info);
    smlua_bind_function(L, "obj_has_behavior_id", smlua_func_obj_has_behavior_id);
    smlua_bind_function(L, "obj_has_model_extended", smlua_func_obj_has_model_extended);
    smlua_bind_function(L, "obj_is_valid_for_interaction", smlua_func_obj_is_valid_for_interaction);
    smlua_bind_function(L, "obj_move_xyz", smlua_func_obj_move_xyz);
    smlua_bind_function(L, "obj_set_model_extended", smlua_func_obj_set_model_extended);
    smlua_bind_function(L, "obj_set_vel", smlua_func_obj_set_vel);
    smlua_bind_function(L, "spawn_non_sync_object", smlua_func_spawn_non_sync_object);
    smlua_bind_function(L, "spawn_sync_object", smlua_func_spawn_sync_object);

    // smlua_text_utils.h
    smlua_bind_function(L, "smlua_text_utils_castle_secret_stars_replace", smlua_func_smlua_text_utils_castle_secret_stars_replace);
    smlua_bind_function(L, "smlua_text_utils_course_acts_replace", smlua_func_smlua_text_utils_course_acts_replace);
    smlua_bind_function(L, "smlua_text_utils_dialog_replace", smlua_func_smlua_text_utils_dialog_replace);
    smlua_bind_function(L, "smlua_text_utils_extra_text_replace", smlua_func_smlua_text_utils_extra_text_replace);
    smlua_bind_function(L, "smlua_text_utils_reset_all", smlua_func_smlua_text_utils_reset_all);
    smlua_bind_function(L, "smlua_text_utils_secret_star_replace", smlua_func_smlua_text_utils_secret_star_replace);

    // sound_init.h
    smlua_bind_function(L, "disable_background_sound", smlua_func_disable_background_sound);
    smlua_bind_function(L, "enable_background_sound", smlua_func_enable_background_sound);
    smlua_bind_function(L, "fadeout_cap_music", smlua_func_fadeout_cap_music);
    smlua_bind_function(L, "fadeout_level_music", smlua_func_fadeout_level_music);
    smlua_bind_function(L, "fadeout_music", smlua_func_fadeout_music);
    smlua_bind_function(L, "lower_background_noise", smlua_func_lower_background_noise);
    smlua_bind_function(L, "play_cap_music", smlua_func_play_cap_music);
    smlua_bind_function(L, "play_cutscene_music", smlua_func_play_cutscene_music);
    smlua_bind_function(L, "play_infinite_stairs_music", smlua_func_play_infinite_stairs_music);
    smlua_bind_function(L, "play_menu_sounds", smlua_func_play_menu_sounds);
    smlua_bind_function(L, "play_painting_eject_sound", smlua_func_play_painting_eject_sound);
    smlua_bind_function(L, "play_shell_music", smlua_func_play_shell_music);
    smlua_bind_function(L, "raise_background_noise", smlua_func_raise_background_noise);
    smlua_bind_function(L, "reset_volume", smlua_func_reset_volume);
    smlua_bind_function(L, "set_background_music", smlua_func_set_background_music);
    smlua_bind_function(L, "stop_cap_music", smlua_func_stop_cap_music);
    smlua_bind_function(L, "stop_shell_music", smlua_func_stop_shell_music);

    // spawn_sound.c
    smlua_bind_function(L, "calc_dist_to_volume_range_1", smlua_func_calc_dist_to_volume_range_1);
    smlua_bind_function(L, "calc_dist_to_volume_range_2", smlua_func_calc_dist_to_volume_range_2);
    smlua_bind_function(L, "cur_obj_play_sound_1", smlua_func_cur_obj_play_sound_1);
    smlua_bind_function(L, "cur_obj_play_sound_2", smlua_func_cur_obj_play_sound_2);
    smlua_bind_function(L, "exec_anim_sound_state", smlua_func_exec_anim_sound_state);

    // surface_collision.h
    //smlua_bind_function(L, "find_ceil", smlua_func_find_ceil); <--- UNIMPLEMENTED
    smlua_bind_function(L, "find_ceil_height", smlua_func_find_ceil_height);
    //smlua_bind_function(L, "find_floor", smlua_func_find_floor); <--- UNIMPLEMENTED
    smlua_bind_function(L, "find_floor_height", smlua_func_find_floor_height);
    //smlua_bind_function(L, "find_floor_height_and_data", smlua_func_find_floor_height_and_data); <--- UNIMPLEMENTED
    smlua_bind_function(L, "find_poison_gas_level", smlua_func_find_poison_gas_level);
    //smlua_bind_function(L, "find_surface_on_ray", smlua_func_find_surface_on_ray); <--- UNIMPLEMENTED
    smlua_bind_function(L, "find_wall_collisions", smlua_func_find_wall_collisions);
    smlua_bind_function(L, "find_water_level", smlua_func_find_water_level);

    // surface_load.h
    smlua_bind_function(L, "alloc_surface_pools", smlua_func_alloc_surface_pools);
    smlua_bind_function(L, "clear_dynamic_surfaces", smlua_func_clear_dynamic_surfaces);
    smlua_bind_function(L, "get_area_terrain_size", smlua_func_get_area_terrain_size);
    smlua_bind_function(L, "load_area_terrain", smlua_func_load_area_terrain);
    smlua_bind_function(L, "load_object_collision_model", smlua_func_load_object_collision_model);

}