local str = [[//#pragma region pe_params_pos
function(SetPos)
    pe_params_pos params;

    params.pos = lua->CheckVec3(2);

    self->SetParams(&params);

    return 0;
end

function(SetRotation)
    pe_params_pos params;

    params.q = lua->CheckQuat(2);

    self->SetParams(&params);

    return 0;
end

function(SetScale)
    pe_params_pos params;

    params.scale = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(ActionPos)
    if (lua->IsTable(2))
    {
        pe_params_pos params;

        lua->Push("RecalcBounds");
        lua->GetTable(-2);
        if(lua->IsVec3(-1))
            params.bRecalcBounds = lua->CheckInteger(-1);

        lua->Push("SimClass");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.iSimClass = lua->CheckInteger(-1);

        lua->Push("Position");
        lua->GetTable(-2);
        if(lua->IsVec3(-1))
            params.pos = lua->CheckVec3(-1);

        lua->Push("Rotation");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.q = lua->CheckQuat(-1);

        lua->Push("Scale");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.scale = lua->CheckInteger(-1);

        self->SetParams(&params);

        return 0;
    }
    return 0;
end


//#pragma endregion pe_params_pos

//#pragma region pe_params_outer_entity
function(SetOuterPhysicalEntity)
    pe_params_outer_entity params;

    params.pOuterEntity = lua->CheckPhysics(2);

    self->SetParams(&params);

    return 0;
end
//#pragma endregion pe_params_outer_entity

//#pragma region pe_simulation_params
function(SetDamping)
    pe_simulation_params params;

    params.damping = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetFreefallDamping)
    pe_simulation_params params;

    params.dampingFreefall = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetDensity)
    pe_simulation_params params;

    params.density = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetGravity)
    pe_simulation_params params;

    params.gravity = lua->CheckVec3(2);

    self->SetParams(&params);

    return 0;
end

function(SetFreefallGravity)
    pe_simulation_params params;

    params.gravityFreefall = lua->CheckVec3(2);

    self->SetParams(&params);

    return 0;
end

function(SetSimClass)
    pe_simulation_params params;

    params.iSimClass = lua->CheckInteger(2);

    self->SetParams(&params);

    return 0;
end

function(SetMass)
    pe_simulation_params params;

    params.mass = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetMaxLoggedCollisions)
    pe_simulation_params params;

    params.maxLoggedCollisions = lua->CheckInteger(2);

    self->SetParams(&params);

    return 0;
end

function(SetMaxTimeStep)
    pe_simulation_params params;

    params.maxTimeStep = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetMinEnergy)
    pe_simulation_params params;

    params.minEnergy = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetSoftness)
    pe_simulation_params params;

    params.softness = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetAngularSoftness)
    pe_simulation_params params;

    params.softnessAngular = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetGroupAngularSoftness)
    pe_simulation_params params;

    params.softnessAngularGroup = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetGroupSoftness)
    pe_simulation_params params;

    params.softnessGroup = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end
//#pragma endregion pe_simulation_params

//#pragma region pe_params_buoyancy
function(SetFlowVariance)
    pe_params_buoyancy params;

    params.flowVariance = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetMedium)
    pe_params_buoyancy params;

    params.iMedium = lua->CheckInteger(2);

    self->SetParams(&params);

    return 0;
end

function(SetkWaterDensity)
    pe_params_buoyancy params;

    params.kwaterDensity = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetkWaterResistance)
    pe_params_buoyancy params;

    params.kwaterResistance = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetWaterDamping)
    pe_params_buoyancy params;

    params.waterDamping = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetWaterDensity)
    pe_params_buoyancy params;

    params.waterDensity = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetWaterEmin)
    pe_params_buoyancy params;

    params.waterEmin = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end

function(SetWaterResistance)
    pe_params_buoyancy params;

    params.waterResistance = lua->CheckNumber(2);

    self->SetParams(&params);

    return 0;
end
//#pragma endregion pe_params_buoyancy

//#pragma region pe_params_flags
function(SetFlags)
    pe_params_flags params;

    params.flags = lua->CheckInteger(2);

    self->SetParams(&params);

    return 0;
end
//#pragma endregion pe_params_flags

//#pragma region pe_action_impulse
function(AddAngularImpulse)
    pe_action_impulse params;

    params.angImpulse = lua->CheckVec3(2);

    self->Action(&params);

    return 0;
end

function(AddImpulse)
    pe_action_impulse params;

    params.impulse = lua->CheckVec3(2);

    self->Action(&params);

    //lua_pop(-2);

    return 0;
end

function(ActionImpulse)
    if (lua->IsTable(2))
    {
        pe_action_impulse params;

        lua->Push("AngularImpulse");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.angImpulse = lua->CheckVec3(-1);

        lua->Push("ApplyTime");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.iApplyTime = lua->CheckInteger(-1);

        lua->Push("Impulse");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.impulse = lua->CheckVec3(-1);

        lua->Push("Part");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.ipart = lua->CheckInteger(-1);

        lua->Push("PartID");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.partid = lua->CheckInteger(-1);

        lua->Push("Point");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pofunction(= lua->CheckVec3(-1);

        self->Action(&params);

        return 0;
    }
    return 0;
end
//#pragma endregion pe_action_impulse

//#pragma region pe_action_reset
function(Reset)
    pe_action_reset params;

    params.bClearContacts = lua->CheckInteger(2);

    self->Action(&params);

    return 0;
end
//#pragma endregion pe_action_reset

//#pragma region pe_action_awake
function(Wake)
    pe_action_awake params;

    params.bAwake = lua->CheckInteger(2);

    self->Action(&params);

    return 0;
end
//#pragma endregion pe_action_awake

//#pragma region pe_action_set_velocity
function(SetVelocity)
    pe_action_set_velocity params;

    params.v = lua->CheckVec3(2);

    self->Action(&params);

    return 0;
end

function(SetAngularVelocity)
    pe_action_set_velocity params;

    params.w = lua->CheckVec3(2);

    self->Action(&params);

    return 0;
end

function(ActionVelocity)
    if (lua->IsTable(2))
    {
        pe_action_set_velocity params;

        lua->Push("Part");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.ipart = lua->CheckInteger(-1);

        lua->Push("PartID");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.partid = lua->CheckInteger(-1);

        lua->Push("Velocity");
        lua->GetTable(-2);
        if(lua->IsNumber(-1))
            params.v = lua->CheckVec3(-1);

        lua->Push("AngularVelocity");
        lua->GetTable(-2);
        if(lua->IsVec3(-1))
            params.w = lua->CheckVec3(-1);

        self->Action(&params);

        return 0;
    }
    return 0;
end
//#pragma endregion pe_action_set_velocity

//#pragma endregion Set~

//#pragma region Get

//#pragma region pe_status_pos
function(GetBBoxMin)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.BBox[0]);

    return 1;
end

function(GetBBoxMax)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.BBox[1]);

    return 1;
end

function(GetFlags)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.flags);

    return 1;
end

function(GetSimClass)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.iSimClass);

    return 1;
end

function(GetPartID)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.partid);

    return 1;
end

function(GetPos)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.pos);

    return 1;
end

function(GetRotation)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.q);

    return 1;
end

function(GetScale)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(params.scale);

    return 1;
end
//#pragma endregion pe_status_pos

//#pragma region pe_status_random
function(GetRandomPos)
    pe_status_random params;

    self->GetStatus(&params);

    lua->Push(params.ran.vPos);
    lua->Push(params.ran.vNorm);

    return 2;
end
//#pragma endregion pe_status_random

//#pragma region pe_status_dynamics
function(GetAcceleration)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.a);

    return 1;
end

function(GetCenterOfMass)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.centerOfMass);

    return 1;
end

function(GetEnergy)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.energy);

    return 1;
end

function(GetMass)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.mass);

    return 1;
end

function(GetNumberOfContacts)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.nContacts);

    return 1;
end

function(GetSubmergedFraction)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.submergedFraction);

    return 1;
end
/*
function(GetTimeInterval)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.time_interval);

    return 1;
end*/
function(GetVelocity)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.v);

    return 1;
end

function(GetAngularVelocity)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.w);

    return 1;
end

function(GetAngularAcceleration)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(params.wa);

    return 1;
end
//#pragma endregion pe_status_dynamics

//#pragma region pe_status_collisions
function(GetLastCollisionAge)
    pe_status_collisions params;

    self->GetStatus(&params);

    lua->Push(params.age);

    return 1;
end

function(GetLastCollisionID)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(params.pHistory->idCollider);

    return 1;
end

function(GetLastCollisionMaterials)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(params.pHistory->idmat[1]);
    lua->Push(params.pHistory->idmat[2]);

    return 1;
end

function(GetLastCollisionNormal)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(params.pHistory->n);

    return 1;
end

function(GetLastCollisionPoint)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(params.pHistory->pt);

    return 1;
end

function(GetLastCollisionPoints)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(params.pHistory->v[1]);
    lua->Push(params.pHistory->v[2]);

    return 1;
end
//#pragma endregion pe_status_collisions

//#pragma region pe_status_timeslices
function(GetPrecision)
    pe_status_timeslices params;

    self->GetStatus(&params);

    lua->Push(params.precision);

    return 1;
end

function(GetTimeInterval)
    pe_status_timeslices params;

    self->GetStatus(&params);

    lua->Push(params.time_interval);

    return 1;
end
//#pragma endregion pe_status_timeslices

//#pragma region pe_status_awake
function(IsAwake)
    pe_status_awake params;

    self->GetStatus(&params);

    lua->Push(params.lag);

    return 1;
end
//#pragma endregion pe_status_awake

//#pragma region Get~

//pe_params_articulated_body
function(SetArticulatedBody)
    if (lua->IsTable(2))
    {
        pe_params_articulated_body params;

        lua->Push("Acceleration");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.a = lua->CheckVec3(-1);

        lua->Push("ApplyDqext");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bApply_dqext = lua->ToBoolean(-1);

        lua->Push("Awake");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bAwake = lua->ToBoolean(-1);

        lua->Push("CheckCollisions");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bCheckCollisions = lua->ToBoolean(-1);

        lua->Push("CollisionResponse");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bCollisionResp = lua->ToBoolean(-1);

        lua->Push("ExpandHinges");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bExpandHinges = lua->ToBoolean(-1);

        lua->Push("Grounded");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bGrounded = lua->ToBoolean(-1);

        lua->Push("InheritVelocity");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bInheritVel = lua->ToBoolean(-1);

        lua->Push("RecalcJoints");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bRecalcJoints = lua->ToBoolean(-1);

        lua->Push("DampingLyingMode");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.dampingLyingMode = lua->CheckNumber(-1);

        lua->Push("GravityLyingMode");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.gravityLyingMode = lua->CheckVec3(-1);

        lua->Push("SimType");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.iSimType = lua->CheckInteger(-1);

        lua->Push("SimTypeLyingMode");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.iSimTypeLyingMode = lua->CheckInteger(-1);

        lua->Push("MinEnergyLyingMode");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.minEnergyLyingMode = lua->CheckNumber(-1);

        lua->Push("CollidingLyingMode");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.nCollLyingMode = lua->CheckInteger(-1);

        lua->Push("Roots");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.nRoots = lua->CheckInteger(-1);

        lua->Push("Host");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pHost = Check(-1);

        lua->Push("Pivot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pivot = lua->CheckVec3(-1);

        lua->Push("Vec3HostPivot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.posHostPivot = lua->CheckVec3(-1);

        lua->Push("QuatHostPivot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qHostPivot = lua->CheckQuat(-1);

        lua->Push("ScaleBounceResponse");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.scaleBounceResponse = lua->CheckNumber(-1);

        //I don't know what the following are shortened for
        lua->Push("v");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.v = lua->CheckVec3(-1);

        lua->Push("w");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.w = lua->CheckVec3(-1);

        lua->Push("wa");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.wa = lua->CheckVec3(-1);

        self->SetParams(&params);

        return 0;
    }
    return 0;
end

function(SetJoint)
    if (lua->IsTable(2))
    {
        pe_params_jofunction(params;

        lua->Push("AnimationTimeStep");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.animationTimeStep = lua->CheckNumber(-1);

        lua->Push("NoUpdate");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bNoUpdate = lua->ToBoolean(-1);

        lua->Push("Bounciness");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.bounciness = lua->CheckVec3(-1);

        lua->Push("Flags");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.flags = lua->CheckInteger(-1);

        lua->Push("FlagsPivot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.flagsPivot = lua->CheckInteger(-1);

        lua->Push("kd");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.kd = lua->CheckVec3(-1);

        lua->Push("kdashpot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.kdashpot = lua->CheckVec3(-1);

        lua->Push("ks");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.ks = lua->CheckVec3(-1);

        lua->Push("Limits1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.limits[1] = lua->CheckVec3(-1);

        lua->Push("Limits2");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.limits[2] = lua->CheckVec3(-1);

        lua->Push("SelfCollidingParts");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.nSelfCollidingParts = lua->CheckInteger(-1);

        lua->Push("op1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.op[1] = lua->CheckInteger(-1);

        lua->Push("op2");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.op[2] = lua->CheckInteger(-1);

        lua->Push("Pivot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pivot = lua->CheckVec3(-1);

        lua->Push("Angle");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.q = Lua_Ang3::Check(-1);

        lua->Push("Quat0");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.q0 = lua->CheckQuat(-1);

        lua->Push("qdashpot");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qdashpot = lua->CheckVec3(-1);

        lua->Push("qext");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qext = Lua_Ang3::Check(-1);

        lua->Push("AngleTarget");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qtarget = Lua_Ang3::Check(-1);

        lua->Push("rAnimationTimeStep");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.ranimationTimeStep = lua->CheckNumber(-1);

        lua->Push(self->SetParams(&params));

        return 0;
    }
    return 0;
end

function(AddConstraint)
    if (lua->IsTable(2))
    {
        pe_action_add_constrafunction(params;

        lua->Push("Damping");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.damping = lua->CheckNumber(-1);

        lua->Push("Flags");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.flags = lua->CheckInteger(-1);

        lua->Push("ID");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.id = lua->CheckInteger(-1);

        lua->Push("MaxBendTorque");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.maxBendTorque = lua->CheckNumber(-1);

        lua->Push("MaxPullForce");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.maxPullForce = lua->CheckNumber(-1);

        lua->Push("PartID1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.partid[1] = lua->CheckInteger(-1);

        lua->Push("PartID2");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.partid[2] = lua->CheckInteger(-1);

        lua->Push("Buddy");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pBuddy = Check(-1);

        lua->Push("ConstraintEntity");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pConstraintEntity = Check(-1);

        lua->Push("Point1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pt[1] = lua->CheckVec3(-1);

        lua->Push("Point1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.pt[2] = lua->CheckVec3(-1);

        lua->Push("QuatFrame1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qframe[1] = lua->CheckQuat(-1);

        lua->Push("QuatFrame1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.qframe[2] = lua->CheckQuat(-1);

        lua->Push("SensorRadius");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.sensorRadius = lua->CheckNumber(-1);

        lua->Push("XLimits1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.xlimits[1] = lua->CheckNumber(-1);

        lua->Push("XLimits2");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.xlimits[2] = lua->CheckNumber(-1);

        lua->Push("YZLimits1");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.yzlimits[1] = lua->CheckNumber(-1);

        lua->Push("YZLimits2");
        lua->GetTable(2);
        if(!lua->IsNil(-1))
            params.yzlimits[2] = lua->CheckNumber(-1);

        self->Action(&params);

        return 0;
    }
    return 0;
end

function(GetEntity)
    lua->Push(gEnv->pEntitySystem->GetEntityFromPhysics(self));
    return 1;
end

#define GetProxy() \
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);\
\
    if(!entity) return 0;\
\
    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);\
\
    if(!proxy) return 0;\
\
    proxy

#define CheckProxy() \
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);\
\
    if(!entity) return 0;\
\
    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);\
\
    if(!proxy) return 0;\


function(AssignPhysicalEntity)
    ->AssignPhysicalEntity(Get(2), luaL_optint(3, -1));

    return 0;
end

function(DephysicalizeFoliage)
    GetProxy()->DephysicalizeFoliage(lua->ToBoolean(2));

    return 0;
end

function(EnablePhysics)
    GetProxy()->EnablePhysics(lua->ToBoolean(2));

    return 1;
end

function(EnableRestrictedRagdoll)
    GetProxy()->EnableRestrictedRagdoll(lua->ToBoolean(2));

    return 1;
end

function(GetLocalBounds)
    CheckProxy()

    AABB aabb;

    proxy->GetLocalBounds(aabb);

    lua->NewTable(L);

    lua->Push("Center");
    lua->Push(aabb.GetCenter());
    lua->SetTable(-3);

    lua->Push("Radius");
    lua->Push(aabb.GetRadius());
    lua->SetTable(-3);

    lua->Push("Size");
    lua->Push(aabb.GetSize());
    lua->SetTable(-3);

    lua->Push("Volume");
    lua->Push(aabb.GetVolume());
    lua->SetTable(-3);

    lua->Push("Max");
    lua->Push(aabb.max);
    lua->SetTable(-3);

    lua->Push("Min");
    lua->Push(aabb.min);
    lua->SetTable(-3);

    return 1;
end

function(GetWorldBounds)
    CheckProxy()

    AABB aabb;

    proxy->GetWorldBounds(aabb);

    lua->NewTable(L);

    lua->Push("Center");
    lua->Push(aabb.GetCenter());
    lua->SetTable(-3);

    lua->Push("Radius");
    lua->Push(aabb.GetRadius());
    lua->SetTable(-3);

    lua->Push("Size");
    lua->Push(aabb.GetSize());
    lua->SetTable(-3);

    lua->Push("Volume");
    lua->Push(aabb.GetVolume());
    lua->SetTable(-3);

    lua->Push("Max");
    lua->Push(aabb.max);
    lua->SetTable(-3);

    lua->Push("Min");
    lua->Push(aabb.min);
    lua->SetTable(-3);

    return 1;
end

function(IsRestrictedRagdoll)
    CheckProxy()

    lua->Push(proxy->IsRestrictedRagdoll());

    return 1;
end]]

for _, line in pairs(str:Split"\n") do
    if line:find("function") then
        print(line:gsub("function", "REG") .. ";")
    end
end