DedicatedServerCourse/Intermediate/Build/Win64/FPSTemplateServer/Inc/RigVM/UHT/RigVMFunction_MathDouble.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_MathDouble.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_MathDouble() {}

// ********** Begin Cross Module References ********************************************************
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathBase();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAbs();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAcos();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAdd();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArrayAverage();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArraySum();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAsin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan2();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBinaryAggregateOp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBinaryOp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCeil();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleClamp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstE();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstHalfPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstTwoPi();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCos();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDeg();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDiv();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleExponential();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleFloor();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLerp();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMake();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMax();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMod();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMul();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNegate();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoublePow();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRad();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRound();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSign();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSin();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSqrt();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSub();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleTan();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleToFloat();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleToInt();
RIGVM_API UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleUnaryOp();
UPackage* Z_Construct_UPackage__Script_RigVM();
// ********** End Cross Module References **********************************************************

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

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

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleConstant Property Definitions ************
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleConstant, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::NewProp_Value,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleConstant Property Definitions **************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleConstant",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleConstant),
	alignof(FRigVMFunction_MathDoubleConstant),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstant.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstant.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstant.InnerSingleton);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleConstant ***********************************

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleConstHalfPi ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstHalfPi_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleConstHalfPi); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleConstHalfPi); }
#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_MathDouble.h" },
		{ "TemplateName", "HalfPi" },
		{ "ToolTip", "Returns PI * 0.5" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleConstTwoPi *******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstTwoPi_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleConstTwoPi); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleConstTwoPi); }
#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_MathDouble.h" },
		{ "TemplateName", "TwoPi" },
		{ "ToolTip", "Returns PI * 2.0" },
	};
#endif // WITH_METADATA

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

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAdd **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAdd_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAdd); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAdd); }
#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_MathDouble.h" },
		{ "TemplateName", "Add" },
		{ "ToolTip", "Returns the sum of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleSub **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSub_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleSub); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleSub); }
#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_MathDouble.h" },
		{ "TemplateName", "Subtract" },
		{ "ToolTip", "Returns the difference of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleMul **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMul_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleMul); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleMul); }
#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_MathDouble.h" },
		{ "TemplateName", "Multiply" },
		{ "ToolTip", "Returns the product of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleDiv **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDiv_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleDiv); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleDiv); }
#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_MathDouble.h" },
		{ "TemplateName", "Divide" },
		{ "ToolTip", "Returns the division of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleMod **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMod_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleMod); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleMod); }
#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_MathDouble.h" },
		{ "TemplateName", "Modulo" },
		{ "ToolTip", "Returns the modulo of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleMin **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleMin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleMin); }
#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_MathDouble.h" },
		{ "TemplateName", "Minimum" },
		{ "ToolTip", "Returns the smaller of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleMax **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMax_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleMax); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleMax); }
#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_MathDouble.h" },
		{ "TemplateName", "Maximum" },
		{ "ToolTip", "Returns the larger of the two values" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoublePow **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoublePow_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoublePow); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoublePow); }
#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_MathDouble.h" },
		{ "TemplateName", "Power" },
		{ "ToolTip", "Returns the value of A raised to the power of B." },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleSqrt *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSqrt_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleSqrt); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleSqrt); }
#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_MathDouble.h" },
		{ "TemplateName", "Sqrt" },
		{ "ToolTip", "Returns the square root of the given value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleNegate ***********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNegate_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleNegate); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleNegate); }
#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_MathDouble.h" },
		{ "TemplateName", "Negate" },
		{ "ToolTip", "Returns the negative value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAbs **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAbs_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAbs); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAbs); }
#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_MathDouble.h" },
		{ "TemplateName", "Absolute" },
		{ "ToolTip", "Returns the absolute (positive) value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleFloor ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleFloor_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleFloor); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleFloor); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleCeil *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCeil_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleCeil); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleCeil); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleRound ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRound_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleRound); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleRound); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Int_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

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

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

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

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

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

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

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleClamp ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleClamp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleClamp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleClamp); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Minimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Maximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLerp *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLerp_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleLerp); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleLerp); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_T_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleRemap ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleRemap); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleRemap); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SourceMinimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SourceMaximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetMinimum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_TargetMaximum_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.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_MathDouble.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_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleRemap Property Definitions ***************
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_SourceMinimum = { "SourceMinimum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, SourceMinimum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SourceMinimum_MetaData), NewProp_SourceMinimum_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_SourceMaximum = { "SourceMaximum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, SourceMaximum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SourceMaximum_MetaData), NewProp_SourceMaximum_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_TargetMinimum = { "TargetMinimum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, TargetMinimum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetMinimum_MetaData), NewProp_TargetMinimum_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_TargetMaximum = { "TargetMaximum", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, TargetMaximum), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_TargetMaximum_MetaData), NewProp_TargetMaximum_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_bClamp_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleRemap*)Obj)->bClamp = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_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_MathDoubleRemap), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_bClamp_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bClamp_MetaData), NewProp_bClamp_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleRemap, Result), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_SourceMinimum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_SourceMaximum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_TargetMinimum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_TargetMaximum,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_bClamp,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleRemap Property Definitions *****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleRemap",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleRemap),
	alignof(FRigVMFunction_MathDoubleRemap),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRemap.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRemap.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRemap.InnerSingleton);
}
void FRigVMFunction_MathDoubleRemap::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleRemap::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		SourceMinimum,
		SourceMaximum,
		TargetMinimum,
		TargetMaximum,
		bClamp,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleRemap **************************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleEquals ***********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleEquals); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleEquals); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleEquals constinit property declarations ***
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleEquals constinit property declarations *****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleEquals::Execute"), 
			.Function = &FRigVMFunction_MathDoubleEquals::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleEquals>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleEquals>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleEquals cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals;
class UScriptStruct* FRigVMFunction_MathDoubleEquals::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleEquals"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleEquals Property Definitions **************
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleEquals, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleEquals, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleEquals*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_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_MathDoubleEquals), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleEquals Property Definitions ****************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleEquals",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleEquals),
	alignof(FRigVMFunction_MathDoubleEquals),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals.InnerSingleton);
}
void FRigVMFunction_MathDoubleEquals::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleEquals::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleEquals *************************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleNotEquals ********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleNotEquals); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleNotEquals); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleNotEquals constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleNotEquals constinit property declarations **
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleNotEquals::Execute"), 
			.Function = &FRigVMFunction_MathDoubleNotEquals::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleNotEquals>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleNotEquals>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleNotEquals cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals;
class UScriptStruct* FRigVMFunction_MathDoubleNotEquals::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleNotEquals"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleNotEquals Property Definitions ***********
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleNotEquals, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleNotEquals, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleNotEquals*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_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_MathDoubleNotEquals), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleNotEquals Property Definitions *************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleNotEquals",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleNotEquals),
	alignof(FRigVMFunction_MathDoubleNotEquals),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals.InnerSingleton);
}
void FRigVMFunction_MathDoubleNotEquals::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleNotEquals::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleNotEquals **********************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreater **********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleGreater); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleGreater); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreater constinit property declarations **
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleGreater constinit property declarations ****
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleGreater::Execute"), 
			.Function = &FRigVMFunction_MathDoubleGreater::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleGreater>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleGreater>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleGreater cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater;
class UScriptStruct* FRigVMFunction_MathDoubleGreater::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleGreater"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreater Property Definitions *************
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleGreater, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleGreater, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleGreater*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_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_MathDoubleGreater), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleGreater Property Definitions ***************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleGreater",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleGreater),
	alignof(FRigVMFunction_MathDoubleGreater),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater.InnerSingleton);
}
void FRigVMFunction_MathDoubleGreater::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleGreater::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleGreater ************************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLess *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleLess); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleLess); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLess constinit property declarations *****
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleLess constinit property declarations *******
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleLess::Execute"), 
			.Function = &FRigVMFunction_MathDoubleLess::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleLess>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleLess>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleLess cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess;
class UScriptStruct* FRigVMFunction_MathDoubleLess::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleLess"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLess Property Definitions ****************
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLess, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLess, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleLess*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_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_MathDoubleLess), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleLess Property Definitions ******************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleLess",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleLess),
	alignof(FRigVMFunction_MathDoubleLess),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess.InnerSingleton);
}
void FRigVMFunction_MathDoubleLess::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleLess::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleLess ***************************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreaterEqual *****************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleGreaterEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleGreaterEqual); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreaterEqual constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleGreaterEqual constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleGreaterEqual::Execute"), 
			.Function = &FRigVMFunction_MathDoubleGreaterEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleGreaterEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleGreaterEqual>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleGreaterEqual cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual;
class UScriptStruct* FRigVMFunction_MathDoubleGreaterEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleGreaterEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleGreaterEqual Property Definitions ********
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleGreaterEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleGreaterEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleGreaterEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_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_MathDoubleGreaterEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleGreaterEqual Property Definitions **********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleGreaterEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleGreaterEqual),
	alignof(FRigVMFunction_MathDoubleGreaterEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual.InnerSingleton);
}
void FRigVMFunction_MathDoubleGreaterEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleGreaterEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleGreaterEqual *******************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLessEqual ********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleLessEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleLessEqual); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLessEqual constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleLessEqual constinit property declarations **
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleLessEqual::Execute"), 
			.Function = &FRigVMFunction_MathDoubleLessEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleLessEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleLessEqual>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleLessEqual cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual;
class UScriptStruct* FRigVMFunction_MathDoubleLessEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleLessEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLessEqual Property Definitions ***********
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLessEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLessEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleLessEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_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_MathDoubleLessEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleLessEqual Property Definitions *************
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleLessEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleLessEqual),
	alignof(FRigVMFunction_MathDoubleLessEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual.InnerSingleton);
}
void FRigVMFunction_MathDoubleLessEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleLessEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleLessEqual **********************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyZero *****************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleIsNearlyZero); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleIsNearlyZero); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Tolerance_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyZero constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_Value;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleIsNearlyZero constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("Value"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Tolerance"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleIsNearlyZero::Execute"), 
			.Function = &FRigVMFunction_MathDoubleIsNearlyZero::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleIsNearlyZero>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleIsNearlyZero>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleIsNearlyZero cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero;
class UScriptStruct* FRigVMFunction_MathDoubleIsNearlyZero::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleIsNearlyZero"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyZero Property Definitions ********
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Value = { "Value", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleIsNearlyZero, Value), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Value_MetaData), NewProp_Value_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Tolerance = { "Tolerance", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleIsNearlyZero, Tolerance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Tolerance_MetaData), NewProp_Tolerance_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleIsNearlyZero*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_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_MathDoubleIsNearlyZero), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Value,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Tolerance,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleIsNearlyZero Property Definitions **********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleIsNearlyZero",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleIsNearlyZero),
	alignof(FRigVMFunction_MathDoubleIsNearlyZero),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero.InnerSingleton);
}
void FRigVMFunction_MathDoubleIsNearlyZero::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleIsNearlyZero::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		Value,
		Tolerance,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleIsNearlyZero *******************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyEqual ****************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleIsNearlyEqual); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleIsNearlyEqual); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Tolerance_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Result_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyEqual constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_B;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleIsNearlyEqual constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Tolerance"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("Result"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleIsNearlyEqual::Execute"), 
			.Function = &FRigVMFunction_MathDoubleIsNearlyEqual::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleIsNearlyEqual>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleIsNearlyEqual>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleIsNearlyEqual cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual;
class UScriptStruct* FRigVMFunction_MathDoubleIsNearlyEqual::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleIsNearlyEqual"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleIsNearlyEqual Property Definitions *******
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleIsNearlyEqual, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleIsNearlyEqual, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_Tolerance = { "Tolerance", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleIsNearlyEqual, Tolerance), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Tolerance_MetaData), NewProp_Tolerance_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_Result_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleIsNearlyEqual*)Obj)->Result = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_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_MathDoubleIsNearlyEqual), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_Result_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Result_MetaData), NewProp_Result_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_Tolerance,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewProp_Result,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleIsNearlyEqual Property Definitions *********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleIsNearlyEqual",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleIsNearlyEqual),
	alignof(FRigVMFunction_MathDoubleIsNearlyEqual),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual.InnerSingleton);
}
void FRigVMFunction_MathDoubleIsNearlyEqual::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleIsNearlyEqual::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		Tolerance,
		Result
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleIsNearlyEqual ******************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleDeg **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDeg_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleDeg); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleDeg); }
#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_MathDouble.h" },
		{ "TemplateName", "Degrees" },
		{ "ToolTip", "Returns the degrees of a given value in radians" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleRad **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRad_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleRad); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleRad); }
#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_MathDouble.h" },
		{ "TemplateName", "Radians" },
		{ "ToolTip", "Returns the radians of a given value in degrees" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleSin **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleSin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleSin); }
#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_MathDouble.h" },
		{ "TemplateName", "Sin" },
		{ "ToolTip", "Returns the sinus value of the given value (in radians)" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleCos **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCos_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleCos); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleCos); }
#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_MathDouble.h" },
		{ "TemplateName", "Cos" },
		{ "ToolTip", "Returns the cosinus value of the given value (in radians)" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleTan **************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleTan_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleTan); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleTan); }
#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_MathDouble.h" },
		{ "TemplateName", "Tan" },
		{ "ToolTip", "Returns the tangens value of the given value (in radians)" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAsin *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAsin_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAsin); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAsin); }
#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_MathDouble.h" },
		{ "TemplateName", "Asin" },
		{ "ToolTip", "Returns the inverse sinus value (in radians) of the given value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAcos *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAcos_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAcos); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAcos); }
#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_MathDouble.h" },
		{ "TemplateName", "Acos" },
		{ "ToolTip", "Returns the inverse cosinus value (in radians) of the given value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAtan *************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAtan); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAtan); }
#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_MathDouble.h" },
		{ "TemplateName", "Atan" },
		{ "ToolTip", "Returns the inverse tangens value (in radians) of the given value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleAtan2 ************************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan2_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleAtan2); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleAtan2); }
#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_MathDouble.h" },
		{ "TemplateName", "Atan2" },
		{ "ToolTip", "Returns the arctangent of the specified A and B coordinates." },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLawOfCosine ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleLawOfCosine); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleLawOfCosine); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_B_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_C_MetaData[] = {
		{ "Category", "Pins" },
		{ "Input", "" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_AlphaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BetaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_GammaAngle_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_bValid_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLawOfCosine constinit property declarations 
	static const UECodeGen_Private::FDoublePropertyParams NewProp_A;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_B;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_C;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_AlphaAngle;
	static const UECodeGen_Private::FDoublePropertyParams NewProp_BetaAngle;
	static const UECodeGen_Private::FDoublePropertyParams 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_MathDoubleLawOfCosine constinit property declarations 
	static inline constexpr FRigVMCompiledInFunctionArgument RigVMFunctionParameters_Execute[] = {
		{ .Name = TEXT("A"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("B"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("C"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("AlphaAngle"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("BetaAngle"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("GammaAngle"), .Type = TEXT("double"), .Direction = ERigVMFunctionArgumentDirection::Input },
		{ .Name = TEXT("bValid"), .Type = TEXT("bool"), .Direction = ERigVMFunctionArgumentDirection::Input },
	};
	static inline constexpr FRigVMCompiledInFunction RigVMFunctions[] = {
		{ .MethodName = TEXT("FRigVMFunction_MathDoubleLawOfCosine::Execute"), 
			.Function = &FRigVMFunction_MathDoubleLawOfCosine::RigVMExecute, 
			.Parameters = MakeArrayView(RigVMFunctionParameters_Execute),
		},
	};
	static void* NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FRigVMFunction_MathDoubleLawOfCosine>();
	}
	static const UECodeGen_Private::FStructParams StructParams;
}; // struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics
static_assert(std::is_polymorphic<FRigVMFunction_MathDoubleLawOfCosine>() == std::is_polymorphic<FRigVMFunction_MathDoubleBase>(), "USTRUCT FRigVMFunction_MathDoubleLawOfCosine cannot be polymorphic unless super FRigVMFunction_MathDoubleBase is polymorphic");
static FStructRegistrationInfo Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine;
class UScriptStruct* FRigVMFunction_MathDoubleLawOfCosine::StaticStruct()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.OuterSingleton)
	{
		Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.OuterSingleton = GetStaticStruct(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine, (UObject*)Z_Construct_UPackage__Script_RigVM(), TEXT("RigVMFunction_MathDoubleLawOfCosine"));
		FRigVMRegistry::Get().RegisterCompiledInStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.OuterSingleton, MakeArrayView(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::RigVMFunctions));
	}
	return Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.OuterSingleton;
	}

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleLawOfCosine Property Definitions *********
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_A = { "A", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, A), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_A_MetaData), NewProp_A_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_B = { "B", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, B), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_B_MetaData), NewProp_B_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_C = { "C", nullptr, (EPropertyFlags)0x0010000000000005, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, C), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_C_MetaData), NewProp_C_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_AlphaAngle = { "AlphaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, AlphaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_AlphaAngle_MetaData), NewProp_AlphaAngle_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_BetaAngle = { "BetaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, BetaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BetaAngle_MetaData), NewProp_BetaAngle_MetaData) };
const UECodeGen_Private::FDoublePropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_GammaAngle = { "GammaAngle", nullptr, (EPropertyFlags)0x0010000000000014, UECodeGen_Private::EPropertyGenFlags::Double, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(FRigVMFunction_MathDoubleLawOfCosine, GammaAngle), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_GammaAngle_MetaData), NewProp_GammaAngle_MetaData) };
void Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_bValid_SetBit(void* Obj)
{
	((FRigVMFunction_MathDoubleLawOfCosine*)Obj)->bValid = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_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_MathDoubleLawOfCosine), &Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_bValid_SetBit, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_bValid_MetaData), NewProp_bValid_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_A,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_B,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_C,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_AlphaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_BetaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_GammaAngle,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewProp_bValid,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::PropPointers) < 2048);
// ********** End ScriptStruct FRigVMFunction_MathDoubleLawOfCosine Property Definitions ***********
const UECodeGen_Private::FStructParams Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::StructParams = {
	(UObject* (*)())Z_Construct_UPackage__Script_RigVM,
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase,
	&NewStructOps,
	"RigVMFunction_MathDoubleLawOfCosine",
	Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::PropPointers,
	UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::PropPointers),
	sizeof(FRigVMFunction_MathDoubleLawOfCosine),
	alignof(FRigVMFunction_MathDoubleLawOfCosine),
	RF_Public|RF_Transient|RF_MarkAsNative,
	EStructFlags(0x00000001),
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::Struct_MetaDataParams), Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::Struct_MetaDataParams)
};
UScriptStruct* Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine()
{
	if (!Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.InnerSingleton)
	{
		UECodeGen_Private::ConstructUScriptStruct(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.InnerSingleton, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::StructParams);
	}
	return CastChecked<UScriptStruct>(Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine.InnerSingleton);
}
void FRigVMFunction_MathDoubleLawOfCosine::Execute()
{
	FRigVMExecuteContext TemporaryExecuteContext;
	TemporaryExecuteContext.Initialize();
	Execute(TemporaryExecuteContext);
}
void FRigVMFunction_MathDoubleLawOfCosine::Execute(const FRigVMExecuteContext& InExecuteContext)
{
	StaticExecute(
		InExecuteContext,
		A,
		B,
		C,
		AlphaAngle,
		BetaAngle,
		GammaAngle,
		bValid
	);
}
// ********** End ScriptStruct FRigVMFunction_MathDoubleLawOfCosine ********************************

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleExponential ******************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleExponential_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleExponential); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleExponential); }
#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_MathDouble.h" },
		{ "TemplateName", "Exponential" },
		{ "ToolTip", "Computes the base-e exponential of the given value" },
	};
#endif // WITH_METADATA

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleArraySum *********************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArraySum_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleArraySum); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleArraySum); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Sum_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin ScriptStruct FRigVMFunction_MathDoubleArrayAverage *****************************
struct Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArrayAverage_Statics
{
	static inline consteval int32 GetStructSize() { return sizeof(FRigVMFunction_MathDoubleArrayAverage); }
	static inline consteval int16 GetStructAlignment() { return alignof(FRigVMFunction_MathDoubleArrayAverage); }
#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_MathDouble.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_MathDouble.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Average_MetaData[] = {
		{ "Category", "Pins" },
		{ "ModuleRelativePath", "Public/RigVMFunctions/Math/RigVMFunction_MathDouble.h" },
		{ "Output", "" },
	};
#endif // WITH_METADATA

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

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

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathDouble_h__Script_RigVM_Statics
{
	static constexpr FStructRegisterCompiledInInfo ScriptStructInfo[] = {
		{ FRigVMFunction_MathDoubleBase::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBase_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleBase"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleBase, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleBase), 3017980297U) },
		{ FRigVMFunction_MathDoubleConstant::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstant_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleConstant"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstant, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleConstant), 3828381116U) },
		{ FRigVMFunction_MathDoubleUnaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleUnaryOp_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleUnaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleUnaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleUnaryOp), 154944452U) },
		{ FRigVMFunction_MathDoubleBinaryOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBinaryOp_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleBinaryOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleBinaryOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleBinaryOp), 3835787174U) },
		{ FRigVMFunction_MathDoubleBinaryAggregateOp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleBinaryAggregateOp_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleBinaryAggregateOp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleBinaryAggregateOp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleBinaryAggregateOp), 1737142742U) },
		{ FRigVMFunction_MathDoubleMake::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMake_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleMake"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleMake, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleMake), 3173347968U) },
		{ FRigVMFunction_MathDoubleConstPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstPi_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleConstPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleConstPi), 4131195612U) },
		{ FRigVMFunction_MathDoubleConstHalfPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstHalfPi_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleConstHalfPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstHalfPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleConstHalfPi), 3817673212U) },
		{ FRigVMFunction_MathDoubleConstTwoPi::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstTwoPi_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleConstTwoPi"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstTwoPi, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleConstTwoPi), 1168596890U) },
		{ FRigVMFunction_MathDoubleConstE::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleConstE_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleConstE"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleConstE, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleConstE), 1207876607U) },
		{ FRigVMFunction_MathDoubleAdd::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAdd_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAdd"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAdd, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAdd), 1573085465U) },
		{ FRigVMFunction_MathDoubleSub::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSub_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleSub"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleSub, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleSub), 4180243373U) },
		{ FRigVMFunction_MathDoubleMul::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMul_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleMul"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleMul, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleMul), 1794359543U) },
		{ FRigVMFunction_MathDoubleDiv::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDiv_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleDiv"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleDiv, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleDiv), 4198078597U) },
		{ FRigVMFunction_MathDoubleMod::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMod_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleMod"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleMod, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleMod), 2619047750U) },
		{ FRigVMFunction_MathDoubleMin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMin_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleMin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleMin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleMin), 2727702690U) },
		{ FRigVMFunction_MathDoubleMax::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleMax_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleMax"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleMax, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleMax), 24305509U) },
		{ FRigVMFunction_MathDoublePow::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoublePow_Statics::NewStructOps, TEXT("RigVMFunction_MathDoublePow"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoublePow, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoublePow), 633965159U) },
		{ FRigVMFunction_MathDoubleSqrt::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSqrt_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleSqrt"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleSqrt, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleSqrt), 2318580266U) },
		{ FRigVMFunction_MathDoubleNegate::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNegate_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleNegate"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNegate, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleNegate), 3439967948U) },
		{ FRigVMFunction_MathDoubleAbs::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAbs_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAbs"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAbs, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAbs), 225106336U) },
		{ FRigVMFunction_MathDoubleFloor::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleFloor_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleFloor"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleFloor, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleFloor), 2527423432U) },
		{ FRigVMFunction_MathDoubleCeil::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCeil_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleCeil"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleCeil, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleCeil), 1270886794U) },
		{ FRigVMFunction_MathDoubleRound::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRound_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleRound"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRound, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleRound), 225745519U) },
		{ FRigVMFunction_MathDoubleToInt::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleToInt_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleToInt"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleToInt, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleToInt), 3068728435U) },
		{ FRigVMFunction_MathDoubleToFloat::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleToFloat_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleToFloat"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleToFloat, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleToFloat), 3750282196U) },
		{ FRigVMFunction_MathDoubleSign::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSign_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleSign"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleSign, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleSign), 3002068069U) },
		{ FRigVMFunction_MathDoubleClamp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleClamp_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleClamp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleClamp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleClamp), 2038035940U) },
		{ FRigVMFunction_MathDoubleLerp::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLerp_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleLerp"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLerp, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleLerp), 402124921U) },
		{ FRigVMFunction_MathDoubleRemap::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRemap_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleRemap"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRemap, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleRemap), 2890775166U) },
		{ FRigVMFunction_MathDoubleEquals::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleEquals_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleEquals"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleEquals, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleEquals), 4139165624U) },
		{ FRigVMFunction_MathDoubleNotEquals::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleNotEquals_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleNotEquals"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleNotEquals, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleNotEquals), 3762675566U) },
		{ FRigVMFunction_MathDoubleGreater::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreater_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleGreater"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreater, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleGreater), 1201880071U) },
		{ FRigVMFunction_MathDoubleLess::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLess_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleLess"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLess, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleLess), 2881250711U) },
		{ FRigVMFunction_MathDoubleGreaterEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleGreaterEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleGreaterEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleGreaterEqual), 1343241662U) },
		{ FRigVMFunction_MathDoubleLessEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLessEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleLessEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLessEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleLessEqual), 458883453U) },
		{ FRigVMFunction_MathDoubleIsNearlyZero::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleIsNearlyZero"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyZero, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleIsNearlyZero), 834913854U) },
		{ FRigVMFunction_MathDoubleIsNearlyEqual::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleIsNearlyEqual"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleIsNearlyEqual, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleIsNearlyEqual), 3549779460U) },
		{ FRigVMFunction_MathDoubleDeg::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleDeg_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleDeg"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleDeg, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleDeg), 1958478536U) },
		{ FRigVMFunction_MathDoubleRad::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleRad_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleRad"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleRad, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleRad), 2750151092U) },
		{ FRigVMFunction_MathDoubleSin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleSin_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleSin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleSin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleSin), 3134018263U) },
		{ FRigVMFunction_MathDoubleCos::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleCos_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleCos"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleCos, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleCos), 1023599585U) },
		{ FRigVMFunction_MathDoubleTan::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleTan_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleTan"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleTan, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleTan), 3828595831U) },
		{ FRigVMFunction_MathDoubleAsin::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAsin_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAsin"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAsin, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAsin), 3654098696U) },
		{ FRigVMFunction_MathDoubleAcos::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAcos_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAcos"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAcos, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAcos), 3090374734U) },
		{ FRigVMFunction_MathDoubleAtan::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAtan"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAtan, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAtan), 2218388122U) },
		{ FRigVMFunction_MathDoubleAtan2::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleAtan2_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleAtan2"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleAtan2, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleAtan2), 4136151060U) },
		{ FRigVMFunction_MathDoubleLawOfCosine::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleLawOfCosine"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleLawOfCosine, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleLawOfCosine), 384490553U) },
		{ FRigVMFunction_MathDoubleExponential::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleExponential_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleExponential"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleExponential, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleExponential), 294205940U) },
		{ FRigVMFunction_MathDoubleArraySum::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArraySum_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleArraySum"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleArraySum, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleArraySum), 2657917510U) },
		{ FRigVMFunction_MathDoubleArrayAverage::StaticStruct, Z_Construct_UScriptStruct_FRigVMFunction_MathDoubleArrayAverage_Statics::NewStructOps, TEXT("RigVMFunction_MathDoubleArrayAverage"),&Z_Registration_Info_UScriptStruct_FRigVMFunction_MathDoubleArrayAverage, CONSTRUCT_RELOAD_VERSION_INFO(FStructReloadVersionInfo, sizeof(FRigVMFunction_MathDoubleArrayAverage), 3583562816U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathDouble_h__Script_RigVM_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathDouble_h__Script_RigVM_2133456967{
	TEXT("/Script/RigVM"),
	nullptr, 0,
	Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathDouble_h__Script_RigVM_Statics::ScriptStructInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Plugins_Runtime_RigVM_Source_RigVM_Public_RigVMFunctions_Math_RigVMFunction_MathDouble_h__Script_RigVM_Statics::ScriptStructInfo),
	nullptr, 0,
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS