// 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 "BlendSpaceAnalysis.h"
#include "Animation/BoneSocketReference.h"

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

// ********** Begin Cross Module References ********************************************************
COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
ENGINE_API UClass* Z_Construct_UClass_UAnalysisProperties();
ENGINE_API UScriptStruct* Z_Construct_UScriptStruct_FBoneSocketTarget();
PERSONA_API UClass* Z_Construct_UClass_UCachedAnalysisProperties();
PERSONA_API UClass* Z_Construct_UClass_UCachedAnalysisProperties_NoRegister();
PERSONA_API UClass* Z_Construct_UClass_UEulerAnalysisProperties();
PERSONA_API UClass* Z_Construct_UClass_UEulerAnalysisProperties_NoRegister();
PERSONA_API UClass* Z_Construct_UClass_ULinearAnalysisProperties();
PERSONA_API UClass* Z_Construct_UClass_ULinearAnalysisProperties_NoRegister();
PERSONA_API UClass* Z_Construct_UClass_ULinearAnalysisPropertiesBase();
PERSONA_API UClass* Z_Construct_UClass_ULinearAnalysisPropertiesBase_NoRegister();
PERSONA_API UEnum* Z_Construct_UEnum_Persona_EAnalysisEulerAxis();
PERSONA_API UEnum* Z_Construct_UEnum_Persona_EAnalysisLinearAxis();
PERSONA_API UEnum* Z_Construct_UEnum_Persona_EAnalysisSpace();
PERSONA_API UEnum* Z_Construct_UEnum_Persona_EEulerCalculationMethod();
UPackage* Z_Construct_UPackage__Script_Persona();
// ********** End Cross Module References **********************************************************

// ********** Begin Enum EAnalysisSpace ************************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAnalysisSpace;
static UEnum* EAnalysisSpace_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_EAnalysisSpace.OuterSingleton)
	{
		Z_Registration_Info_UEnum_EAnalysisSpace.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Persona_EAnalysisSpace, (UObject*)Z_Construct_UPackage__Script_Persona(), TEXT("EAnalysisSpace"));
	}
	return Z_Registration_Info_UEnum_EAnalysisSpace.OuterSingleton;
}
template<> PERSONA_NON_ATTRIBUTED_API UEnum* StaticEnum<EAnalysisSpace>()
{
	return EAnalysisSpace_StaticEnum();
}
struct Z_Construct_UEnum_Persona_EAnalysisSpace_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "Changing.Name", "EAnalysisSpace::Changing" },
		{ "Changing.ToolTip", "Analysis is done in the space of the specified bone or socket based, but velocities are calculated as if this space is not moving" },
		{ "Fixed.Name", "EAnalysisSpace::Fixed" },
		{ "Fixed.ToolTip", "Analysis is done in the space of the specified bone or socket based on the first frame of the animation used" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "Moving.Name", "EAnalysisSpace::Moving" },
		{ "Moving.ToolTip", "Analysis is done in the space of the specified bone or socket" },
		{ "World.Name", "EAnalysisSpace::World" },
		{ "World.ToolTip", "Analysis is done in world space (relative to the root of the character)" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "EAnalysisSpace::World", (int64)EAnalysisSpace::World },
		{ "EAnalysisSpace::Fixed", (int64)EAnalysisSpace::Fixed },
		{ "EAnalysisSpace::Changing", (int64)EAnalysisSpace::Changing },
		{ "EAnalysisSpace::Moving", (int64)EAnalysisSpace::Moving },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Persona_EAnalysisSpace_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Persona,
	nullptr,
	"EAnalysisSpace",
	"EAnalysisSpace",
	Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Persona_EAnalysisSpace()
{
	if (!Z_Registration_Info_UEnum_EAnalysisSpace.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAnalysisSpace.InnerSingleton, Z_Construct_UEnum_Persona_EAnalysisSpace_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_EAnalysisSpace.InnerSingleton;
}
// ********** End Enum EAnalysisSpace **************************************************************

// ********** Begin Enum EAnalysisLinearAxis *******************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAnalysisLinearAxis;
static UEnum* EAnalysisLinearAxis_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_EAnalysisLinearAxis.OuterSingleton)
	{
		Z_Registration_Info_UEnum_EAnalysisLinearAxis.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Persona_EAnalysisLinearAxis, (UObject*)Z_Construct_UPackage__Script_Persona(), TEXT("EAnalysisLinearAxis"));
	}
	return Z_Registration_Info_UEnum_EAnalysisLinearAxis.OuterSingleton;
}
template<> PERSONA_NON_ATTRIBUTED_API UEnum* StaticEnum<EAnalysisLinearAxis>()
{
	return EAnalysisLinearAxis_StaticEnum();
}
struct Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "MinusX.DisplayName", "-X" },
		{ "MinusX.Name", "EAnalysisLinearAxis::MinusX" },
		{ "MinusX.ToolTip", "The axis points in the negative X direction" },
		{ "MinusY.DisplayName", "-Y" },
		{ "MinusY.Name", "EAnalysisLinearAxis::MinusY" },
		{ "MinusY.ToolTip", "The axis points in the negative Y direction" },
		{ "MinusZ.DisplayName", "-Z" },
		{ "MinusZ.Name", "EAnalysisLinearAxis::MinusZ" },
		{ "MinusZ.ToolTip", "The axis points in the negative Z direction" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "PlusX.DisplayName", "+X" },
		{ "PlusX.Name", "EAnalysisLinearAxis::PlusX" },
		{ "PlusX.ToolTip", "The axis points in the positive X direction" },
		{ "PlusY.DisplayName", "+Y" },
		{ "PlusY.Name", "EAnalysisLinearAxis::PlusY" },
		{ "PlusY.ToolTip", "The axis points in the positive Y direction" },
		{ "PlusZ.DisplayName", "+Z" },
		{ "PlusZ.Name", "EAnalysisLinearAxis::PlusZ" },
		{ "PlusZ.ToolTip", "The axis points in the positive Z direction" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "EAnalysisLinearAxis::PlusX", (int64)EAnalysisLinearAxis::PlusX },
		{ "EAnalysisLinearAxis::PlusY", (int64)EAnalysisLinearAxis::PlusY },
		{ "EAnalysisLinearAxis::PlusZ", (int64)EAnalysisLinearAxis::PlusZ },
		{ "EAnalysisLinearAxis::MinusX", (int64)EAnalysisLinearAxis::MinusX },
		{ "EAnalysisLinearAxis::MinusY", (int64)EAnalysisLinearAxis::MinusY },
		{ "EAnalysisLinearAxis::MinusZ", (int64)EAnalysisLinearAxis::MinusZ },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Persona,
	nullptr,
	"EAnalysisLinearAxis",
	"EAnalysisLinearAxis",
	Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Persona_EAnalysisLinearAxis()
{
	if (!Z_Registration_Info_UEnum_EAnalysisLinearAxis.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAnalysisLinearAxis.InnerSingleton, Z_Construct_UEnum_Persona_EAnalysisLinearAxis_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_EAnalysisLinearAxis.InnerSingleton;
}
// ********** End Enum EAnalysisLinearAxis *********************************************************

// ********** Begin Enum EEulerCalculationMethod ***************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EEulerCalculationMethod;
static UEnum* EEulerCalculationMethod_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_EEulerCalculationMethod.OuterSingleton)
	{
		Z_Registration_Info_UEnum_EEulerCalculationMethod.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Persona_EEulerCalculationMethod, (UObject*)Z_Construct_UPackage__Script_Persona(), TEXT("EEulerCalculationMethod"));
	}
	return Z_Registration_Info_UEnum_EEulerCalculationMethod.OuterSingleton;
}
template<> PERSONA_NON_ATTRIBUTED_API UEnum* StaticEnum<EEulerCalculationMethod>()
{
	return EEulerCalculationMethod_StaticEnum();
}
struct Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "AimDirection.Name", "EEulerCalculationMethod::AimDirection" },
		{ "AimDirection.ToolTip", "Calculates the yaw by looking at the BoneRightAxis. This can provide better yaw values, especially when aiming (e.g. with a weapon that has minimal rotation around its pointing axis) and covering extreme angles up and down, but only if this rightwards facing axis is reliable. It won't work well if the bone is also rolling around its axis." },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "PointDirection.Name", "EEulerCalculationMethod::PointDirection" },
		{ "PointDirection.ToolTip", "Calculates the yaw based only on the BoneFacingAxis. This will work when you're most interested in the yaw and pitch from a pointing direction, but can produce undesirable results when pointing almost directly up or down." },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "EEulerCalculationMethod::AimDirection", (int64)EEulerCalculationMethod::AimDirection },
		{ "EEulerCalculationMethod::PointDirection", (int64)EEulerCalculationMethod::PointDirection },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Persona,
	nullptr,
	"EEulerCalculationMethod",
	"EEulerCalculationMethod",
	Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Persona_EEulerCalculationMethod()
{
	if (!Z_Registration_Info_UEnum_EEulerCalculationMethod.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EEulerCalculationMethod.InnerSingleton, Z_Construct_UEnum_Persona_EEulerCalculationMethod_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_EEulerCalculationMethod.InnerSingleton;
}
// ********** End Enum EEulerCalculationMethod *****************************************************

// ********** Begin Enum EAnalysisEulerAxis ********************************************************
static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAnalysisEulerAxis;
static UEnum* EAnalysisEulerAxis_StaticEnum()
{
	if (!Z_Registration_Info_UEnum_EAnalysisEulerAxis.OuterSingleton)
	{
		Z_Registration_Info_UEnum_EAnalysisEulerAxis.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_Persona_EAnalysisEulerAxis, (UObject*)Z_Construct_UPackage__Script_Persona(), TEXT("EAnalysisEulerAxis"));
	}
	return Z_Registration_Info_UEnum_EAnalysisEulerAxis.OuterSingleton;
}
template<> PERSONA_NON_ATTRIBUTED_API UEnum* StaticEnum<EAnalysisEulerAxis>()
{
	return EAnalysisEulerAxis_StaticEnum();
}
struct Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "Pitch.Name", "EAnalysisEulerAxis::Pitch" },
		{ "Roll.Name", "EAnalysisEulerAxis::Roll" },
		{ "Yaw.Name", "EAnalysisEulerAxis::Yaw" },
	};
#endif // WITH_METADATA
	static constexpr UECodeGen_Private::FEnumeratorParam Enumerators[] = {
		{ "EAnalysisEulerAxis::Roll", (int64)EAnalysisEulerAxis::Roll },
		{ "EAnalysisEulerAxis::Pitch", (int64)EAnalysisEulerAxis::Pitch },
		{ "EAnalysisEulerAxis::Yaw", (int64)EAnalysisEulerAxis::Yaw },
	};
	static const UECodeGen_Private::FEnumParams EnumParams;
}; // struct Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics 
const UECodeGen_Private::FEnumParams Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::EnumParams = {
	(UObject*(*)())Z_Construct_UPackage__Script_Persona,
	nullptr,
	"EAnalysisEulerAxis",
	"EAnalysisEulerAxis",
	Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::Enumerators,
	RF_Public|RF_Transient|RF_MarkAsNative,
	UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::Enumerators),
	EEnumFlags::None,
	(uint8)UEnum::ECppForm::EnumClass,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::Enum_MetaDataParams), Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::Enum_MetaDataParams)
};
UEnum* Z_Construct_UEnum_Persona_EAnalysisEulerAxis()
{
	if (!Z_Registration_Info_UEnum_EAnalysisEulerAxis.InnerSingleton)
	{
		UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAnalysisEulerAxis.InnerSingleton, Z_Construct_UEnum_Persona_EAnalysisEulerAxis_Statics::EnumParams);
	}
	return Z_Registration_Info_UEnum_EAnalysisEulerAxis.InnerSingleton;
}
// ********** End Enum EAnalysisEulerAxis **********************************************************

// ********** Begin Class UCachedAnalysisProperties ************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UCachedAnalysisProperties;
UClass* UCachedAnalysisProperties::GetPrivateStaticClass()
{
	using TClass = UCachedAnalysisProperties;
	if (!Z_Registration_Info_UClass_UCachedAnalysisProperties.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("CachedAnalysisProperties"),
			Z_Registration_Info_UClass_UCachedAnalysisProperties.InnerSingleton,
			StaticRegisterNativesUCachedAnalysisProperties,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_UCachedAnalysisProperties.InnerSingleton;
}
UClass* Z_Construct_UClass_UCachedAnalysisProperties_NoRegister()
{
	return UCachedAnalysisProperties::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UCachedAnalysisProperties_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "Comment", "/**\n * This will be used to preserve values as far as possible when switching between analysis functions, so it contains all\n * the parameters used by the engine functions. User defined can inherit from this and add their own - then the\n * user-defined MakeCache function should replace any base class cache that is passed in with their own.\n*/" },
		{ "IncludePath", "BlendSpaceAnalysis.h" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "This will be used to preserve values as far as possible when switching between analysis functions, so it contains all\nthe parameters used by the engine functions. User defined can inherit from this and add their own - then the\nuser-defined MakeCache function should replace any base class cache that is passed in with their own." },
	};
#endif // WITH_METADATA

// ********** Begin Class UCachedAnalysisProperties constinit property declarations ****************
// ********** End Class UCachedAnalysisProperties constinit property declarations ******************
	static UObject* (*const DependentSingletons[])();
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UCachedAnalysisProperties>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UCachedAnalysisProperties_Statics
UObject* (*const Z_Construct_UClass_UCachedAnalysisProperties_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UObject,
	(UObject* (*)())Z_Construct_UPackage__Script_Persona,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UCachedAnalysisProperties_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UCachedAnalysisProperties_Statics::ClassParams = {
	&UCachedAnalysisProperties::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	nullptr,
	nullptr,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	0,
	0,
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UCachedAnalysisProperties_Statics::Class_MetaDataParams), Z_Construct_UClass_UCachedAnalysisProperties_Statics::Class_MetaDataParams)
};
void UCachedAnalysisProperties::StaticRegisterNativesUCachedAnalysisProperties()
{
}
UClass* Z_Construct_UClass_UCachedAnalysisProperties()
{
	if (!Z_Registration_Info_UClass_UCachedAnalysisProperties.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UCachedAnalysisProperties.OuterSingleton, Z_Construct_UClass_UCachedAnalysisProperties_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UCachedAnalysisProperties.OuterSingleton;
}
UCachedAnalysisProperties::UCachedAnalysisProperties(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UCachedAnalysisProperties);
UCachedAnalysisProperties::~UCachedAnalysisProperties() {}
// ********** End Class UCachedAnalysisProperties **************************************************

// ********** Begin Class ULinearAnalysisPropertiesBase ********************************************
FClassRegistrationInfo Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase;
UClass* ULinearAnalysisPropertiesBase::GetPrivateStaticClass()
{
	using TClass = ULinearAnalysisPropertiesBase;
	if (!Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("LinearAnalysisPropertiesBase"),
			Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.InnerSingleton,
			StaticRegisterNativesULinearAnalysisPropertiesBase,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.InnerSingleton;
}
UClass* Z_Construct_UClass_ULinearAnalysisPropertiesBase_NoRegister()
{
	return ULinearAnalysisPropertiesBase::GetPrivateStaticClass();
}
struct Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "IncludePath", "BlendSpaceAnalysis.h" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BoneSocket_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** The bone or socket used for analysis */" },
		{ "DisplayName", "Bone/Socket" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "The bone or socket used for analysis" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Space_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/**\n\x09* The space in which to perform the analysis. Fixed will use the analysis bone/socket at the first frame\n\x09* of the analysis time range. Changing will use the analysis bone/socket at the relevant frame during the\n\x09* analysis, but calculate velocities assuming that frame isn't moving. Moving will do the same but velocities\n\x09* as well as positions/rotations will be relative to this moving frame.\n\x09*/" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "The space in which to perform the analysis. Fixed will use the analysis bone/socket at the first frame\nof the analysis time range. Changing will use the analysis bone/socket at the relevant frame during the\nanalysis, but calculate velocities assuming that frame isn't moving. Moving will do the same but velocities\nas well as positions/rotations will be relative to this moving frame." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SpaceBoneSocket_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Bone or socket that defines the analysis space (when it isn't World) */" },
		{ "DisplayName", "Analysis Space Bone/Socket" },
		{ "EditCondition", "Space != EAnalysisSpace::World" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Bone or socket that defines the analysis space (when it isn't World)" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_StartTimeFraction_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "ClampMax", "1" },
		{ "ClampMin", "0" },
		{ "Comment", "/** Fraction through each animation at which analysis starts */" },
		{ "DisplayName", "Start time fraction" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Fraction through each animation at which analysis starts" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_EndTimeFraction_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "ClampMax", "1" },
		{ "ClampMin", "0" },
		{ "Comment", "/** Fraction through each animation at which analysis ends */" },
		{ "DisplayName", "End time fraction" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Fraction through each animation at which analysis ends" },
	};
#endif // WITH_METADATA

// ********** Begin Class ULinearAnalysisPropertiesBase constinit property declarations ************
	static const UECodeGen_Private::FStructPropertyParams NewProp_BoneSocket;
	static const UECodeGen_Private::FBytePropertyParams NewProp_Space_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_Space;
	static const UECodeGen_Private::FStructPropertyParams NewProp_SpaceBoneSocket;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_StartTimeFraction;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_EndTimeFraction;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class ULinearAnalysisPropertiesBase constinit property declarations **************
	static UObject* (*const DependentSingletons[])();
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<ULinearAnalysisPropertiesBase>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics

// ********** Begin Class ULinearAnalysisPropertiesBase Property Definitions ***********************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_BoneSocket = { "BoneSocket", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisPropertiesBase, BoneSocket), Z_Construct_UScriptStruct_FBoneSocketTarget, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BoneSocket_MetaData), NewProp_BoneSocket_MetaData) }; // 3986982990
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_Space_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_Space = { "Space", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisPropertiesBase, Space), Z_Construct_UEnum_Persona_EAnalysisSpace, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Space_MetaData), NewProp_Space_MetaData) }; // 110265900
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_SpaceBoneSocket = { "SpaceBoneSocket", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisPropertiesBase, SpaceBoneSocket), Z_Construct_UScriptStruct_FBoneSocketTarget, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SpaceBoneSocket_MetaData), NewProp_SpaceBoneSocket_MetaData) }; // 3986982990
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_StartTimeFraction = { "StartTimeFraction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisPropertiesBase, StartTimeFraction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_StartTimeFraction_MetaData), NewProp_StartTimeFraction_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_EndTimeFraction = { "EndTimeFraction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisPropertiesBase, EndTimeFraction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_EndTimeFraction_MetaData), NewProp_EndTimeFraction_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_BoneSocket,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_Space_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_Space,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_SpaceBoneSocket,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_StartTimeFraction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::NewProp_EndTimeFraction,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::PropPointers) < 2048);
// ********** End Class ULinearAnalysisPropertiesBase Property Definitions *************************
UObject* (*const Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UAnalysisProperties,
	(UObject* (*)())Z_Construct_UPackage__Script_Persona,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::ClassParams = {
	&ULinearAnalysisPropertiesBase::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	nullptr,
	Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::PropPointers,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	0,
	UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::PropPointers),
	0,
	0x000800A1u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::Class_MetaDataParams), Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::Class_MetaDataParams)
};
void ULinearAnalysisPropertiesBase::StaticRegisterNativesULinearAnalysisPropertiesBase()
{
}
UClass* Z_Construct_UClass_ULinearAnalysisPropertiesBase()
{
	if (!Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.OuterSingleton, Z_Construct_UClass_ULinearAnalysisPropertiesBase_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase.OuterSingleton;
}
ULinearAnalysisPropertiesBase::ULinearAnalysisPropertiesBase(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, ULinearAnalysisPropertiesBase);
ULinearAnalysisPropertiesBase::~ULinearAnalysisPropertiesBase() {}
// ********** End Class ULinearAnalysisPropertiesBase **********************************************

// ********** Begin Class ULinearAnalysisProperties ************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_ULinearAnalysisProperties;
UClass* ULinearAnalysisProperties::GetPrivateStaticClass()
{
	using TClass = ULinearAnalysisProperties;
	if (!Z_Registration_Info_UClass_ULinearAnalysisProperties.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("LinearAnalysisProperties"),
			Z_Registration_Info_UClass_ULinearAnalysisProperties.InnerSingleton,
			StaticRegisterNativesULinearAnalysisProperties,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_ULinearAnalysisProperties.InnerSingleton;
}
UClass* Z_Construct_UClass_ULinearAnalysisProperties_NoRegister()
{
	return ULinearAnalysisProperties::GetPrivateStaticClass();
}
struct Z_Construct_UClass_ULinearAnalysisProperties_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "IncludePath", "BlendSpaceAnalysis.h" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_FunctionAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Axis for the analysis function */" },
		{ "DisplayName", "Axis" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Axis for the analysis function" },
	};
#endif // WITH_METADATA

// ********** Begin Class ULinearAnalysisProperties constinit property declarations ****************
	static const UECodeGen_Private::FBytePropertyParams NewProp_FunctionAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_FunctionAxis;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class ULinearAnalysisProperties constinit property declarations ******************
	static UObject* (*const DependentSingletons[])();
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<ULinearAnalysisProperties>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_ULinearAnalysisProperties_Statics

// ********** Begin Class ULinearAnalysisProperties Property Definitions ***************************
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_ULinearAnalysisProperties_Statics::NewProp_FunctionAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_ULinearAnalysisProperties_Statics::NewProp_FunctionAxis = { "FunctionAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(ULinearAnalysisProperties, FunctionAxis), Z_Construct_UEnum_Persona_EAnalysisLinearAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_FunctionAxis_MetaData), NewProp_FunctionAxis_MetaData) }; // 2489960087
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_ULinearAnalysisProperties_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisProperties_Statics::NewProp_FunctionAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_ULinearAnalysisProperties_Statics::NewProp_FunctionAxis,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisProperties_Statics::PropPointers) < 2048);
// ********** End Class ULinearAnalysisProperties Property Definitions *****************************
UObject* (*const Z_Construct_UClass_ULinearAnalysisProperties_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_ULinearAnalysisPropertiesBase,
	(UObject* (*)())Z_Construct_UPackage__Script_Persona,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisProperties_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_ULinearAnalysisProperties_Statics::ClassParams = {
	&ULinearAnalysisProperties::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	nullptr,
	Z_Construct_UClass_ULinearAnalysisProperties_Statics::PropPointers,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	0,
	UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisProperties_Statics::PropPointers),
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_ULinearAnalysisProperties_Statics::Class_MetaDataParams), Z_Construct_UClass_ULinearAnalysisProperties_Statics::Class_MetaDataParams)
};
void ULinearAnalysisProperties::StaticRegisterNativesULinearAnalysisProperties()
{
}
UClass* Z_Construct_UClass_ULinearAnalysisProperties()
{
	if (!Z_Registration_Info_UClass_ULinearAnalysisProperties.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_ULinearAnalysisProperties.OuterSingleton, Z_Construct_UClass_ULinearAnalysisProperties_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_ULinearAnalysisProperties.OuterSingleton;
}
ULinearAnalysisProperties::ULinearAnalysisProperties(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, ULinearAnalysisProperties);
ULinearAnalysisProperties::~ULinearAnalysisProperties() {}
// ********** End Class ULinearAnalysisProperties **************************************************

// ********** Begin Class UEulerAnalysisProperties *************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UEulerAnalysisProperties;
UClass* UEulerAnalysisProperties::GetPrivateStaticClass()
{
	using TClass = UEulerAnalysisProperties;
	if (!Z_Registration_Info_UClass_UEulerAnalysisProperties.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("EulerAnalysisProperties"),
			Z_Registration_Info_UClass_UEulerAnalysisProperties.InnerSingleton,
			StaticRegisterNativesUEulerAnalysisProperties,
			sizeof(TClass),
			alignof(TClass),
			TClass::StaticClassFlags,
			TClass::StaticClassCastFlags(),
			TClass::StaticConfigName(),
			(UClass::ClassConstructorType)InternalConstructor<TClass>,
			(UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>,
			UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass),
			&TClass::Super::StaticClass,
			&TClass::WithinClass::StaticClass
		);
	}
	return Z_Registration_Info_UClass_UEulerAnalysisProperties.InnerSingleton;
}
UClass* Z_Construct_UClass_UEulerAnalysisProperties_NoRegister()
{
	return UEulerAnalysisProperties::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UEulerAnalysisProperties_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "IncludePath", "BlendSpaceAnalysis.h" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_FunctionAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Axis for the analysis function */" },
		{ "DisplayName", "Axis" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Axis for the analysis function" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BoneSocket_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** The bone or socket used for analysis */" },
		{ "DisplayName", "Bone/Socket" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "The bone or socket used for analysis" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BoneFacingAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Used for some analysis functions - specifies the bone/socket axis that points in the facing/forwards direction */" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Used for some analysis functions - specifies the bone/socket axis that points in the facing/forwards direction" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_BoneRightAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Used for some analysis functions - specifies the bone/socket axis that points to the \"right\" */" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Used for some analysis functions - specifies the bone/socket axis that points to the \"right\"" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_EulerCalculationMethod_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Used for some analysis functions - specifies how yaw should be calculated from the bone axes */" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Used for some analysis functions - specifies how yaw should be calculated from the bone axes" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_Space_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/**\n\x09* The space in which to perform the analysis. Fixed will use the analysis bone/socket at the first frame\n\x09* of the analysis time range. Changing will use the analysis bone/socket at the relevant frame during the\n\x09* analysis, but calculate velocities assuming that frame isn't moving. Moving will do the same but velocities\n\x09* as well as positions/rotations will be relative to this moving frame.\n\x09*/" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "The space in which to perform the analysis. Fixed will use the analysis bone/socket at the first frame\nof the analysis time range. Changing will use the analysis bone/socket at the relevant frame during the\nanalysis, but calculate velocities assuming that frame isn't moving. Moving will do the same but velocities\nas well as positions/rotations will be relative to this moving frame." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_SpaceBoneSocket_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** Bone or socket that defines the analysis space (when it isn't World) */" },
		{ "DisplayName", "Analysis Space Bone/Socket" },
		{ "EditCondition", "Space != EAnalysisSpace::World" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Bone or socket that defines the analysis space (when it isn't World)" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_CharacterFacingAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** World or bone/socket axis that specifies the character's facing direction */" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "World or bone/socket axis that specifies the character's facing direction" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_CharacterUpAxis_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "Comment", "/** World or bone/socket axis that specifies the character's up direction */" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "World or bone/socket axis that specifies the character's up direction" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_StartTimeFraction_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "ClampMax", "1" },
		{ "ClampMin", "0" },
		{ "Comment", "/** Fraction through each animation at which analysis starts */" },
		{ "DisplayName", "Start time fraction" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Fraction through each animation at which analysis starts" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_EndTimeFraction_MetaData[] = {
		{ "Category", "AnalysisProperties" },
		{ "ClampMax", "1" },
		{ "ClampMin", "0" },
		{ "Comment", "/** Fraction through each animation at which analysis ends */" },
		{ "DisplayName", "End time fraction" },
		{ "ModuleRelativePath", "Public/BlendSpaceAnalysis.h" },
		{ "ToolTip", "Fraction through each animation at which analysis ends" },
	};
#endif // WITH_METADATA

// ********** Begin Class UEulerAnalysisProperties constinit property declarations *****************
	static const UECodeGen_Private::FBytePropertyParams NewProp_FunctionAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_FunctionAxis;
	static const UECodeGen_Private::FStructPropertyParams NewProp_BoneSocket;
	static const UECodeGen_Private::FBytePropertyParams NewProp_BoneFacingAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_BoneFacingAxis;
	static const UECodeGen_Private::FBytePropertyParams NewProp_BoneRightAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_BoneRightAxis;
	static const UECodeGen_Private::FBytePropertyParams NewProp_EulerCalculationMethod_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_EulerCalculationMethod;
	static const UECodeGen_Private::FBytePropertyParams NewProp_Space_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_Space;
	static const UECodeGen_Private::FStructPropertyParams NewProp_SpaceBoneSocket;
	static const UECodeGen_Private::FBytePropertyParams NewProp_CharacterFacingAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_CharacterFacingAxis;
	static const UECodeGen_Private::FBytePropertyParams NewProp_CharacterUpAxis_Underlying;
	static const UECodeGen_Private::FEnumPropertyParams NewProp_CharacterUpAxis;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_StartTimeFraction;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_EndTimeFraction;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class UEulerAnalysisProperties constinit property declarations *******************
	static UObject* (*const DependentSingletons[])();
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UEulerAnalysisProperties>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UEulerAnalysisProperties_Statics

// ********** Begin Class UEulerAnalysisProperties Property Definitions ****************************
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_FunctionAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_FunctionAxis = { "FunctionAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, FunctionAxis), Z_Construct_UEnum_Persona_EAnalysisEulerAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_FunctionAxis_MetaData), NewProp_FunctionAxis_MetaData) }; // 1945753561
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneSocket = { "BoneSocket", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, BoneSocket), Z_Construct_UScriptStruct_FBoneSocketTarget, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BoneSocket_MetaData), NewProp_BoneSocket_MetaData) }; // 3986982990
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneFacingAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneFacingAxis = { "BoneFacingAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, BoneFacingAxis), Z_Construct_UEnum_Persona_EAnalysisLinearAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BoneFacingAxis_MetaData), NewProp_BoneFacingAxis_MetaData) }; // 2489960087
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneRightAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneRightAxis = { "BoneRightAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, BoneRightAxis), Z_Construct_UEnum_Persona_EAnalysisLinearAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_BoneRightAxis_MetaData), NewProp_BoneRightAxis_MetaData) }; // 2489960087
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EulerCalculationMethod_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EulerCalculationMethod = { "EulerCalculationMethod", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, EulerCalculationMethod), Z_Construct_UEnum_Persona_EEulerCalculationMethod, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_EulerCalculationMethod_MetaData), NewProp_EulerCalculationMethod_MetaData) }; // 2734798132
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_Space_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_Space = { "Space", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, Space), Z_Construct_UEnum_Persona_EAnalysisSpace, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_Space_MetaData), NewProp_Space_MetaData) }; // 110265900
const UECodeGen_Private::FStructPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_SpaceBoneSocket = { "SpaceBoneSocket", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, SpaceBoneSocket), Z_Construct_UScriptStruct_FBoneSocketTarget, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_SpaceBoneSocket_MetaData), NewProp_SpaceBoneSocket_MetaData) }; // 3986982990
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterFacingAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterFacingAxis = { "CharacterFacingAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, CharacterFacingAxis), Z_Construct_UEnum_Persona_EAnalysisLinearAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_CharacterFacingAxis_MetaData), NewProp_CharacterFacingAxis_MetaData) }; // 2489960087
const UECodeGen_Private::FBytePropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterUpAxis_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, nullptr, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterUpAxis = { "CharacterUpAxis", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, CharacterUpAxis), Z_Construct_UEnum_Persona_EAnalysisLinearAxis, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_CharacterUpAxis_MetaData), NewProp_CharacterUpAxis_MetaData) }; // 2489960087
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_StartTimeFraction = { "StartTimeFraction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, StartTimeFraction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_StartTimeFraction_MetaData), NewProp_StartTimeFraction_MetaData) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EndTimeFraction = { "EndTimeFraction", nullptr, (EPropertyFlags)0x0010000000000001, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UEulerAnalysisProperties, EndTimeFraction), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_EndTimeFraction_MetaData), NewProp_EndTimeFraction_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UEulerAnalysisProperties_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_FunctionAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_FunctionAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneSocket,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneFacingAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneFacingAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneRightAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_BoneRightAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EulerCalculationMethod_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EulerCalculationMethod,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_Space_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_Space,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_SpaceBoneSocket,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterFacingAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterFacingAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterUpAxis_Underlying,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_CharacterUpAxis,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_StartTimeFraction,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UEulerAnalysisProperties_Statics::NewProp_EndTimeFraction,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UEulerAnalysisProperties_Statics::PropPointers) < 2048);
// ********** End Class UEulerAnalysisProperties Property Definitions ******************************
UObject* (*const Z_Construct_UClass_UEulerAnalysisProperties_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UAnalysisProperties,
	(UObject* (*)())Z_Construct_UPackage__Script_Persona,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UEulerAnalysisProperties_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UEulerAnalysisProperties_Statics::ClassParams = {
	&UEulerAnalysisProperties::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	nullptr,
	Z_Construct_UClass_UEulerAnalysisProperties_Statics::PropPointers,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	0,
	UE_ARRAY_COUNT(Z_Construct_UClass_UEulerAnalysisProperties_Statics::PropPointers),
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UEulerAnalysisProperties_Statics::Class_MetaDataParams), Z_Construct_UClass_UEulerAnalysisProperties_Statics::Class_MetaDataParams)
};
void UEulerAnalysisProperties::StaticRegisterNativesUEulerAnalysisProperties()
{
}
UClass* Z_Construct_UClass_UEulerAnalysisProperties()
{
	if (!Z_Registration_Info_UClass_UEulerAnalysisProperties.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UEulerAnalysisProperties.OuterSingleton, Z_Construct_UClass_UEulerAnalysisProperties_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UEulerAnalysisProperties.OuterSingleton;
}
UEulerAnalysisProperties::UEulerAnalysisProperties(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UEulerAnalysisProperties);
UEulerAnalysisProperties::~UEulerAnalysisProperties() {}
// ********** End Class UEulerAnalysisProperties ***************************************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics
{
	static constexpr FEnumRegisterCompiledInInfo EnumInfo[] = {
		{ EAnalysisSpace_StaticEnum, TEXT("EAnalysisSpace"), &Z_Registration_Info_UEnum_EAnalysisSpace, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 110265900U) },
		{ EAnalysisLinearAxis_StaticEnum, TEXT("EAnalysisLinearAxis"), &Z_Registration_Info_UEnum_EAnalysisLinearAxis, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2489960087U) },
		{ EEulerCalculationMethod_StaticEnum, TEXT("EEulerCalculationMethod"), &Z_Registration_Info_UEnum_EEulerCalculationMethod, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2734798132U) },
		{ EAnalysisEulerAxis_StaticEnum, TEXT("EAnalysisEulerAxis"), &Z_Registration_Info_UEnum_EAnalysisEulerAxis, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1945753561U) },
	};
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_UCachedAnalysisProperties, UCachedAnalysisProperties::StaticClass, TEXT("UCachedAnalysisProperties"), &Z_Registration_Info_UClass_UCachedAnalysisProperties, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UCachedAnalysisProperties), 772344515U) },
		{ Z_Construct_UClass_ULinearAnalysisPropertiesBase, ULinearAnalysisPropertiesBase::StaticClass, TEXT("ULinearAnalysisPropertiesBase"), &Z_Registration_Info_UClass_ULinearAnalysisPropertiesBase, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(ULinearAnalysisPropertiesBase), 4258903697U) },
		{ Z_Construct_UClass_ULinearAnalysisProperties, ULinearAnalysisProperties::StaticClass, TEXT("ULinearAnalysisProperties"), &Z_Registration_Info_UClass_ULinearAnalysisProperties, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(ULinearAnalysisProperties), 2803340131U) },
		{ Z_Construct_UClass_UEulerAnalysisProperties, UEulerAnalysisProperties::StaticClass, TEXT("UEulerAnalysisProperties"), &Z_Registration_Info_UClass_UEulerAnalysisProperties, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UEulerAnalysisProperties), 4112604697U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_3487160048{
	TEXT("/Script/Persona"),
	Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics::ClassInfo),
	nullptr, 0,
	Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Editor_Persona_Public_BlendSpaceAnalysis_h__Script_Persona_Statics::EnumInfo),
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS