DedicatedServerCourse/Intermediate/Build/Win64/FPSTemplateServer/Inc/RigVM/UHT/RigVMFunction_MathFloat.gen.cpp

// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
	Generated code exported from UnrealHeaderTool.
	DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/

#include "UObject/GeneratedCppIncludes.h"
#include "RigVMFunctions/Math/RigVMFunction_MathFloat.h"
#include "RigVMCore/RigVMFunction.h"
#include "RigVMCore/RigVMRegistry.h"

PRAGMA_DISABLE_DEPRECATION_WARNINGS
static_assert(!UE_WITH_CONSTINIT_UOBJECT, "This generated code can only be compiled with !UE_WITH_CONSTINIT_OBJECT");
void EmptyLinkFunctionForGeneratedCodeRigVMFunction_MathFloat() {}

// ********** Begin Cross Module References ********************************************************
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathBase();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp();
UPackage* Z_Construct_UPackage__Script_RigVM();
// ********** End Cross Module References **********************************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBase **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatBase); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatBase); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Abstract", "" },
		{ "Category", "Math|Float" },
		{ "MenuDescSuffix", "(Float)" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBase constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatBase constinit property declarations ********
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatBase>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatBase>() == std::is_polymorphic<FRigVMFunction_MathBase>(), "USTRUCT FRigVMFunction_MathFloatBase cannot be polymorphic unless super FRigVMFunction_MathBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase;
class UScriptStruct* FRigVMFunction_MathFloatBase::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatBase"));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathBase,
	&NewStructOps,
	"RigVMFunction_MathFloatBase",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatBase),
	alignof(FRigVMFunction_MathFloatBase),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatBase ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstant **********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatConstant); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatConstant); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Abstract", "" },
		{ "BlueprintType", "true" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstant constinit property declarations **
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatConstant constinit property declarations ****
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatConstant>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatConstant>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatConstant cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant;
class UScriptStruct* FRigVMFunction_MathFloatConstant::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatConstant"));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstant Property Definitions *************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatConstant, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::NewProp_Value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatConstant Property Definitions ***************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatConstant",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatConstant),
	alignof(FRigVMFunction_MathFloatConstant),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatConstant ************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatUnaryOp ***********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatUnaryOp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatUnaryOp); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Abstract", "" },
		{ "BlueprintType", "true" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatUnaryOp constinit property declarations ***
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatUnaryOp constinit property declarations *****
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatUnaryOp>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatUnaryOp cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp;
class UScriptStruct* FRigVMFunction_MathFloatUnaryOp::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatUnaryOp"));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatUnaryOp Property Definitions **************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatUnaryOp, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatUnaryOp, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatUnaryOp Property Definitions ****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatUnaryOp",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatUnaryOp),
	alignof(FRigVMFunction_MathFloatUnaryOp),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatUnaryOp *************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryOp **********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatBinaryOp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatBinaryOp); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Abstract", "" },
		{ "BlueprintType", "true" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryOp constinit property declarations **
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryOp constinit property declarations ****
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatBinaryOp>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatBinaryOp cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp;
class UScriptStruct* FRigVMFunction_MathFloatBinaryOp::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatBinaryOp"));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryOp Property Definitions *************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryOp, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryOp, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryOp, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryOp Property Definitions ***************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatBinaryOp",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatBinaryOp),
	alignof(FRigVMFunction_MathFloatBinaryOp),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryOp ************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp *************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatBinaryAggregateOp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatBinaryAggregateOp); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Abstract", "" },
		{ "BlueprintType", "true" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Aggregate", "" },
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Aggregate", "" },
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Aggregate", "" },
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp constinit property declarations 
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatBinaryAggregateOp>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatBinaryAggregateOp>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatBinaryAggregateOp cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp;
class UScriptStruct* FRigVMFunction_MathFloatBinaryAggregateOp::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatBinaryAggregateOp"));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp Property Definitions ****
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryAggregateOp, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryAggregateOp, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatBinaryAggregateOp, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp Property Definitions ******
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatBinaryAggregateOp",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatBinaryAggregateOp),
	alignof(FRigVMFunction_MathFloatBinaryAggregateOp),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatBinaryAggregateOp ***************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMake **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatMake); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatMake); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * A float constant\n */" },
		{ "Deprecated", "5.7" },
		{ "DisplayName", "Float" },
		{ "Keywords", "Make,Construct,Constant" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "ToolTip", "A float constant" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMake constinit property declarations ******
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatMake constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatMake::Execute"), 
			.Function = &FRigVMFunction_MathFloatMake::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatMake>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatMake>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatMake cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake;
class UScriptStruct* FRigVMFunction_MathFloatMake::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatMake"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMake Property Definitions *****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatMake, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::NewProp_Value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatMake Property Definitions *******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatMake",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatMake),
	alignof(FRigVMFunction_MathFloatMake),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake.InnerSingleton);
}
void FRigVMFunction_MathFloatMake::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatMake::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatMake ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstPi ***********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatConstPi); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatConstPi); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns PI\n */" },
		{ "DisplayName", "Pi" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Pi" },
		{ "ToolTip", "Returns PI" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstPi constinit property declarations ***
// ********** End ScriptStruct FRigVMFunction_MathFloatConstPi constinit property declarations *****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatConstPi::Execute"), 
			.Function = &FRigVMFunction_MathFloatConstPi::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatConstPi>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatConstPi>() == std::is_polymorphic<FRigVMFunction_MathFloatConstant>(), "USTRUCT FRigVMFunction_MathFloatConstPi cannot be polymorphic unless super FRigVMFunction_MathFloatConstant is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi;
class UScriptStruct* FRigVMFunction_MathFloatConstPi::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatConstPi"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant,
	&NewStructOps,
	"RigVMFunction_MathFloatConstPi",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatConstPi),
	alignof(FRigVMFunction_MathFloatConstPi),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi.InnerSingleton);
}
void FRigVMFunction_MathFloatConstPi::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatConstPi::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatConstPi *************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstHalfPi *******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatConstHalfPi); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatConstHalfPi); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns PI * 0.5\n */" },
		{ "DisplayName", "Half Pi" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "HalfPi" },
		{ "ToolTip", "Returns PI * 0.5" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstHalfPi constinit property declarations 
// ********** End ScriptStruct FRigVMFunction_MathFloatConstHalfPi constinit property declarations *
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatConstHalfPi::Execute"), 
			.Function = &FRigVMFunction_MathFloatConstHalfPi::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatConstHalfPi>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatConstHalfPi>() == std::is_polymorphic<FRigVMFunction_MathFloatConstant>(), "USTRUCT FRigVMFunction_MathFloatConstHalfPi cannot be polymorphic unless super FRigVMFunction_MathFloatConstant is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi;
class UScriptStruct* FRigVMFunction_MathFloatConstHalfPi::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatConstHalfPi"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant,
	&NewStructOps,
	"RigVMFunction_MathFloatConstHalfPi",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatConstHalfPi),
	alignof(FRigVMFunction_MathFloatConstHalfPi),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi.InnerSingleton);
}
void FRigVMFunction_MathFloatConstHalfPi::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatConstHalfPi::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatConstHalfPi *********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstTwoPi ********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatConstTwoPi); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatConstTwoPi); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns PI * 2.0\n */" },
		{ "DisplayName", "Two Pi" },
		{ "Keywords", "Tau" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "TwoPi" },
		{ "ToolTip", "Returns PI * 2.0" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstTwoPi constinit property declarations 
// ********** End ScriptStruct FRigVMFunction_MathFloatConstTwoPi constinit property declarations **
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatConstTwoPi::Execute"), 
			.Function = &FRigVMFunction_MathFloatConstTwoPi::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatConstTwoPi>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatConstTwoPi>() == std::is_polymorphic<FRigVMFunction_MathFloatConstant>(), "USTRUCT FRigVMFunction_MathFloatConstTwoPi cannot be polymorphic unless super FRigVMFunction_MathFloatConstant is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi;
class UScriptStruct* FRigVMFunction_MathFloatConstTwoPi::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatConstTwoPi"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant,
	&NewStructOps,
	"RigVMFunction_MathFloatConstTwoPi",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatConstTwoPi),
	alignof(FRigVMFunction_MathFloatConstTwoPi),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi.InnerSingleton);
}
void FRigVMFunction_MathFloatConstTwoPi::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatConstTwoPi::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatConstTwoPi **********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstE ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatConstE); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatConstE); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns E\n */" },
		{ "DisplayName", "E" },
		{ "Keywords", "Euler" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "E" },
		{ "ToolTip", "Returns E" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatConstE constinit property declarations ****
// ********** End ScriptStruct FRigVMFunction_MathFloatConstE constinit property declarations ******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatConstE::Execute"), 
			.Function = &FRigVMFunction_MathFloatConstE::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatConstE>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatConstE>() == std::is_polymorphic<FRigVMFunction_MathFloatConstant>(), "USTRUCT FRigVMFunction_MathFloatConstE cannot be polymorphic unless super FRigVMFunction_MathFloatConstant is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE;
class UScriptStruct* FRigVMFunction_MathFloatConstE::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatConstE"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant,
	&NewStructOps,
	"RigVMFunction_MathFloatConstE",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatConstE),
	alignof(FRigVMFunction_MathFloatConstE),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE.InnerSingleton);
}
void FRigVMFunction_MathFloatConstE::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatConstE::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatConstE **************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAdd ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAdd); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAdd); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the sum of the two values\n */" },
		{ "DisplayName", "Add" },
		{ "Keywords", "Sum,+" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Add" },
		{ "ToolTip", "Returns the sum of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAdd constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatAdd constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAdd::Execute"), 
			.Function = &FRigVMFunction_MathFloatAdd::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAdd>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAdd>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryAggregateOp>(), "USTRUCT FRigVMFunction_MathFloatAdd cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryAggregateOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd;
class UScriptStruct* FRigVMFunction_MathFloatAdd::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAdd"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAdd",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAdd),
	alignof(FRigVMFunction_MathFloatAdd),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd.InnerSingleton);
}
void FRigVMFunction_MathFloatAdd::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAdd::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAdd *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSub ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatSub); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatSub); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the difference of the two values\n */" },
		{ "DisplayName", "Subtract" },
		{ "Keywords", "-" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Subtract" },
		{ "ToolTip", "Returns the difference of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSub constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatSub constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatSub::Execute"), 
			.Function = &FRigVMFunction_MathFloatSub::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatSub>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatSub>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>(), "USTRUCT FRigVMFunction_MathFloatSub cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub;
class UScriptStruct* FRigVMFunction_MathFloatSub::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatSub"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatSub",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatSub),
	alignof(FRigVMFunction_MathFloatSub),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub.InnerSingleton);
}
void FRigVMFunction_MathFloatSub::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatSub::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatSub *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMul ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatMul); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatMul); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the product of the two values\n */" },
		{ "DisplayName", "Multiply" },
		{ "Keywords", "Product,*" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Multiply" },
		{ "ToolTip", "Returns the product of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMul constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatMul constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatMul::Execute"), 
			.Function = &FRigVMFunction_MathFloatMul::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatMul>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatMul>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryAggregateOp>(), "USTRUCT FRigVMFunction_MathFloatMul cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryAggregateOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul;
class UScriptStruct* FRigVMFunction_MathFloatMul::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatMul"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp,
	&NewStructOps,
	"RigVMFunction_MathFloatMul",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatMul),
	alignof(FRigVMFunction_MathFloatMul),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul.InnerSingleton);
}
void FRigVMFunction_MathFloatMul::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatMul::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatMul *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatDiv ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatDiv); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatDiv); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the division of the two values\n */" },
		{ "DisplayName", "Divide" },
		{ "Keywords", "Division,Divisor,/" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Divide" },
		{ "ToolTip", "Returns the division of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatDiv constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatDiv constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatDiv::Execute"), 
			.Function = &FRigVMFunction_MathFloatDiv::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatDiv>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatDiv>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>(), "USTRUCT FRigVMFunction_MathFloatDiv cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv;
class UScriptStruct* FRigVMFunction_MathFloatDiv::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatDiv"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatDiv",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatDiv),
	alignof(FRigVMFunction_MathFloatDiv),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv.InnerSingleton);
}
void FRigVMFunction_MathFloatDiv::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatDiv::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatDiv *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMod ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatMod); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatMod); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the modulo of the two values\n */" },
		{ "DisplayName", "Modulo" },
		{ "Keywords", "%,fmod" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Modulo" },
		{ "ToolTip", "Returns the modulo of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMod constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatMod constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatMod::Execute"), 
			.Function = &FRigVMFunction_MathFloatMod::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatMod>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatMod>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>(), "USTRUCT FRigVMFunction_MathFloatMod cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod;
class UScriptStruct* FRigVMFunction_MathFloatMod::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatMod"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatMod",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatMod),
	alignof(FRigVMFunction_MathFloatMod),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod.InnerSingleton);
}
void FRigVMFunction_MathFloatMod::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatMod::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatMod *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMin ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatMin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatMin); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the smaller of the two values\n */" },
		{ "DisplayName", "Minimum" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Minimum" },
		{ "ToolTip", "Returns the smaller of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMin constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatMin constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatMin::Execute"), 
			.Function = &FRigVMFunction_MathFloatMin::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatMin>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatMin>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryAggregateOp>(), "USTRUCT FRigVMFunction_MathFloatMin cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryAggregateOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin;
class UScriptStruct* FRigVMFunction_MathFloatMin::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatMin"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp,
	&NewStructOps,
	"RigVMFunction_MathFloatMin",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatMin),
	alignof(FRigVMFunction_MathFloatMin),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin.InnerSingleton);
}
void FRigVMFunction_MathFloatMin::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatMin::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatMin *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMax ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatMax); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatMax); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the larger of the two values\n */" },
		{ "DisplayName", "Maximum" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Maximum" },
		{ "ToolTip", "Returns the larger of the two values" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatMax constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatMax constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatMax::Execute"), 
			.Function = &FRigVMFunction_MathFloatMax::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatMax>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatMax>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryAggregateOp>(), "USTRUCT FRigVMFunction_MathFloatMax cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryAggregateOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax;
class UScriptStruct* FRigVMFunction_MathFloatMax::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatMax"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp,
	&NewStructOps,
	"RigVMFunction_MathFloatMax",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatMax),
	alignof(FRigVMFunction_MathFloatMax),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax.InnerSingleton);
}
void FRigVMFunction_MathFloatMax::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatMax::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatMax *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatPow ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatPow); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatPow); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the value of A raised to the power of B.\n */" },
		{ "DisplayName", "Power" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Power" },
		{ "ToolTip", "Returns the value of A raised to the power of B." },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatPow constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatPow constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatPow::Execute"), 
			.Function = &FRigVMFunction_MathFloatPow::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatPow>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatPow>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>(), "USTRUCT FRigVMFunction_MathFloatPow cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow;
class UScriptStruct* FRigVMFunction_MathFloatPow::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatPow"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatPow",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatPow),
	alignof(FRigVMFunction_MathFloatPow),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow.InnerSingleton);
}
void FRigVMFunction_MathFloatPow::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatPow::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatPow *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSqrt **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatSqrt); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatSqrt); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the square root of the given value\n */" },
		{ "DisplayName", "Sqrt" },
		{ "Keywords", "Root,Square" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Sqrt" },
		{ "ToolTip", "Returns the square root of the given value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSqrt constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatSqrt constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatSqrt::Execute"), 
			.Function = &FRigVMFunction_MathFloatSqrt::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatSqrt>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatSqrt>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatSqrt cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt;
class UScriptStruct* FRigVMFunction_MathFloatSqrt::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatSqrt"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatSqrt",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatSqrt),
	alignof(FRigVMFunction_MathFloatSqrt),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt.InnerSingleton);
}
void FRigVMFunction_MathFloatSqrt::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatSqrt::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatSqrt ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatNegate ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatNegate); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatNegate); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the negative value\n */" },
		{ "DisplayName", "Negate" },
		{ "Keywords", "-,Abs" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Negate" },
		{ "ToolTip", "Returns the negative value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatNegate constinit property declarations ****
// ********** End ScriptStruct FRigVMFunction_MathFloatNegate constinit property declarations ******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatNegate::Execute"), 
			.Function = &FRigVMFunction_MathFloatNegate::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatNegate>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatNegate>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatNegate cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate;
class UScriptStruct* FRigVMFunction_MathFloatNegate::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatNegate"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatNegate",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatNegate),
	alignof(FRigVMFunction_MathFloatNegate),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate.InnerSingleton);
}
void FRigVMFunction_MathFloatNegate::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatNegate::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatNegate **************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAbs ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAbs); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAbs); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the absolute (positive) value\n */" },
		{ "DisplayName", "Absolute" },
		{ "Keywords", "Abs,Neg" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Absolute" },
		{ "ToolTip", "Returns the absolute (positive) value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAbs constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatAbs constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAbs::Execute"), 
			.Function = &FRigVMFunction_MathFloatAbs::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAbs>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAbs>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatAbs cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs;
class UScriptStruct* FRigVMFunction_MathFloatAbs::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAbs"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAbs",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAbs),
	alignof(FRigVMFunction_MathFloatAbs),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs.InnerSingleton);
}
void FRigVMFunction_MathFloatAbs::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAbs::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAbs *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatFloor *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatFloor); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatFloor); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the closest lower full number (integer) of the value\n */" },
		{ "DisplayName", "Floor" },
		{ "Keywords", "Round" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Floor" },
		{ "ToolTip", "Returns the closest lower full number (integer) of the value" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatFloor constinit property declarations *****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FIntPropertyParams NewProp_Int;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatFloor constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Int"), .Type = TEXT("int32"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatFloor::Execute"), 
			.Function = &FRigVMFunction_MathFloatFloor::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatFloor>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatFloor>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatFloor cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor;
class UScriptStruct* FRigVMFunction_MathFloatFloor::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatFloor"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatFloor Property Definitions ****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatFloor, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatFloor, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Int = { "Int", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatFloor, Int), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Int_MetaData), NewProp_Int_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Result,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewProp_Int,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatFloor Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatFloor",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatFloor),
	alignof(FRigVMFunction_MathFloatFloor),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor.InnerSingleton);
}
void FRigVMFunction_MathFloatFloor::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatFloor::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result,
		Int
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatFloor ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatCeil **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatCeil); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatCeil); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the closest higher full number (integer) of the value\n */" },
		{ "DisplayName", "Ceiling" },
		{ "Keywords", "Round" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Ceiling" },
		{ "ToolTip", "Returns the closest higher full number (integer) of the value" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatCeil constinit property declarations ******
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FIntPropertyParams NewProp_Int;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatCeil constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Int"), .Type = TEXT("int32"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatCeil::Execute"), 
			.Function = &FRigVMFunction_MathFloatCeil::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatCeil>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatCeil>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatCeil cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil;
class UScriptStruct* FRigVMFunction_MathFloatCeil::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatCeil"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatCeil Property Definitions *****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatCeil, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatCeil, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Int = { "Int", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatCeil, Int), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Int_MetaData), NewProp_Int_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Result,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewProp_Int,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatCeil Property Definitions *******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatCeil",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatCeil),
	alignof(FRigVMFunction_MathFloatCeil),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil.InnerSingleton);
}
void FRigVMFunction_MathFloatCeil::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatCeil::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result,
		Int
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatCeil ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRound *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatRound); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatRound); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the closest higher full number (integer) of the value\n */" },
		{ "DisplayName", "Round" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Round" },
		{ "ToolTip", "Returns the closest higher full number (integer) of the value" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRound constinit property declarations *****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FIntPropertyParams NewProp_Int;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatRound constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Int"), .Type = TEXT("int32"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatRound::Execute"), 
			.Function = &FRigVMFunction_MathFloatRound::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatRound>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatRound>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatRound cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound;
class UScriptStruct* FRigVMFunction_MathFloatRound::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatRound"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRound Property Definitions ****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRound, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRound, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Int = { "Int", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRound, Int), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Int_MetaData), NewProp_Int_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Result,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewProp_Int,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatRound Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatRound",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatRound),
	alignof(FRigVMFunction_MathFloatRound),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound.InnerSingleton);
}
void FRigVMFunction_MathFloatRound::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatRound::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result,
		Int
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatRound ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToInt *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatToInt); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatToInt); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the float cast to an int (this uses floor)\n */" },
		{ "DisplayName", "To Int" },
		{ "ExecuteContext", "FRigVMExecuteContext" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Cast" },
		{ "ToolTip", "Returns the float cast to an int (this uses floor)" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToInt constinit property declarations *****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FIntPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatToInt constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("int32"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatToInt::Execute"), 
			.Function = &FRigVMFunction_MathFloatToInt::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatToInt>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatToInt>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatToInt cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt;
class UScriptStruct* FRigVMFunction_MathFloatToInt::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatToInt"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToInt Property Definitions ****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatToInt, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FIntPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatToInt, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatToInt Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatToInt",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatToInt),
	alignof(FRigVMFunction_MathFloatToInt),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt.InnerSingleton);
}
void FRigVMFunction_MathFloatToInt::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatToInt::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatToInt ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToDouble **********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatToDouble); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatToDouble); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the float cast to a double\n */" },
		{ "DisplayName", "To Double" },
		{ "ExecuteContext", "FRigVMExecuteContext" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Cast" },
		{ "ToolTip", "Returns the float cast to a double" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToDouble constinit property declarations **
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatToDouble constinit property declarations ****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatToDouble::Execute"), 
			.Function = &FRigVMFunction_MathFloatToDouble::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatToDouble>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatToDouble>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatToDouble cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble;
class UScriptStruct* FRigVMFunction_MathFloatToDouble::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatToDouble"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatToDouble Property Definitions *************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatToDouble, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatToDouble, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatToDouble Property Definitions ***************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatToDouble",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatToDouble),
	alignof(FRigVMFunction_MathFloatToDouble),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble.InnerSingleton);
}
void FRigVMFunction_MathFloatToDouble::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatToDouble::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatToDouble ************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSign **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatSign); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatSign); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the sign of the value (+1 for >= 0.f, -1 for < 0.f)\n */" },
		{ "DisplayName", "Sign" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Sign" },
		{ "ToolTip", "Returns the sign of the value (+1 for >= 0.f, -1 for < 0.f)" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSign constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatSign constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatSign::Execute"), 
			.Function = &FRigVMFunction_MathFloatSign::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatSign>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatSign>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatSign cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign;
class UScriptStruct* FRigVMFunction_MathFloatSign::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatSign"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatSign",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatSign),
	alignof(FRigVMFunction_MathFloatSign),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign.InnerSingleton);
}
void FRigVMFunction_MathFloatSign::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatSign::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatSign ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatClamp *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatClamp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatClamp); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Clamps the given value within the range provided by minimum and maximum\n */" },
		{ "DisplayName", "Clamp" },
		{ "Keywords", "Range,Remap" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Clamp" },
		{ "ToolTip", "Clamps the given value within the range provided by minimum and maximum" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Minimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Maximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatClamp constinit property declarations *****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Minimum;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Maximum;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatClamp constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Minimum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Maximum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatClamp::Execute"), 
			.Function = &FRigVMFunction_MathFloatClamp::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatClamp>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatClamp>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatClamp cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp;
class UScriptStruct* FRigVMFunction_MathFloatClamp::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatClamp"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatClamp Property Definitions ****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatClamp, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Minimum = { "Minimum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatClamp, Minimum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Minimum_MetaData), NewProp_Minimum_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Maximum = { "Maximum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatClamp, Maximum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Maximum_MetaData), NewProp_Maximum_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatClamp, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Minimum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Maximum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatClamp Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatClamp",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatClamp),
	alignof(FRigVMFunction_MathFloatClamp),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp.InnerSingleton);
}
void FRigVMFunction_MathFloatClamp::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatClamp::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Minimum,
		Maximum,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatClamp ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLerp **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatLerp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatLerp); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Linearly interpolates between A and B using the ratio T\n */" },
		{ "DisplayName", "Interpolate" },
		{ "Keywords", "Lerp,Mix,Blend" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Interpolate" },
		{ "ToolTip", "Linearly interpolates between A and B using the ratio T" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_T_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLerp constinit property declarations ******
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_T;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatLerp constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("T"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatLerp::Execute"), 
			.Function = &FRigVMFunction_MathFloatLerp::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatLerp>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatLerp>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatLerp cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp;
class UScriptStruct* FRigVMFunction_MathFloatLerp::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatLerp"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLerp Property Definitions *****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLerp, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLerp, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_T = { "T", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLerp, T), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_T_MetaData), NewProp_T_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLerp, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_T,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatLerp Property Definitions *******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatLerp",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatLerp),
	alignof(FRigVMFunction_MathFloatLerp),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp.InnerSingleton);
}
void FRigVMFunction_MathFloatLerp::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatLerp::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		T,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatLerp ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRemap *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatRemap); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatRemap); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Remaps the given value from a source range to a target range.\n */" },
		{ "DisplayName", "Remap" },
		{ "Keywords", "Rescale,Scale" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Remap" },
		{ "ToolTip", "Remaps the given value from a source range to a target range." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SourceMinimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SourceMaximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetMinimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetMaximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bClamp_MetaData[] = {
		{ "Category", "Pins" },
		{ "Comment", "/** If set to true the result is clamped to the target range */" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "ToolTip", "If set to true the result is clamped to the target range" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRemap constinit property declarations *****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SourceMinimum;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_SourceMaximum;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetMinimum;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_TargetMaximum;
	static void NewProp_bClamp_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bClamp;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatRemap constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("SourceMinimum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("SourceMaximum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("TargetMinimum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("TargetMaximum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("bClamp"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatRemap::Execute"), 
			.Function = &FRigVMFunction_MathFloatRemap::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatRemap>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatRemap>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatRemap cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap;
class UScriptStruct* FRigVMFunction_MathFloatRemap::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatRemap"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRemap Property Definitions ****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_SourceMinimum = { "SourceMinimum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, SourceMinimum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SourceMinimum_MetaData), NewProp_SourceMinimum_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_SourceMaximum = { "SourceMaximum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, SourceMaximum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SourceMaximum_MetaData), NewProp_SourceMaximum_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_TargetMinimum = { "TargetMinimum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, TargetMinimum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetMinimum_MetaData), NewProp_TargetMinimum_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_TargetMaximum = { "TargetMaximum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, TargetMaximum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetMaximum_MetaData), NewProp_TargetMaximum_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_bClamp_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatRemap*)Obj)->bClamp = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_bClamp = { "bClamp", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatRemap), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_bClamp_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bClamp_MetaData), NewProp_bClamp_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatRemap, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_SourceMinimum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_SourceMaximum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_TargetMinimum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_TargetMaximum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_bClamp,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatRemap Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatRemap",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatRemap),
	alignof(FRigVMFunction_MathFloatRemap),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap.InnerSingleton);
}
void FRigVMFunction_MathFloatRemap::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatRemap::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		SourceMinimum,
		SourceMaximum,
		TargetMinimum,
		TargetMaximum,
		bClamp,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatRemap ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatEquals ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatEquals); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatEquals); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A equals B\n */" },
		{ "Deprecated", "5.1" },
		{ "DisplayName", "Equals" },
		{ "Keywords", "Same,==" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Equals" },
		{ "ToolTip", "Returns true if the value A equals B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatEquals constinit property declarations ****
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatEquals constinit property declarations ******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatEquals::Execute"), 
			.Function = &FRigVMFunction_MathFloatEquals::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatEquals>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatEquals>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatEquals cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals;
class UScriptStruct* FRigVMFunction_MathFloatEquals::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatEquals"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatEquals Property Definitions ***************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatEquals, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatEquals, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatEquals*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatEquals), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatEquals Property Definitions *****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatEquals",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatEquals),
	alignof(FRigVMFunction_MathFloatEquals),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals.InnerSingleton);
}
void FRigVMFunction_MathFloatEquals::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatEquals::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatEquals **************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatNotEquals *********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatNotEquals); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatNotEquals); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A does not equal B\n */" },
		{ "Deprecated", "5.1" },
		{ "DisplayName", "Not Equals" },
		{ "Keywords", "Different,!=" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "NotEquals" },
		{ "ToolTip", "Returns true if the value A does not equal B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatNotEquals constinit property declarations *
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatNotEquals constinit property declarations ***
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatNotEquals::Execute"), 
			.Function = &FRigVMFunction_MathFloatNotEquals::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatNotEquals>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatNotEquals>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatNotEquals cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals;
class UScriptStruct* FRigVMFunction_MathFloatNotEquals::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatNotEquals"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatNotEquals Property Definitions ************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatNotEquals, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatNotEquals, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatNotEquals*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatNotEquals), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatNotEquals Property Definitions **************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatNotEquals",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatNotEquals),
	alignof(FRigVMFunction_MathFloatNotEquals),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals.InnerSingleton);
}
void FRigVMFunction_MathFloatNotEquals::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatNotEquals::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatNotEquals ***********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreater ***********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatGreater); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatGreater); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A is greater than B\n */" },
		{ "DisplayName", "Greater" },
		{ "Keywords", "Larger,Bigger,>" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Greater" },
		{ "ToolTip", "Returns true if the value A is greater than B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreater constinit property declarations ***
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatGreater constinit property declarations *****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatGreater::Execute"), 
			.Function = &FRigVMFunction_MathFloatGreater::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatGreater>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatGreater>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatGreater cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater;
class UScriptStruct* FRigVMFunction_MathFloatGreater::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatGreater"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreater Property Definitions **************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatGreater, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatGreater, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatGreater*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatGreater), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatGreater Property Definitions ****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatGreater",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatGreater),
	alignof(FRigVMFunction_MathFloatGreater),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater.InnerSingleton);
}
void FRigVMFunction_MathFloatGreater::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatGreater::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatGreater *************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLess **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatLess); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatLess); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A is less than B\n */" },
		{ "DisplayName", "Less" },
		{ "Keywords", "Smaller,<" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Less" },
		{ "ToolTip", "Returns true if the value A is less than B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLess constinit property declarations ******
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatLess constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatLess::Execute"), 
			.Function = &FRigVMFunction_MathFloatLess::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatLess>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatLess>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatLess cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess;
class UScriptStruct* FRigVMFunction_MathFloatLess::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatLess"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLess Property Definitions *****************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLess, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLess, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatLess*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatLess), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatLess Property Definitions *******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatLess",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatLess),
	alignof(FRigVMFunction_MathFloatLess),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess.InnerSingleton);
}
void FRigVMFunction_MathFloatLess::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatLess::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatLess ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreaterEqual ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatGreaterEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatGreaterEqual); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A is greater than or equal to B\n */" },
		{ "DisplayName", "Greater Equal" },
		{ "Keywords", "Larger,Bigger,>=" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "GreaterEqual" },
		{ "ToolTip", "Returns true if the value A is greater than or equal to B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreaterEqual constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatGreaterEqual constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatGreaterEqual::Execute"), 
			.Function = &FRigVMFunction_MathFloatGreaterEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatGreaterEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatGreaterEqual>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatGreaterEqual cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual;
class UScriptStruct* FRigVMFunction_MathFloatGreaterEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatGreaterEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatGreaterEqual Property Definitions *********
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatGreaterEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatGreaterEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatGreaterEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatGreaterEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatGreaterEqual Property Definitions ***********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatGreaterEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatGreaterEqual),
	alignof(FRigVMFunction_MathFloatGreaterEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual.InnerSingleton);
}
void FRigVMFunction_MathFloatGreaterEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatGreaterEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatGreaterEqual ********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLessEqual *********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatLessEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatLessEqual); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A is less than or equal to B\n */" },
		{ "DisplayName", "Less Equal" },
		{ "Keywords", "Smaller,<=" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "LessEqual" },
		{ "ToolTip", "Returns true if the value A is less than or equal to B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLessEqual constinit property declarations *
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatLessEqual constinit property declarations ***
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatLessEqual::Execute"), 
			.Function = &FRigVMFunction_MathFloatLessEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatLessEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatLessEqual>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatLessEqual cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual;
class UScriptStruct* FRigVMFunction_MathFloatLessEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatLessEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLessEqual Property Definitions ************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLessEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLessEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatLessEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatLessEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatLessEqual Property Definitions **************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatLessEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatLessEqual),
	alignof(FRigVMFunction_MathFloatLessEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual.InnerSingleton);
}
void FRigVMFunction_MathFloatLessEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatLessEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatLessEqual ***********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyZero ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatIsNearlyZero); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatIsNearlyZero); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value is nearly zero\n */" },
		{ "DisplayName", "Is Nearly Zero" },
		{ "Keywords", "AlmostZero,0" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "IsNearlyZero" },
		{ "ToolTip", "Returns true if the value is nearly zero" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Value_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Tolerance_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyZero constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Value;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Tolerance;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyZero constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Tolerance"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatIsNearlyZero::Execute"), 
			.Function = &FRigVMFunction_MathFloatIsNearlyZero::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatIsNearlyZero>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatIsNearlyZero>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatIsNearlyZero cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero;
class UScriptStruct* FRigVMFunction_MathFloatIsNearlyZero::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatIsNearlyZero"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyZero Property Definitions *********
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatIsNearlyZero, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Tolerance = { "Tolerance", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatIsNearlyZero, Tolerance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Tolerance_MetaData), NewProp_Tolerance_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatIsNearlyZero*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatIsNearlyZero), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Tolerance,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyZero Property Definitions ***********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatIsNearlyZero",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatIsNearlyZero),
	alignof(FRigVMFunction_MathFloatIsNearlyZero),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero.InnerSingleton);
}
void FRigVMFunction_MathFloatIsNearlyZero::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatIsNearlyZero::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Tolerance,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyZero ********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual *****************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatIsNearlyEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatIsNearlyEqual); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns true if the value A is almost equal to B\n */" },
		{ "DisplayName", "Is Nearly Equal" },
		{ "Keywords", "AlmostEqual,==" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "IsNearlyEqual" },
		{ "ToolTip", "Returns true if the value A is almost equal to B" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Tolerance_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Tolerance;
	static void NewProp_Result_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Tolerance"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatIsNearlyEqual::Execute"), 
			.Function = &FRigVMFunction_MathFloatIsNearlyEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatIsNearlyEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatIsNearlyEqual>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatIsNearlyEqual cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual;
class UScriptStruct* FRigVMFunction_MathFloatIsNearlyEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatIsNearlyEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual Property Definitions ********
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatIsNearlyEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatIsNearlyEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Tolerance = { "Tolerance", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatIsNearlyEqual, Tolerance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Tolerance_MetaData), NewProp_Tolerance_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatIsNearlyEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatIsNearlyEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Tolerance,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual Property Definitions **********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatIsNearlyEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatIsNearlyEqual),
	alignof(FRigVMFunction_MathFloatIsNearlyEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual.InnerSingleton);
}
void FRigVMFunction_MathFloatIsNearlyEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatIsNearlyEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Tolerance,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatIsNearlyEqual *******************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSelectBool ********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatSelectBool); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatSelectBool); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Return one of the two values based on the condition\n */" },
		{ "Deprecated", "4.26.0" },
		{ "DisplayName", "Select" },
		{ "Keywords", "Pick,If" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "ToolTip", "Return one of the two values based on the condition" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Condition_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_IfTrue_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_IfFalse_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSelectBool constinit property declarations 
	static void NewProp_Condition_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_Condition;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_IfTrue;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_IfFalse;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Result;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatSelectBool constinit property declarations **
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Condition"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("IfTrue"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("IfFalse"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatSelectBool::Execute"), 
			.Function = &FRigVMFunction_MathFloatSelectBool::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatSelectBool>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatSelectBool>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatSelectBool cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool;
class UScriptStruct* FRigVMFunction_MathFloatSelectBool::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatSelectBool"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSelectBool Property Definitions ***********
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Condition_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatSelectBool*)Obj)->Condition = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Condition = { "Condition", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatSelectBool), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Condition_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Condition_MetaData), NewProp_Condition_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_IfTrue = { "IfTrue", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatSelectBool, IfTrue), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_IfTrue_MetaData), NewProp_IfTrue_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_IfFalse = { "IfFalse", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatSelectBool, IfFalse), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_IfFalse_MetaData), NewProp_IfFalse_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatSelectBool, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Condition,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_IfTrue,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_IfFalse,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatSelectBool Property Definitions *************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatSelectBool",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatSelectBool),
	alignof(FRigVMFunction_MathFloatSelectBool),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool.InnerSingleton);
}
void FRigVMFunction_MathFloatSelectBool::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatSelectBool::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Condition,
		IfTrue,
		IfFalse,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatSelectBool **********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatDeg ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatDeg); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatDeg); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the degrees of a given value in radians\n */" },
		{ "DisplayName", "Degrees" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Degrees" },
		{ "ToolTip", "Returns the degrees of a given value in radians" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatDeg constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatDeg constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatDeg::Execute"), 
			.Function = &FRigVMFunction_MathFloatDeg::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatDeg>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatDeg>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatDeg cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg;
class UScriptStruct* FRigVMFunction_MathFloatDeg::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatDeg"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatDeg",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatDeg),
	alignof(FRigVMFunction_MathFloatDeg),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg.InnerSingleton);
}
void FRigVMFunction_MathFloatDeg::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatDeg::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatDeg *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRad ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatRad); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatRad); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the radians of a given value in degrees\n */" },
		{ "DisplayName", "Radians" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Radians" },
		{ "ToolTip", "Returns the radians of a given value in degrees" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatRad constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatRad constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatRad::Execute"), 
			.Function = &FRigVMFunction_MathFloatRad::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatRad>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatRad>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatRad cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad;
class UScriptStruct* FRigVMFunction_MathFloatRad::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatRad"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatRad",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatRad),
	alignof(FRigVMFunction_MathFloatRad),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad.InnerSingleton);
}
void FRigVMFunction_MathFloatRad::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatRad::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatRad *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSin ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatSin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatSin); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the sinus value of the given value (in radians)\n */" },
		{ "DisplayName", "Sin" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Sin" },
		{ "ToolTip", "Returns the sinus value of the given value (in radians)" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatSin constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatSin constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatSin::Execute"), 
			.Function = &FRigVMFunction_MathFloatSin::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatSin>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatSin>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatSin cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin;
class UScriptStruct* FRigVMFunction_MathFloatSin::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatSin"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatSin",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatSin),
	alignof(FRigVMFunction_MathFloatSin),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin.InnerSingleton);
}
void FRigVMFunction_MathFloatSin::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatSin::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatSin *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatCos ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatCos); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatCos); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the cosinus value of the given value (in radians)\n */" },
		{ "DisplayName", "Cos" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Cos" },
		{ "ToolTip", "Returns the cosinus value of the given value (in radians)" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatCos constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatCos constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatCos::Execute"), 
			.Function = &FRigVMFunction_MathFloatCos::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatCos>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatCos>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatCos cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos;
class UScriptStruct* FRigVMFunction_MathFloatCos::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatCos"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatCos",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatCos),
	alignof(FRigVMFunction_MathFloatCos),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos.InnerSingleton);
}
void FRigVMFunction_MathFloatCos::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatCos::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatCos *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatTan ***************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatTan); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatTan); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the tangens value of the given value (in radians)\n */" },
		{ "DisplayName", "Tan" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Tan" },
		{ "ToolTip", "Returns the tangens value of the given value (in radians)" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatTan constinit property declarations *******
// ********** End ScriptStruct FRigVMFunction_MathFloatTan constinit property declarations *********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatTan::Execute"), 
			.Function = &FRigVMFunction_MathFloatTan::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatTan>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatTan>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatTan cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan;
class UScriptStruct* FRigVMFunction_MathFloatTan::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatTan"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatTan",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatTan),
	alignof(FRigVMFunction_MathFloatTan),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan.InnerSingleton);
}
void FRigVMFunction_MathFloatTan::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatTan::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatTan *****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAsin **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAsin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAsin); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the inverse sinus value (in radians) of the given value\n */" },
		{ "DisplayName", "Asin" },
		{ "Keywords", "Arcsin" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Asin" },
		{ "ToolTip", "Returns the inverse sinus value (in radians) of the given value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAsin constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatAsin constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAsin::Execute"), 
			.Function = &FRigVMFunction_MathFloatAsin::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAsin>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAsin>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatAsin cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin;
class UScriptStruct* FRigVMFunction_MathFloatAsin::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAsin"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAsin",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAsin),
	alignof(FRigVMFunction_MathFloatAsin),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin.InnerSingleton);
}
void FRigVMFunction_MathFloatAsin::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAsin::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAsin ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAcos **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAcos); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAcos); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the inverse cosinus value (in radians) of the given value\n */" },
		{ "DisplayName", "Acos" },
		{ "Keywords", "Arccos" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Acos" },
		{ "ToolTip", "Returns the inverse cosinus value (in radians) of the given value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAcos constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatAcos constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAcos::Execute"), 
			.Function = &FRigVMFunction_MathFloatAcos::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAcos>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAcos>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatAcos cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos;
class UScriptStruct* FRigVMFunction_MathFloatAcos::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAcos"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAcos",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAcos),
	alignof(FRigVMFunction_MathFloatAcos),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos.InnerSingleton);
}
void FRigVMFunction_MathFloatAcos::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAcos::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAcos ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAtan **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAtan); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAtan); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the inverse tangens value (in radians) of the given value\n */" },
		{ "DisplayName", "Atan" },
		{ "Keywords", "Arctan" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Atan" },
		{ "ToolTip", "Returns the inverse tangens value (in radians) of the given value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAtan constinit property declarations ******
// ********** End ScriptStruct FRigVMFunction_MathFloatAtan constinit property declarations ********
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAtan::Execute"), 
			.Function = &FRigVMFunction_MathFloatAtan::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAtan>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAtan>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatAtan cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan;
class UScriptStruct* FRigVMFunction_MathFloatAtan::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAtan"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAtan",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAtan),
	alignof(FRigVMFunction_MathFloatAtan),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan.InnerSingleton);
}
void FRigVMFunction_MathFloatAtan::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAtan::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAtan ****************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAtan2 *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatAtan2); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatAtan2); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Returns the arctangent of the specified A and B coordinates.\n */" },
		{ "DisplayName", "Atan2" },
		{ "Keywords", "Arctan" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Atan2" },
		{ "ToolTip", "Returns the arctangent of the specified A and B coordinates." },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatAtan2 constinit property declarations *****
// ********** End ScriptStruct FRigVMFunction_MathFloatAtan2 constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatAtan2::Execute"), 
			.Function = &FRigVMFunction_MathFloatAtan2::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatAtan2>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatAtan2>() == std::is_polymorphic<FRigVMFunction_MathFloatBinaryOp>(), "USTRUCT FRigVMFunction_MathFloatAtan2 cannot be polymorphic unless super FRigVMFunction_MathFloatBinaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2;
class UScriptStruct* FRigVMFunction_MathFloatAtan2::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatAtan2"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatAtan2",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatAtan2),
	alignof(FRigVMFunction_MathFloatAtan2),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2.InnerSingleton);
}
void FRigVMFunction_MathFloatAtan2::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatAtan2::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatAtan2 ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLawOfCosine *******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatLawOfCosine); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatLawOfCosine); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Computes the angles alpha, beta and gamma (in radians) between the three sides A, B and C\n */" },
		{ "DisplayName", "Law Of Cosine" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "LawOfCosine" },
		{ "ToolTip", "Computes the angles alpha, beta and gamma (in radians) between the three sides A, B and C" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_A_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_C_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_AlphaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BetaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_GammaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bValid_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLawOfCosine constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_A;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_B;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_C;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_AlphaAngle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_BetaAngle;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_GammaAngle;
	static void NewProp_bValid_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bValid;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatLawOfCosine constinit property declarations *
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("C"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("AlphaAngle"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("BetaAngle"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("GammaAngle"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("bValid"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatLawOfCosine::Execute"), 
			.Function = &FRigVMFunction_MathFloatLawOfCosine::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatLawOfCosine>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatLawOfCosine>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatLawOfCosine cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine;
class UScriptStruct* FRigVMFunction_MathFloatLawOfCosine::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatLawOfCosine"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatLawOfCosine Property Definitions **********
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_C = { "C", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, C), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_C_MetaData), NewProp_C_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_AlphaAngle = { "AlphaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, AlphaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_AlphaAngle_MetaData), NewProp_AlphaAngle_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_BetaAngle = { "BetaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, BetaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BetaAngle_MetaData), NewProp_BetaAngle_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_GammaAngle = { "GammaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatLawOfCosine, GammaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_GammaAngle_MetaData), NewProp_GammaAngle_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_bValid_SetBit(void* Obj)
{
	((FRigVMFunction_MathFloatLawOfCosine*)Obj)->bValid = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_bValid = { "bValid", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(FRigVMFunction_MathFloatLawOfCosine), &Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_bValid_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bValid_MetaData), NewProp_bValid_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_C,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_AlphaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_BetaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_GammaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewProp_bValid,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatLawOfCosine Property Definitions ************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatLawOfCosine",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatLawOfCosine),
	alignof(FRigVMFunction_MathFloatLawOfCosine),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine.InnerSingleton);
}
void FRigVMFunction_MathFloatLawOfCosine::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatLawOfCosine::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		C,
		AlphaAngle,
		BetaAngle,
		GammaAngle,
		bValid
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatLawOfCosine *********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatExponential *******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatExponential); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatExponential); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "Comment", "/**\n * Computes the base-e exponential of the given value \n */" },
		{ "DisplayName", "Exponential" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "Exponential" },
		{ "ToolTip", "Computes the base-e exponential of the given value" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatExponential constinit property declarations 
// ********** End ScriptStruct FRigVMFunction_MathFloatExponential constinit property declarations *
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatExponential::Execute"), 
			.Function = &FRigVMFunction_MathFloatExponential::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatExponential>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatExponential>() == std::is_polymorphic<FRigVMFunction_MathFloatUnaryOp>(), "USTRUCT FRigVMFunction_MathFloatExponential cannot be polymorphic unless super FRigVMFunction_MathFloatUnaryOp is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential;
class UScriptStruct* FRigVMFunction_MathFloatExponential::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatExponential"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.OuterSingleton;
	}
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp,
	&NewStructOps,
	"RigVMFunction_MathFloatExponential",
	nullptr,
	0,
	sizeof(FRigVMFunction_MathFloatExponential),
	alignof(FRigVMFunction_MathFloatExponential),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential.InnerSingleton);
}
void FRigVMFunction_MathFloatExponential::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatExponential::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatExponential *********************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArraySum **********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatArraySum); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatArraySum); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the sum of the given array\n */" },
		{ "DisplayName", "Array Sum" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "ArraySum" },
		{ "ToolTip", "Returns the sum of the given array" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Array_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Sum_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArraySum constinit property declarations **
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Array_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_Array;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Sum;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatArraySum constinit property declarations ****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Array"), .Type = TEXT("TArray<float>"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Sum"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatArraySum::Execute"), 
			.Function = &FRigVMFunction_MathFloatArraySum::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatArraySum>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatArraySum>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatArraySum cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum;
class UScriptStruct* FRigVMFunction_MathFloatArraySum::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatArraySum"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArraySum Property Definitions *************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Array_Inner = { "Array", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Array = { "Array", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatArraySum, Array), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Array_MetaData), NewProp_Array_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Sum = { "Sum", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatArraySum, Sum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Sum_MetaData), NewProp_Sum_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Array_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Array,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewProp_Sum,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatArraySum Property Definitions ***************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatArraySum",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatArraySum),
	alignof(FRigVMFunction_MathFloatArraySum),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum.InnerSingleton);
}
void FRigVMFunction_MathFloatArraySum::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatArraySum::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	TArrayView<const float> Array_0_Array(Array);
	StaticExecute(
		InExecuteContext,
		Array_0_Array,
		Sum
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatArraySum ************************************

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArrayAverage ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathFloatArrayAverage); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathFloatArrayAverage); }
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Returns the average of the given array\n */" },
		{ "DisplayName", "Array Average" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "TemplateName", "ArrayAverage" },
		{ "ToolTip", "Returns the average of the given array" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Array_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Average_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathFloat.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArrayAverage constinit property declarations 
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Array_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_Array;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Average;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End ScriptStruct FRigVMFunction_MathFloatArrayAverage constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Array"), .Type = TEXT("TArray<float>"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Average"), .Type = TEXT("float"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathFloatArrayAverage::Execute"), 
			.Function = &FRigVMFunction_MathFloatArrayAverage::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathFloatArrayAverage>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathFloatArrayAverage>() == std::is_polymorphic<FRigVMFunction_MathFloatBase>(), "USTRUCT FRigVMFunction_MathFloatArrayAverage cannot be polymorphic unless super FRigVMFunction_MathFloatBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage;
class UScriptStruct* FRigVMFunction_MathFloatArrayAverage::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathFloatArrayAverage"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathFloatArrayAverage Property Definitions *********
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Array_Inner = { "Array", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Array = { "Array", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatArrayAverage, Array), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Array_MetaData), NewProp_Array_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Average = { "Average", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathFloatArrayAverage, Average), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Average_MetaData), NewProp_Average_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Array_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Array,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewProp_Average,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathFloatArrayAverage Property Definitions ***********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase,
	&NewStructOps,
	"RigVMFunction_MathFloatArrayAverage",
	Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::PropPointers),
	sizeof(FRigVMFunction_MathFloatArrayAverage),
	alignof(FRigVMFunction_MathFloatArrayAverage),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage.InnerSingleton);
}
void FRigVMFunction_MathFloatArrayAverage::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathFloatArrayAverage::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	TArrayView<const float> Array_0_Array(Array);
	StaticExecute(
		InExecuteContext,
		Array_0_Array,
		Average
	);
}
// ********** End ScriptStruct FRigVMFunction_MathFloatArrayAverage ********************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathFloat_h__Script_RigVM_Statics
{
	static constexpr FStructRegisterCompiledInInfo ScriptStructInfo[] = {
		{ FRigVMFunction_MathFloatBase::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBase_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatBase"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBase, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatBase), 200711179U) },
		{ FRigVMFunction_MathFloatConstant::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstant_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatConstant"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstant, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatConstant), 913109712U) },
		{ FRigVMFunction_MathFloatUnaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatUnaryOp_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatUnaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatUnaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatUnaryOp), 4053025812U) },
		{ FRigVMFunction_MathFloatBinaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryOp_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatBinaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatBinaryOp), 1410412510U) },
		{ FRigVMFunction_MathFloatBinaryAggregateOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatBinaryAggregateOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatBinaryAggregateOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatBinaryAggregateOp), 2128738887U) },
		{ FRigVMFunction_MathFloatMake::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMake_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatMake"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMake, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatMake), 368671053U) },
		{ FRigVMFunction_MathFloatConstPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstPi_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatConstPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatConstPi), 794880729U) },
		{ FRigVMFunction_MathFloatConstHalfPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatConstHalfPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstHalfPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatConstHalfPi), 384218721U) },
		{ FRigVMFunction_MathFloatConstTwoPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatConstTwoPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstTwoPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatConstTwoPi), 3312356564U) },
		{ FRigVMFunction_MathFloatConstE::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatConstE_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatConstE"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatConstE, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatConstE), 3563721926U) },
		{ FRigVMFunction_MathFloatAdd::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAdd_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAdd"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAdd, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAdd), 2835591388U) },
		{ FRigVMFunction_MathFloatSub::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSub_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatSub"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSub, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatSub), 1011966716U) },
		{ FRigVMFunction_MathFloatMul::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMul_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatMul"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMul, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatMul), 1251989947U) },
		{ FRigVMFunction_MathFloatDiv::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDiv_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatDiv"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDiv, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatDiv), 3749147757U) },
		{ FRigVMFunction_MathFloatMod::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMod_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatMod"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMod, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatMod), 2800004156U) },
		{ FRigVMFunction_MathFloatMin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMin_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatMin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatMin), 917569514U) },
		{ FRigVMFunction_MathFloatMax::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatMax_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatMax"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatMax, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatMax), 100361938U) },
		{ FRigVMFunction_MathFloatPow::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatPow_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatPow"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatPow, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatPow), 2533997907U) },
		{ FRigVMFunction_MathFloatSqrt::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSqrt_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatSqrt"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSqrt, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatSqrt), 3520502040U) },
		{ FRigVMFunction_MathFloatNegate::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNegate_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatNegate"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNegate, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatNegate), 3264378744U) },
		{ FRigVMFunction_MathFloatAbs::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAbs_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAbs"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAbs, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAbs), 4281216829U) },
		{ FRigVMFunction_MathFloatFloor::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatFloor_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatFloor"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatFloor, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatFloor), 2719410206U) },
		{ FRigVMFunction_MathFloatCeil::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCeil_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatCeil"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCeil, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatCeil), 2135765555U) },
		{ FRigVMFunction_MathFloatRound::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRound_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatRound"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRound, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatRound), 1665191734U) },
		{ FRigVMFunction_MathFloatToInt::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToInt_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatToInt"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToInt, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatToInt), 994822459U) },
		{ FRigVMFunction_MathFloatToDouble::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatToDouble_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatToDouble"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatToDouble, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatToDouble), 2156102730U) },
		{ FRigVMFunction_MathFloatSign::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSign_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatSign"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSign, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatSign), 3447379864U) },
		{ FRigVMFunction_MathFloatClamp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatClamp_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatClamp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatClamp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatClamp), 3607892401U) },
		{ FRigVMFunction_MathFloatLerp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLerp_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatLerp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLerp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatLerp), 1509324880U) },
		{ FRigVMFunction_MathFloatRemap::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRemap_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatRemap"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRemap, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatRemap), 1167630519U) },
		{ FRigVMFunction_MathFloatEquals::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatEquals_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatEquals"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatEquals, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatEquals), 455162282U) },
		{ FRigVMFunction_MathFloatNotEquals::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatNotEquals_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatNotEquals"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatNotEquals, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatNotEquals), 722916208U) },
		{ FRigVMFunction_MathFloatGreater::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreater_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatGreater"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreater, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatGreater), 1376061991U) },
		{ FRigVMFunction_MathFloatLess::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLess_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatLess"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLess, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatLess), 3404257732U) },
		{ FRigVMFunction_MathFloatGreaterEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatGreaterEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatGreaterEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatGreaterEqual), 471437615U) },
		{ FRigVMFunction_MathFloatLessEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLessEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatLessEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLessEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatLessEqual), 3278974829U) },
		{ FRigVMFunction_MathFloatIsNearlyZero::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatIsNearlyZero"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyZero, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatIsNearlyZero), 4010526618U) },
		{ FRigVMFunction_MathFloatIsNearlyEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatIsNearlyEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatIsNearlyEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatIsNearlyEqual), 1852027899U) },
		{ FRigVMFunction_MathFloatSelectBool::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSelectBool_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatSelectBool"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSelectBool, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatSelectBool), 2730370229U) },
		{ FRigVMFunction_MathFloatDeg::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatDeg_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatDeg"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatDeg, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatDeg), 3585452795U) },
		{ FRigVMFunction_MathFloatRad::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatRad_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatRad"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatRad, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatRad), 2674447470U) },
		{ FRigVMFunction_MathFloatSin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatSin_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatSin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatSin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatSin), 1669745568U) },
		{ FRigVMFunction_MathFloatCos::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatCos_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatCos"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatCos, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatCos), 507661875U) },
		{ FRigVMFunction_MathFloatTan::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatTan_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatTan"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatTan, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatTan), 1230378457U) },
		{ FRigVMFunction_MathFloatAsin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAsin_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAsin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAsin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAsin), 2569633549U) },
		{ FRigVMFunction_MathFloatAcos::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAcos_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAcos"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAcos, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAcos), 1690479037U) },
		{ FRigVMFunction_MathFloatAtan::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAtan"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAtan), 1036017757U) },
		{ FRigVMFunction_MathFloatAtan2::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatAtan2_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatAtan2"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatAtan2, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatAtan2), 897332638U) },
		{ FRigVMFunction_MathFloatLawOfCosine::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatLawOfCosine"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatLawOfCosine, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatLawOfCosine), 1795592661U) },
		{ FRigVMFunction_MathFloatExponential::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatExponential_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatExponential"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatExponential, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatExponential), 1501380839U) },
		{ FRigVMFunction_MathFloatArraySum::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArraySum_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatArraySum"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArraySum, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatArraySum), 2604423120U) },
		{ FRigVMFunction_MathFloatArrayAverage::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathFloatArrayAverage_Statics::NewStructOps, TEXT("RigVMFunction_MathFloatArrayAverage"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathFloatArrayAverage, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathFloatArrayAverage), 301087550U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathFloat_h__Script_RigVM_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathFloat_h__Script_RigVM_4069444168{
	TEXT("/Script/RigVM"),
	nullptr, 0,
	Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathFloat_h__Script_RigVM_Statics::ScriptStructInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathFloat_h__Script_RigVM_Statics::ScriptStructInfo),
	nullptr, 0,
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS