DedicatedServerCourse/Intermediate/Build/Win64/FPSTemplateServer/Inc/Engine/UHT/CheatManager.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 "GameFramework/CheatManager.h"
#include "GameFramework/PlayerController.h"
#include "UObject/Class.h"
#include "UObject/CoreNet.h"

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

// ********** Begin Cross Module References ********************************************************
COREUOBJECT_API UClass* Z_Construct_UClass_UClass_NoRegister();
COREUOBJECT_API UClass* Z_Construct_UClass_UObject();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FRotator();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
ENGINE_API UClass* Z_Construct_UClass_AActor_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_ADebugCameraController_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_APawn_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_APlayerController_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_UCheatManager();
ENGINE_API UClass* Z_Construct_UClass_UCheatManager_NoRegister();
ENGINE_API UClass* Z_Construct_UClass_UCheatManagerExtension();
ENGINE_API UClass* Z_Construct_UClass_UCheatManagerExtension_NoRegister();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_ECollisionChannel();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_EEndPlayReason();
UPackage* Z_Construct_UPackage__Script_Engine();
// ********** End Cross Module References **********************************************************

// ********** Begin Class UCheatManagerExtension Function AddedToCheatManager **********************
static FName NAME_UCheatManagerExtension_AddedToCheatManager = FName(TEXT("AddedToCheatManager"));
void UCheatManagerExtension::AddedToCheatManager()
{
	UFunction* Func = FindFunctionChecked(NAME_UCheatManagerExtension_AddedToCheatManager);
	if (!Func->GetOwnerClass()->HasAnyClassFlags(CLASS_Native))
	{
	ProcessEvent(Func,NULL);
	}
	else
	{
		AddedToCheatManager_Implementation();
	}
}
struct Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "DisplayName", "Added To Cheat Manager" },
		{ "Keywords", "Begin Play" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function AddedToCheatManager constinit property declarations *******************
// ********** End Function AddedToCheatManager constinit property declarations *********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManagerExtension, nullptr, "AddedToCheatManager", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08020C02, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManagerExtension::execAddedToCheatManager)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->AddedToCheatManager_Implementation();
	P_NATIVE_END;
}
// ********** End Class UCheatManagerExtension Function AddedToCheatManager ************************

// ********** Begin Class UCheatManagerExtension Function GetPlayerController **********************
struct Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics
{
	struct CheatManagerExtension_eventGetPlayerController_Parms
	{
		APlayerController* ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function GetPlayerController constinit property declarations *******************
	static const UECodeGen_Private::FObjectPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function GetPlayerController constinit property declarations *********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function GetPlayerController Property Definitions ******************************
const UECodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManagerExtension_eventGetPlayerController_Parms, ReturnValue), Z_Construct_UClass_APlayerController_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::PropPointers) < 2048);
// ********** End Function GetPlayerController Property Definitions ********************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManagerExtension, nullptr, "GetPlayerController", 	Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::CheatManagerExtension_eventGetPlayerController_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::CheatManagerExtension_eventGetPlayerController_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManagerExtension::execGetPlayerController)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	*(APlayerController**)Z_Param__Result=P_THIS->GetPlayerController();
	P_NATIVE_END;
}
// ********** End Class UCheatManagerExtension Function GetPlayerController ************************

// ********** Begin Class UCheatManagerExtension Function RemovedFromCheatManager ******************
static FName NAME_UCheatManagerExtension_RemovedFromCheatManager = FName(TEXT("RemovedFromCheatManager"));
void UCheatManagerExtension::RemovedFromCheatManager()
{
	UFunction* Func = FindFunctionChecked(NAME_UCheatManagerExtension_RemovedFromCheatManager);
	if (!Func->GetOwnerClass()->HasAnyClassFlags(CLASS_Native))
	{
	ProcessEvent(Func,NULL);
	}
	else
	{
		RemovedFromCheatManager_Implementation();
	}
}
struct Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "DisplayName", "Removed From Cheat Manager" },
		{ "Keywords", "End Play" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function RemovedFromCheatManager constinit property declarations ***************
// ********** End Function RemovedFromCheatManager constinit property declarations *****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManagerExtension, nullptr, "RemovedFromCheatManager", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08020C02, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManagerExtension::execRemovedFromCheatManager)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->RemovedFromCheatManager_Implementation();
	P_NATIVE_END;
}
// ********** End Class UCheatManagerExtension Function RemovedFromCheatManager ********************

// ********** Begin Class UCheatManagerExtension ***************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UCheatManagerExtension;
UClass* UCheatManagerExtension::GetPrivateStaticClass()
{
	using TClass = UCheatManagerExtension;
	if (!Z_Registration_Info_UClass_UCheatManagerExtension.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("CheatManagerExtension"),
			Z_Registration_Info_UClass_UCheatManagerExtension.InnerSingleton,
			StaticRegisterNativesUCheatManagerExtension,
			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_UCheatManagerExtension.InnerSingleton;
}
UClass* Z_Construct_UClass_UCheatManagerExtension_NoRegister()
{
	return UCheatManagerExtension::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UCheatManagerExtension_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/** A cheat manager extension can extend the main cheat manager in a modular way, being enabled or disabled when the system associated with the cheats is enabled or disabled */" },
		{ "IncludePath", "GameFramework/CheatManager.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "A cheat manager extension can extend the main cheat manager in a modular way, being enabled or disabled when the system associated with the cheats is enabled or disabled" },
	};
#endif // WITH_METADATA

// ********** Begin Class UCheatManagerExtension constinit property declarations *******************
// ********** End Class UCheatManagerExtension constinit property declarations *********************
	static constexpr UE::CodeGen::FClassNativeFunction Funcs[] = {
		{ .NameUTF8 = UTF8TEXT("AddedToCheatManager"), .Pointer = &UCheatManagerExtension::execAddedToCheatManager },
		{ .NameUTF8 = UTF8TEXT("GetPlayerController"), .Pointer = &UCheatManagerExtension::execGetPlayerController },
		{ .NameUTF8 = UTF8TEXT("RemovedFromCheatManager"), .Pointer = &UCheatManagerExtension::execRemovedFromCheatManager },
	};
	static UObject* (*const DependentSingletons[])();
	static constexpr FClassFunctionLinkInfo FuncInfo[] = {
		{ &Z_Construct_UFunction_UCheatManagerExtension_AddedToCheatManager, "AddedToCheatManager" }, // 324963228
		{ &Z_Construct_UFunction_UCheatManagerExtension_GetPlayerController, "GetPlayerController" }, // 4176133130
		{ &Z_Construct_UFunction_UCheatManagerExtension_RemovedFromCheatManager, "RemovedFromCheatManager" }, // 2676925897
	};
	static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UCheatManagerExtension>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UCheatManagerExtension_Statics
UObject* (*const Z_Construct_UClass_UCheatManagerExtension_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UObject,
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManagerExtension_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UCheatManagerExtension_Statics::ClassParams = {
	&UCheatManagerExtension::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	FuncInfo,
	nullptr,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	UE_ARRAY_COUNT(FuncInfo),
	0,
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManagerExtension_Statics::Class_MetaDataParams), Z_Construct_UClass_UCheatManagerExtension_Statics::Class_MetaDataParams)
};
void UCheatManagerExtension::StaticRegisterNativesUCheatManagerExtension()
{
	UClass* Class = UCheatManagerExtension::StaticClass();
	FNativeFunctionRegistrar::RegisterFunctions(Class, MakeConstArrayView(Z_Construct_UClass_UCheatManagerExtension_Statics::Funcs));
}
UClass* Z_Construct_UClass_UCheatManagerExtension()
{
	if (!Z_Registration_Info_UClass_UCheatManagerExtension.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UCheatManagerExtension.OuterSingleton, Z_Construct_UClass_UCheatManagerExtension_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UCheatManagerExtension.OuterSingleton;
}
UCheatManagerExtension::UCheatManagerExtension(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UCheatManagerExtension);
UCheatManagerExtension::~UCheatManagerExtension() {}
// ********** End Class UCheatManagerExtension *****************************************************

// ********** Begin Class UCheatManager Function BugIt *********************************************
struct Z_Construct_UFunction_UCheatManager_BugIt_Statics
{
	struct CheatManager_eventBugIt_Parms
	{
		FString ScreenShotDescription;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/**\n\x09* This function is used to print out the BugIt location.  It prints out copy and paste versions for both IMing someone to type in\n\x09* and also a gameinfo ?options version so that you can append it to your launching url and be taken to the correct place.\n\x09* Additionally, it will take a screen shot so reporting bugs is a one command action!\n\x09*\n\x09**/" },
		{ "CPP_Default_ScreenShotDescription", "" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "This function is used to print out the BugIt location.  It prints out copy and paste versions for both IMing someone to type in\nand also a gameinfo ?options version so that you can append it to your launching url and be taken to the correct place.\nAdditionally, it will take a screen shot so reporting bugs is a one command action!" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ScreenShotDescription_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function BugIt constinit property declarations *********************************
	static const UECodeGen_Private::FStrPropertyParams NewProp_ScreenShotDescription;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function BugIt constinit property declarations ***********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function BugIt Property Definitions ********************************************
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_BugIt_Statics::NewProp_ScreenShotDescription = { "ScreenShotDescription", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugIt_Parms, ScreenShotDescription), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ScreenShotDescription_MetaData), NewProp_ScreenShotDescription_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_BugIt_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugIt_Statics::NewProp_ScreenShotDescription,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugIt_Statics::PropPointers) < 2048);
// ********** End Function BugIt Property Definitions **********************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_BugIt_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "BugIt", 	Z_Construct_UFunction_UCheatManager_BugIt_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugIt_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_BugIt_Statics::CheatManager_eventBugIt_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugIt_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_BugIt_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_BugIt_Statics::CheatManager_eventBugIt_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_BugIt()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_BugIt_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execBugIt)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_ScreenShotDescription);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->BugIt(Z_Param_ScreenShotDescription);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function BugIt ***********************************************

// ********** Begin Class UCheatManager Function BugItGo *******************************************
struct Z_Construct_UFunction_UCheatManager_BugItGo_Statics
{
	struct CheatManager_eventBugItGo_Parms
	{
		float X;
		float Y;
		float Z;
		float Pitch;
		float Yaw;
		float Roll;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/**\n\x09 * This will move the player and set their rotation to the passed in values.\n\x09 * We have this version of the BugIt family as it is easier to type in just raw numbers in the console.\n\x09 */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "This will move the player and set their rotation to the passed in values.\nWe have this version of the BugIt family as it is easier to type in just raw numbers in the console." },
	};
#endif // WITH_METADATA

// ********** Begin Function BugItGo constinit property declarations *******************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_X;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Y;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Z;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Pitch;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Yaw;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Roll;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function BugItGo constinit property declarations *********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function BugItGo Property Definitions ******************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_X = { "X", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, X), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Y = { "Y", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, Y), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Z = { "Z", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, Z), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Pitch = { "Pitch", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, Pitch), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Yaw = { "Yaw", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, Yaw), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Roll = { "Roll", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItGo_Parms, Roll), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_BugItGo_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_X,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Y,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Z,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Pitch,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Yaw,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItGo_Statics::NewProp_Roll,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItGo_Statics::PropPointers) < 2048);
// ********** End Function BugItGo Property Definitions ********************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_BugItGo_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "BugItGo", 	Z_Construct_UFunction_UCheatManager_BugItGo_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItGo_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_BugItGo_Statics::CheatManager_eventBugItGo_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItGo_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_BugItGo_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_BugItGo_Statics::CheatManager_eventBugItGo_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_BugItGo()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_BugItGo_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execBugItGo)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_X);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Y);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Z);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Pitch);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Yaw);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Roll);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->BugItGo(Z_Param_X,Z_Param_Y,Z_Param_Z,Z_Param_Pitch,Z_Param_Yaw,Z_Param_Roll);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function BugItGo *********************************************

// ********** Begin Class UCheatManager Function BugItStringCreator ********************************
struct Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics
{
	struct CheatManager_eventBugItStringCreator_Parms
	{
		FVector ViewLocation;
		FRotator ViewRotation;
		FString GoString;
		FString LocString;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** This will create a BugItGo string for us.  Nice for calling form c++ where you just want the string and no Screenshots **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "This will create a BugItGo string for us.  Nice for calling form c++ where you just want the string and no Screenshots *" },
	};
#endif // WITH_METADATA

// ********** Begin Function BugItStringCreator constinit property declarations ********************
	static const UECodeGen_Private::FStructPropertyParams NewProp_ViewLocation;
	static const UECodeGen_Private::FStructPropertyParams NewProp_ViewRotation;
	static const UECodeGen_Private::FStrPropertyParams NewProp_GoString;
	static const UECodeGen_Private::FStrPropertyParams NewProp_LocString;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function BugItStringCreator constinit property declarations **********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function BugItStringCreator Property Definitions *******************************
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_ViewLocation = { "ViewLocation", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItStringCreator_Parms, ViewLocation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_ViewRotation = { "ViewRotation", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItStringCreator_Parms, ViewRotation), Z_Construct_UScriptStruct_FRotator, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_GoString = { "GoString", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItStringCreator_Parms, GoString), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_LocString = { "LocString", nullptr, (EPropertyFlags)0x0010000000000180, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventBugItStringCreator_Parms, LocString), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_ViewLocation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_ViewRotation,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_GoString,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::NewProp_LocString,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::PropPointers) < 2048);
// ********** End Function BugItStringCreator Property Definitions *********************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "BugItStringCreator", 	Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::CheatManager_eventBugItStringCreator_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00C20602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::CheatManager_eventBugItStringCreator_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_BugItStringCreator()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_BugItStringCreator_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execBugItStringCreator)
{
	P_GET_STRUCT(FVector,Z_Param_ViewLocation);
	P_GET_STRUCT(FRotator,Z_Param_ViewRotation);
	P_GET_PROPERTY_REF(FStrProperty,Z_Param_Out_GoString);
	P_GET_PROPERTY_REF(FStrProperty,Z_Param_Out_LocString);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->BugItStringCreator(Z_Param_ViewLocation,Z_Param_ViewRotation,Z_Param_Out_GoString,Z_Param_Out_LocString);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function BugItStringCreator **********************************

// ********** Begin Class UCheatManager Function ChangeSize ****************************************
struct Z_Construct_UFunction_UCheatManager_ChangeSize_Statics
{
	struct CheatManager_eventChangeSize_Parms
	{
		float F;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/* Scale the player's size to be F * default size. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Scale the player's size to be F * default size." },
	};
#endif // WITH_METADATA

// ********** Begin Function ChangeSize constinit property declarations ****************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_F;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function ChangeSize constinit property declarations ******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function ChangeSize Property Definitions ***************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::NewProp_F = { "F", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventChangeSize_Parms, F), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::NewProp_F,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::PropPointers) < 2048);
// ********** End Function ChangeSize Property Definitions *****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ChangeSize", 	Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::CheatManager_eventChangeSize_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::CheatManager_eventChangeSize_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_ChangeSize()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ChangeSize_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execChangeSize)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_F);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ChangeSize(Z_Param_F);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ChangeSize ******************************************

// ********** Begin Class UCheatManager Function CheatScript ***************************************
struct Z_Construct_UFunction_UCheatManager_CheatScript_Statics
{
	struct CheatManager_eventCheatScript_Parms
	{
		FString ScriptName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Executes commands listed in CheatScript.ScriptName ini section of DefaultGame.ini */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Executes commands listed in CheatScript.ScriptName ini section of DefaultGame.ini" },
	};
#endif // WITH_METADATA

// ********** Begin Function CheatScript constinit property declarations ***************************
	static const UECodeGen_Private::FStrPropertyParams NewProp_ScriptName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function CheatScript constinit property declarations *****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function CheatScript Property Definitions **************************************
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_CheatScript_Statics::NewProp_ScriptName = { "ScriptName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventCheatScript_Parms, ScriptName), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_CheatScript_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_CheatScript_Statics::NewProp_ScriptName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_CheatScript_Statics::PropPointers) < 2048);
// ********** End Function CheatScript Property Definitions ****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_CheatScript_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "CheatScript", 	Z_Construct_UFunction_UCheatManager_CheatScript_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_CheatScript_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_CheatScript_Statics::CheatManager_eventCheatScript_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_CheatScript_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_CheatScript_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_CheatScript_Statics::CheatManager_eventCheatScript_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_CheatScript()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_CheatScript_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execCheatScript)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_ScriptName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->CheatScript(Z_Param_ScriptName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function CheatScript *****************************************

// ********** Begin Class UCheatManager Function DamageTarget **************************************
struct Z_Construct_UFunction_UCheatManager_DamageTarget_Statics
{
	struct CheatManager_eventDamageTarget_Parms
	{
		float DamageAmount;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Damage the actor you're looking at (sourced from the player). */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Damage the actor you're looking at (sourced from the player)." },
	};
#endif // WITH_METADATA

// ********** Begin Function DamageTarget constinit property declarations **************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_DamageAmount;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DamageTarget constinit property declarations ****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DamageTarget Property Definitions *************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::NewProp_DamageAmount = { "DamageAmount", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDamageTarget_Parms, DamageAmount), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::NewProp_DamageAmount,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::PropPointers) < 2048);
// ********** End Function DamageTarget Property Definitions ***************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DamageTarget", 	Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::CheatManager_eventDamageTarget_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::CheatManager_eventDamageTarget_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DamageTarget()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DamageTarget_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDamageTarget)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_DamageAmount);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DamageTarget(Z_Param_DamageAmount);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DamageTarget ****************************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweep *********************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Toggle capsule trace debugging. Will trace a capsule from current view point and show where it hits the world */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Toggle capsule trace debugging. Will trace a capsule from current view point and show where it hits the world" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweep constinit property declarations *********************
// ********** End Function DebugCapsuleSweep constinit property declarations ***********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweep", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweep)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweep();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweep ***********************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepCapture **************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Capture current trace and add to persistent list **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Capture current trace and add to persistent list *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepCapture constinit property declarations **************
// ********** End Function DebugCapsuleSweepCapture constinit property declarations ****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepCapture", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepCapture)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepCapture();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepCapture ****************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepChannel **************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics
{
	struct CheatManager_eventDebugCapsuleSweepChannel_Parms
	{
		TEnumAsByte<ECollisionChannel> Channel;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Change Trace Channel **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Change Trace Channel *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepChannel constinit property declarations **************
	static const UECodeGen_Private::FBytePropertyParams NewProp_Channel;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DebugCapsuleSweepChannel constinit property declarations ****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DebugCapsuleSweepChannel Property Definitions *************************
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::NewProp_Channel = { "Channel", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDebugCapsuleSweepChannel_Parms, Channel), Z_Construct_UEnum_Engine_ECollisionChannel, METADATA_PARAMS(0, nullptr) }; // 838391399
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::NewProp_Channel,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::PropPointers) < 2048);
// ********** End Function DebugCapsuleSweepChannel Property Definitions ***************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepChannel", 	Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::CheatManager_eventDebugCapsuleSweepChannel_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::CheatManager_eventDebugCapsuleSweepChannel_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepChannel)
{
	P_GET_PROPERTY(FByteProperty,Z_Param_Channel);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepChannel(ECollisionChannel(Z_Param_Channel));
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepChannel ****************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepClear ****************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Clear persistent list for trace capture **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Clear persistent list for trace capture *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepClear constinit property declarations ****************
// ********** End Function DebugCapsuleSweepClear constinit property declarations ******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepClear", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepClear)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepClear();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepClear ******************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepComplex **************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics
{
	struct CheatManager_eventDebugCapsuleSweepComplex_Parms
	{
		bool bTraceComplex;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Change Trace Complex setting **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Change Trace Complex setting *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepComplex constinit property declarations **************
	static void NewProp_bTraceComplex_SetBit(void* Obj);
	static const UECodeGen_Private::FBoolPropertyParams NewProp_bTraceComplex;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DebugCapsuleSweepComplex constinit property declarations ****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DebugCapsuleSweepComplex Property Definitions *************************
void Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::NewProp_bTraceComplex_SetBit(void* Obj)
{
	((CheatManager_eventDebugCapsuleSweepComplex_Parms*)Obj)->bTraceComplex = 1;
}
const UECodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::NewProp_bTraceComplex = { "bTraceComplex", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Bool | UECodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, sizeof(bool), sizeof(CheatManager_eventDebugCapsuleSweepComplex_Parms), &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::NewProp_bTraceComplex_SetBit, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::NewProp_bTraceComplex,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::PropPointers) < 2048);
// ********** End Function DebugCapsuleSweepComplex Property Definitions ***************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepComplex", 	Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::CheatManager_eventDebugCapsuleSweepComplex_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::CheatManager_eventDebugCapsuleSweepComplex_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepComplex)
{
	P_GET_UBOOL(Z_Param_bTraceComplex);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepComplex(Z_Param_bTraceComplex);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepComplex ****************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepPawn *****************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Capture current local PC's pawn's location and add to persistent list **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Capture current local PC's pawn's location and add to persistent list *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepPawn constinit property declarations *****************
// ********** End Function DebugCapsuleSweepPawn constinit property declarations *******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepPawn", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepPawn)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepPawn();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepPawn *******************************

// ********** Begin Class UCheatManager Function DebugCapsuleSweepSize *****************************
struct Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics
{
	struct CheatManager_eventDebugCapsuleSweepSize_Parms
	{
		float HalfHeight;
		float Radius;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Change Trace capsule size **/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Change Trace capsule size *" },
	};
#endif // WITH_METADATA

// ********** Begin Function DebugCapsuleSweepSize constinit property declarations *****************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_HalfHeight;
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Radius;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DebugCapsuleSweepSize constinit property declarations *******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DebugCapsuleSweepSize Property Definitions ****************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::NewProp_HalfHeight = { "HalfHeight", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDebugCapsuleSweepSize_Parms, HalfHeight), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::NewProp_Radius = { "Radius", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDebugCapsuleSweepSize_Parms, Radius), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::NewProp_HalfHeight,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::NewProp_Radius,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::PropPointers) < 2048);
// ********** End Function DebugCapsuleSweepSize Property Definitions ******************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DebugCapsuleSweepSize", 	Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::CheatManager_eventDebugCapsuleSweepSize_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::CheatManager_eventDebugCapsuleSweepSize_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDebugCapsuleSweepSize)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_HalfHeight);
	P_GET_PROPERTY(FFloatProperty,Z_Param_Radius);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DebugCapsuleSweepSize(Z_Param_HalfHeight,Z_Param_Radius);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DebugCapsuleSweepSize *******************************

// ********** Begin Class UCheatManager Function DestroyAll ****************************************
struct Z_Construct_UFunction_UCheatManager_DestroyAll_Statics
{
	struct CheatManager_eventDestroyAll_Parms
	{
		TSubclassOf<AActor> aClass;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Destroy all actors of class aClass */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Destroy all actors of class aClass" },
	};
#endif // WITH_METADATA

// ********** Begin Function DestroyAll constinit property declarations ****************************
	static const UECodeGen_Private::FClassPropertyParams NewProp_aClass;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DestroyAll constinit property declarations ******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DestroyAll Property Definitions ***************************************
const UECodeGen_Private::FClassPropertyParams Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::NewProp_aClass = { "aClass", nullptr, (EPropertyFlags)0x0014000000000080, UECodeGen_Private::EPropertyGenFlags::Class, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDestroyAll_Parms, aClass), Z_Construct_UClass_UClass_NoRegister, Z_Construct_UClass_AActor_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::NewProp_aClass,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::PropPointers) < 2048);
// ********** End Function DestroyAll Property Definitions *****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DestroyAll", 	Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::CheatManager_eventDestroyAll_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::CheatManager_eventDestroyAll_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DestroyAll()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DestroyAll_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDestroyAll)
{
	P_GET_OBJECT(UClass,Z_Param_aClass);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DestroyAll(Z_Param_aClass);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DestroyAll ******************************************

// ********** Begin Class UCheatManager Function DestroyAllPawnsExceptTarget ***********************
struct Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Destroy all pawns except for the (pawn) target.  If no (pawn) target is found we don't destroy anything. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Destroy all pawns except for the (pawn) target.  If no (pawn) target is found we don't destroy anything." },
	};
#endif // WITH_METADATA

// ********** Begin Function DestroyAllPawnsExceptTarget constinit property declarations ***********
// ********** End Function DestroyAllPawnsExceptTarget constinit property declarations *************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DestroyAllPawnsExceptTarget", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDestroyAllPawnsExceptTarget)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DestroyAllPawnsExceptTarget();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DestroyAllPawnsExceptTarget *************************

// ********** Begin Class UCheatManager Function DestroyPawns **************************************
struct Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics
{
	struct CheatManager_eventDestroyPawns_Parms
	{
		TSubclassOf<APawn> aClass;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Destroys (by calling destroy directly) all non-player pawns of class aClass in the level */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Destroys (by calling destroy directly) all non-player pawns of class aClass in the level" },
	};
#endif // WITH_METADATA

// ********** Begin Function DestroyPawns constinit property declarations **************************
	static const UECodeGen_Private::FClassPropertyParams NewProp_aClass;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function DestroyPawns constinit property declarations ****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function DestroyPawns Property Definitions *************************************
const UECodeGen_Private::FClassPropertyParams Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::NewProp_aClass = { "aClass", nullptr, (EPropertyFlags)0x0014000000000080, UECodeGen_Private::EPropertyGenFlags::Class, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventDestroyPawns_Parms, aClass), Z_Construct_UClass_UClass_NoRegister, Z_Construct_UClass_APawn_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::NewProp_aClass,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::PropPointers) < 2048);
// ********** End Function DestroyPawns Property Definitions ***************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DestroyPawns", 	Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::CheatManager_eventDestroyPawns_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::CheatManager_eventDestroyPawns_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_DestroyPawns()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DestroyPawns_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDestroyPawns)
{
	P_GET_OBJECT(UClass,Z_Param_aClass);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DestroyPawns(Z_Param_aClass);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DestroyPawns ****************************************

// ********** Begin Class UCheatManager Function DestroyServerStatReplicator ***********************
struct Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function DestroyServerStatReplicator constinit property declarations ***********
// ********** End Function DestroyServerStatReplicator constinit property declarations *************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DestroyServerStatReplicator", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDestroyServerStatReplicator)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DestroyServerStatReplicator();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DestroyServerStatReplicator *************************

// ********** Begin Class UCheatManager Function DestroyTarget *************************************
struct Z_Construct_UFunction_UCheatManager_DestroyTarget_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Destroy the actor you're looking at. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Destroy the actor you're looking at." },
	};
#endif // WITH_METADATA

// ********** Begin Function DestroyTarget constinit property declarations *************************
// ********** End Function DestroyTarget constinit property declarations ***************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DestroyTarget_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DestroyTarget", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DestroyTarget_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DestroyTarget_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DestroyTarget()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DestroyTarget_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDestroyTarget)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DestroyTarget();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DestroyTarget ***************************************

// ********** Begin Class UCheatManager Function DisableDebugCamera ********************************
struct Z_Construct_UFunction_UCheatManager_DisableDebugCamera_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Switch controller from debug camera back to normal controller */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Switch controller from debug camera back to normal controller" },
	};
#endif // WITH_METADATA

// ********** Begin Function DisableDebugCamera constinit property declarations ********************
// ********** End Function DisableDebugCamera constinit property declarations **********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DisableDebugCamera_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DisableDebugCamera", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04080402, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DisableDebugCamera_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DisableDebugCamera_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DisableDebugCamera()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DisableDebugCamera_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDisableDebugCamera)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DisableDebugCamera();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DisableDebugCamera **********************************

// ********** Begin Class UCheatManager Function DumpChatState *************************************
struct Z_Construct_UFunction_UCheatManager_DumpChatState_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Dump known chat information */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Dump known chat information" },
	};
#endif // WITH_METADATA

// ********** Begin Function DumpChatState constinit property declarations *************************
// ********** End Function DumpChatState constinit property declarations ***************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DumpChatState_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DumpChatState", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DumpChatState_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DumpChatState_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DumpChatState()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DumpChatState_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDumpChatState)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DumpChatState();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DumpChatState ***************************************

// ********** Begin Class UCheatManager Function DumpOnlineSessionState ****************************
struct Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Dump online session information */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Dump online session information" },
	};
#endif // WITH_METADATA

// ********** Begin Function DumpOnlineSessionState constinit property declarations ****************
// ********** End Function DumpOnlineSessionState constinit property declarations ******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DumpOnlineSessionState", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDumpOnlineSessionState)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DumpOnlineSessionState();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DumpOnlineSessionState ******************************

// ********** Begin Class UCheatManager Function DumpPartyState ************************************
struct Z_Construct_UFunction_UCheatManager_DumpPartyState_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Dump known party information */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Dump known party information" },
	};
#endif // WITH_METADATA

// ********** Begin Function DumpPartyState constinit property declarations ************************
// ********** End Function DumpPartyState constinit property declarations **************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DumpPartyState_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DumpPartyState", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DumpPartyState_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DumpPartyState_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DumpPartyState()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DumpPartyState_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDumpPartyState)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DumpPartyState();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DumpPartyState **************************************

// ********** Begin Class UCheatManager Function DumpVoiceMutingState ******************************
struct Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Dump current state of voice chat */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Dump current state of voice chat" },
	};
#endif // WITH_METADATA

// ********** Begin Function DumpVoiceMutingState constinit property declarations ******************
// ********** End Function DumpVoiceMutingState constinit property declarations ********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "DumpVoiceMutingState", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execDumpVoiceMutingState)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->DumpVoiceMutingState();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function DumpVoiceMutingState ********************************

// ********** Begin Class UCheatManager Function EnableDebugCamera *********************************
struct Z_Construct_UFunction_UCheatManager_EnableDebugCamera_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Switch controller to debug camera without locking gameplay and with locking local player controller input */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Switch controller to debug camera without locking gameplay and with locking local player controller input" },
	};
#endif // WITH_METADATA

// ********** Begin Function EnableDebugCamera constinit property declarations *********************
// ********** End Function EnableDebugCamera constinit property declarations ***********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_EnableDebugCamera_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "EnableDebugCamera", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04080402, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_EnableDebugCamera_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_EnableDebugCamera_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_EnableDebugCamera()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_EnableDebugCamera_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execEnableDebugCamera)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->EnableDebugCamera();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function EnableDebugCamera ***********************************

// ********** Begin Class UCheatManager Function FlushLog ******************************************
struct Z_Construct_UFunction_UCheatManager_FlushLog_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** This will force a flush of the output log to file*/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "This will force a flush of the output log to file" },
	};
#endif // WITH_METADATA

// ********** Begin Function FlushLog constinit property declarations ******************************
// ********** End Function FlushLog constinit property declarations ********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_FlushLog_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "FlushLog", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_FlushLog_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_FlushLog_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_FlushLog()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_FlushLog_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execFlushLog)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->FlushLog();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function FlushLog ********************************************

// ********** Begin Class UCheatManager Function Fly ***********************************************
struct Z_Construct_UFunction_UCheatManager_Fly_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Pawn can fly. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Pawn can fly." },
	};
#endif // WITH_METADATA

// ********** Begin Function Fly constinit property declarations ***********************************
// ********** End Function Fly constinit property declarations *************************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Fly_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Fly", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Fly_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Fly_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_Fly()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Fly_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execFly)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Fly();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Fly *************************************************

// ********** Begin Class UCheatManager Function FreezeFrame ***************************************
struct Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics
{
	struct CheatManager_eventFreezeFrame_Parms
	{
		float Delay;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Pause the game for Delay seconds. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Pause the game for Delay seconds." },
	};
#endif // WITH_METADATA

// ********** Begin Function FreezeFrame constinit property declarations ***************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_Delay;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function FreezeFrame constinit property declarations *****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function FreezeFrame Property Definitions **************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::NewProp_Delay = { "Delay", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventFreezeFrame_Parms, Delay), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::NewProp_Delay,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::PropPointers) < 2048);
// ********** End Function FreezeFrame Property Definitions ****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "FreezeFrame", 	Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::CheatManager_eventFreezeFrame_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::CheatManager_eventFreezeFrame_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_FreezeFrame()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_FreezeFrame_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execFreezeFrame)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_Delay);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->FreezeFrame(Z_Param_Delay);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function FreezeFrame *****************************************

// ********** Begin Class UCheatManager Function GetPlayerController *******************************
struct Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics
{
	struct CheatManager_eventGetPlayerController_Parms
	{
		APlayerController* ReturnValue;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function GetPlayerController constinit property declarations *******************
	static const UECodeGen_Private::FObjectPropertyParams NewProp_ReturnValue;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function GetPlayerController constinit property declarations *********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function GetPlayerController Property Definitions ******************************
const UECodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UECodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventGetPlayerController_Parms, ReturnValue), Z_Construct_UClass_APlayerController_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::NewProp_ReturnValue,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::PropPointers) < 2048);
// ********** End Function GetPlayerController Property Definitions ********************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "GetPlayerController", 	Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::CheatManager_eventGetPlayerController_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x54020403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::CheatManager_eventGetPlayerController_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_GetPlayerController()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_GetPlayerController_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execGetPlayerController)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	*(APlayerController**)Z_Param__Result=P_THIS->GetPlayerController();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function GetPlayerController *********************************

// ********** Begin Class UCheatManager Function Ghost *********************************************
struct Z_Construct_UFunction_UCheatManager_Ghost_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Pawn no longer collides with the world, and can fly */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Pawn no longer collides with the world, and can fly" },
	};
#endif // WITH_METADATA

// ********** Begin Function Ghost constinit property declarations *********************************
// ********** End Function Ghost constinit property declarations ***********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Ghost_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Ghost", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Ghost_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Ghost_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_Ghost()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Ghost_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execGhost)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Ghost();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Ghost ***********************************************

// ********** Begin Class UCheatManager Function God ***********************************************
struct Z_Construct_UFunction_UCheatManager_God_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Invulnerability cheat. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Invulnerability cheat." },
	};
#endif // WITH_METADATA

// ********** Begin Function God constinit property declarations ***********************************
// ********** End Function God constinit property declarations *************************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_God_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "God", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_God_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_God_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_God()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_God_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execGod)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->God();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function God *************************************************

// ********** Begin Class UCheatManager Function InvertMouse ***************************************
struct Z_Construct_UFunction_UCheatManager_InvertMouse_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Backwards compatibility exec function for people used to it instead of using InvertAxisKey */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Backwards compatibility exec function for people used to it instead of using InvertAxisKey" },
	};
#endif // WITH_METADATA

// ********** Begin Function InvertMouse constinit property declarations ***************************
// ********** End Function InvertMouse constinit property declarations *****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_InvertMouse_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "InvertMouse", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_InvertMouse_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_InvertMouse_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_InvertMouse()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_InvertMouse_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execInvertMouse)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->InvertMouse();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function InvertMouse *****************************************

// ********** Begin Class UCheatManager Function LogLoc ********************************************
struct Z_Construct_UFunction_UCheatManager_LogLoc_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Logs the current location in bugit format without taking screenshot and further routing. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Logs the current location in bugit format without taking screenshot and further routing." },
	};
#endif // WITH_METADATA

// ********** Begin Function LogLoc constinit property declarations ********************************
// ********** End Function LogLoc constinit property declarations **********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_LogLoc_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "LogLoc", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_LogLoc_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_LogLoc_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_LogLoc()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_LogLoc_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execLogLoc)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->LogLoc();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function LogLoc **********************************************

// ********** Begin Class UCheatManager Function OnlyLoadLevel *************************************
struct Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics
{
	struct CheatManager_eventOnlyLoadLevel_Parms
	{
		FName PackageName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Load the given level. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Load the given level." },
	};
#endif // WITH_METADATA

// ********** Begin Function OnlyLoadLevel constinit property declarations *************************
	static const UECodeGen_Private::FNamePropertyParams NewProp_PackageName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function OnlyLoadLevel constinit property declarations ***************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function OnlyLoadLevel Property Definitions ************************************
const UECodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::NewProp_PackageName = { "PackageName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventOnlyLoadLevel_Parms, PackageName), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::NewProp_PackageName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::PropPointers) < 2048);
// ********** End Function OnlyLoadLevel Property Definitions **************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "OnlyLoadLevel", 	Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::CheatManager_eventOnlyLoadLevel_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::CheatManager_eventOnlyLoadLevel_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_OnlyLoadLevel()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_OnlyLoadLevel_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execOnlyLoadLevel)
{
	P_GET_PROPERTY(FNameProperty,Z_Param_PackageName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->OnlyLoadLevel(Z_Param_PackageName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function OnlyLoadLevel ***************************************

// ********** Begin Class UCheatManager Function OnPlayerEndPlayed *********************************
struct Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics
{
	struct CheatManager_eventOnPlayerEndPlayed_Parms
	{
		AActor* Player;
		TEnumAsByte<EEndPlayReason::Type> EndPlayReason;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function OnPlayerEndPlayed constinit property declarations *********************
	static const UECodeGen_Private::FObjectPropertyParams NewProp_Player;
	static const UECodeGen_Private::FBytePropertyParams NewProp_EndPlayReason;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function OnPlayerEndPlayed constinit property declarations ***********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function OnPlayerEndPlayed Property Definitions ********************************
const UECodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::NewProp_Player = { "Player", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventOnPlayerEndPlayed_Parms, Player), Z_Construct_UClass_AActor_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::NewProp_EndPlayReason = { "EndPlayReason", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventOnPlayerEndPlayed_Parms, EndPlayReason), Z_Construct_UEnum_Engine_EEndPlayReason, METADATA_PARAMS(0, nullptr) }; // 1050143493
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::NewProp_Player,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::NewProp_EndPlayReason,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::PropPointers) < 2048);
// ********** End Function OnPlayerEndPlayed Property Definitions **********************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "OnPlayerEndPlayed", 	Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::CheatManager_eventOnPlayerEndPlayed_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020403, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::CheatManager_eventOnPlayerEndPlayed_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execOnPlayerEndPlayed)
{
	P_GET_OBJECT(AActor,Z_Param_Player);
	P_GET_PROPERTY(FByteProperty,Z_Param_EndPlayReason);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->OnPlayerEndPlayed(Z_Param_Player,EEndPlayReason::Type(Z_Param_EndPlayReason));
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function OnPlayerEndPlayed ***********************************

// ********** Begin Class UCheatManager Function PlayersOnly ***************************************
struct Z_Construct_UFunction_UCheatManager_PlayersOnly_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Freeze everything in the level except for players. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Freeze everything in the level except for players." },
	};
#endif // WITH_METADATA

// ********** Begin Function PlayersOnly constinit property declarations ***************************
// ********** End Function PlayersOnly constinit property declarations *****************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_PlayersOnly_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "PlayersOnly", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_PlayersOnly_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_PlayersOnly_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_PlayersOnly()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_PlayersOnly_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execPlayersOnly)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->PlayersOnly();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function PlayersOnly *****************************************

// ********** Begin Class UCheatManager Function ReceiveEndPlay ************************************
static FName NAME_UCheatManager_ReceiveEndPlay = FName(TEXT("ReceiveEndPlay"));
void UCheatManager::ReceiveEndPlay()
{
	UFunction* Func = FindFunctionChecked(NAME_UCheatManager_ReceiveEndPlay);
	ProcessEvent(Func,NULL);
}
struct Z_Construct_UFunction_UCheatManager_ReceiveEndPlay_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/**\n\x09* This is the End Play event for the CheatManager\n\x09*/" },
		{ "DisplayName", "Shutdown" },
		{ "keywords", "endplay" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "This is the End Play event for the CheatManager" },
	};
#endif // WITH_METADATA

// ********** Begin Function ReceiveEndPlay constinit property declarations ************************
// ********** End Function ReceiveEndPlay constinit property declarations **************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ReceiveEndPlay_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ReceiveEndPlay", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08020802, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ReceiveEndPlay_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ReceiveEndPlay_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ReceiveEndPlay()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ReceiveEndPlay_Statics::FuncParams);
	}
	return ReturnFunction;
}
// ********** End Class UCheatManager Function ReceiveEndPlay **************************************

// ********** Begin Class UCheatManager Function ReceiveInitCheatManager ***************************
static FName NAME_UCheatManager_ReceiveInitCheatManager = FName(TEXT("ReceiveInitCheatManager"));
void UCheatManager::ReceiveInitCheatManager()
{
	UFunction* Func = FindFunctionChecked(NAME_UCheatManager_ReceiveInitCheatManager);
	ProcessEvent(Func,NULL);
}
struct Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** \n\x09* BP implementable event for when CheatManager is created to allow any needed initialization.  \n\x09*/" },
		{ "DisplayName", "Init Cheat Manager" },
		{ "Keywords", "Begin Play" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "BP implementable event for when CheatManager is created to allow any needed initialization." },
	};
#endif // WITH_METADATA

// ********** Begin Function ReceiveInitCheatManager constinit property declarations ***************
// ********** End Function ReceiveInitCheatManager constinit property declarations *****************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ReceiveInitCheatManager", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08020802, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager_Statics::FuncParams);
	}
	return ReturnFunction;
}
// ********** End Class UCheatManager Function ReceiveInitCheatManager *****************************

// ********** Begin Class UCheatManager Function ServerToggleAILogging *****************************
static FName NAME_UCheatManager_ServerToggleAILogging = FName(TEXT("ServerToggleAILogging"));
void UCheatManager::ServerToggleAILogging()
{
	UFunction* Func = FindFunctionChecked(NAME_UCheatManager_ServerToggleAILogging);
	ProcessEvent(Func,NULL);
}
struct Z_Construct_UFunction_UCheatManager_ServerToggleAILogging_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function ServerToggleAILogging constinit property declarations *****************
// ********** End Function ServerToggleAILogging constinit property declarations *******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ServerToggleAILogging_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ServerToggleAILogging", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x80220CC2, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ServerToggleAILogging_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ServerToggleAILogging_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ServerToggleAILogging()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ServerToggleAILogging_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execServerToggleAILogging)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	if (!P_THIS->ServerToggleAILogging_Validate())
	{
		RPC_ValidateFailed(TEXT("ServerToggleAILogging_Validate"));
		return;
	}
	P_THIS->ServerToggleAILogging_Implementation();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ServerToggleAILogging *******************************

// ********** Begin Class UCheatManager Function SetMouseSensitivityToDefault **********************
struct Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Exec function to return the mouse sensitivity to its default value */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Exec function to return the mouse sensitivity to its default value" },
	};
#endif // WITH_METADATA

// ********** Begin Function SetMouseSensitivityToDefault constinit property declarations **********
// ********** End Function SetMouseSensitivityToDefault constinit property declarations ************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "SetMouseSensitivityToDefault", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execSetMouseSensitivityToDefault)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->SetMouseSensitivityToDefault();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function SetMouseSensitivityToDefault ************************

// ********** Begin Class UCheatManager Function SetWorldOrigin ************************************
struct Z_Construct_UFunction_UCheatManager_SetWorldOrigin_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Translate world origin to this player position */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Translate world origin to this player position" },
	};
#endif // WITH_METADATA

// ********** Begin Function SetWorldOrigin constinit property declarations ************************
// ********** End Function SetWorldOrigin constinit property declarations **************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_SetWorldOrigin_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "SetWorldOrigin", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_SetWorldOrigin_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_SetWorldOrigin_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_SetWorldOrigin()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_SetWorldOrigin_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execSetWorldOrigin)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->SetWorldOrigin();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function SetWorldOrigin **************************************

// ********** Begin Class UCheatManager Function Slomo *********************************************
struct Z_Construct_UFunction_UCheatManager_Slomo_Statics
{
	struct CheatManager_eventSlomo_Parms
	{
		float NewTimeDilation;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Modify time dilation to change apparent speed of passage of time. e.g. \"Slomo 0.1\" makes everything move very slowly, while \"Slomo 10\" makes everything move very fast. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Modify time dilation to change apparent speed of passage of time. e.g. \"Slomo 0.1\" makes everything move very slowly, while \"Slomo 10\" makes everything move very fast." },
	};
#endif // WITH_METADATA

// ********** Begin Function Slomo constinit property declarations *********************************
	static const UECodeGen_Private::FFloatPropertyParams NewProp_NewTimeDilation;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function Slomo constinit property declarations ***********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function Slomo Property Definitions ********************************************
const UECodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UCheatManager_Slomo_Statics::NewProp_NewTimeDilation = { "NewTimeDilation", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventSlomo_Parms, NewTimeDilation), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_Slomo_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_Slomo_Statics::NewProp_NewTimeDilation,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Slomo_Statics::PropPointers) < 2048);
// ********** End Function Slomo Property Definitions **********************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Slomo_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Slomo", 	Z_Construct_UFunction_UCheatManager_Slomo_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Slomo_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_Slomo_Statics::CheatManager_eventSlomo_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Slomo_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Slomo_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_Slomo_Statics::CheatManager_eventSlomo_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_Slomo()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Slomo_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execSlomo)
{
	P_GET_PROPERTY(FFloatProperty,Z_Param_NewTimeDilation);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Slomo(Z_Param_NewTimeDilation);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Slomo ***********************************************

// ********** Begin Class UCheatManager Function SpawnServerStatReplicator *************************
struct Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function SpawnServerStatReplicator constinit property declarations *************
// ********** End Function SpawnServerStatReplicator constinit property declarations ***************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "SpawnServerStatReplicator", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execSpawnServerStatReplicator)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->SpawnServerStatReplicator();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function SpawnServerStatReplicator ***************************

// ********** Begin Class UCheatManager Function StreamLevelIn *************************************
struct Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics
{
	struct CheatManager_eventStreamLevelIn_Parms
	{
		FName PackageName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Stream in the given level. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Stream in the given level." },
	};
#endif // WITH_METADATA

// ********** Begin Function StreamLevelIn constinit property declarations *************************
	static const UECodeGen_Private::FNamePropertyParams NewProp_PackageName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function StreamLevelIn constinit property declarations ***************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function StreamLevelIn Property Definitions ************************************
const UECodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::NewProp_PackageName = { "PackageName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventStreamLevelIn_Parms, PackageName), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::NewProp_PackageName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::PropPointers) < 2048);
// ********** End Function StreamLevelIn Property Definitions **************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "StreamLevelIn", 	Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::CheatManager_eventStreamLevelIn_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::CheatManager_eventStreamLevelIn_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_StreamLevelIn()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_StreamLevelIn_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execStreamLevelIn)
{
	P_GET_PROPERTY(FNameProperty,Z_Param_PackageName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->StreamLevelIn(Z_Param_PackageName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function StreamLevelIn ***************************************

// ********** Begin Class UCheatManager Function StreamLevelOut ************************************
struct Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics
{
	struct CheatManager_eventStreamLevelOut_Parms
	{
		FName PackageName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Stream out the given level. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Stream out the given level." },
	};
#endif // WITH_METADATA

// ********** Begin Function StreamLevelOut constinit property declarations ************************
	static const UECodeGen_Private::FNamePropertyParams NewProp_PackageName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function StreamLevelOut constinit property declarations **************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function StreamLevelOut Property Definitions ***********************************
const UECodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::NewProp_PackageName = { "PackageName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventStreamLevelOut_Parms, PackageName), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::NewProp_PackageName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::PropPointers) < 2048);
// ********** End Function StreamLevelOut Property Definitions *************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "StreamLevelOut", 	Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::CheatManager_eventStreamLevelOut_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::CheatManager_eventStreamLevelOut_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_StreamLevelOut()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_StreamLevelOut_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execStreamLevelOut)
{
	P_GET_PROPERTY(FNameProperty,Z_Param_PackageName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->StreamLevelOut(Z_Param_PackageName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function StreamLevelOut **************************************

// ********** Begin Class UCheatManager Function Summon ********************************************
struct Z_Construct_UFunction_UCheatManager_Summon_Statics
{
	struct CheatManager_eventSummon_Parms
	{
		FString ClassName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Load Classname and spawn an actor of that class */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Load Classname and spawn an actor of that class" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_ClassName_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function Summon constinit property declarations ********************************
	static const UECodeGen_Private::FStrPropertyParams NewProp_ClassName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function Summon constinit property declarations **********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function Summon Property Definitions *******************************************
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_Summon_Statics::NewProp_ClassName = { "ClassName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventSummon_Parms, ClassName), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_ClassName_MetaData), NewProp_ClassName_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_Summon_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_Summon_Statics::NewProp_ClassName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Summon_Statics::PropPointers) < 2048);
// ********** End Function Summon Property Definitions *********************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Summon_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Summon", 	Z_Construct_UFunction_UCheatManager_Summon_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Summon_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_Summon_Statics::CheatManager_eventSummon_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Summon_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Summon_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_Summon_Statics::CheatManager_eventSummon_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_Summon()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Summon_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execSummon)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_ClassName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Summon(Z_Param_ClassName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Summon **********************************************

// ********** Begin Class UCheatManager Function Teleport ******************************************
struct Z_Construct_UFunction_UCheatManager_Teleport_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/* Teleport to surface player is looking at. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Teleport to surface player is looking at." },
	};
#endif // WITH_METADATA

// ********** Begin Function Teleport constinit property declarations ******************************
// ********** End Function Teleport constinit property declarations ********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Teleport_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Teleport", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Teleport_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Teleport_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_Teleport()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Teleport_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execTeleport)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Teleport();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Teleport ********************************************

// ********** Begin Class UCheatManager Function TestCollisionDistance *****************************
struct Z_Construct_UFunction_UCheatManager_TestCollisionDistance_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Test all volumes in the world to the player controller's view location**/" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Test all volumes in the world to the player controller's view location*" },
	};
#endif // WITH_METADATA

// ********** Begin Function TestCollisionDistance constinit property declarations *****************
// ********** End Function TestCollisionDistance constinit property declarations *******************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_TestCollisionDistance_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "TestCollisionDistance", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_TestCollisionDistance_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_TestCollisionDistance_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_TestCollisionDistance()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_TestCollisionDistance_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execTestCollisionDistance)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->TestCollisionDistance();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function TestCollisionDistance *******************************

// ********** Begin Class UCheatManager Function ToggleAILogging ***********************************
struct Z_Construct_UFunction_UCheatManager_ToggleAILogging_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** toggles AI logging */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "toggles AI logging" },
	};
#endif // WITH_METADATA

// ********** Begin Function ToggleAILogging constinit property declarations ***********************
// ********** End Function ToggleAILogging constinit property declarations *************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ToggleAILogging_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ToggleAILogging", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ToggleAILogging_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ToggleAILogging_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ToggleAILogging()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ToggleAILogging_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execToggleAILogging)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ToggleAILogging();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ToggleAILogging *************************************

// ********** Begin Class UCheatManager Function ToggleDebugCamera *********************************
struct Z_Construct_UFunction_UCheatManager_ToggleDebugCamera_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Toggle between debug camera/player camera without locking gameplay and with locking local player controller input. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Toggle between debug camera/player camera without locking gameplay and with locking local player controller input." },
	};
#endif // WITH_METADATA

// ********** Begin Function ToggleDebugCamera constinit property declarations *********************
// ********** End Function ToggleDebugCamera constinit property declarations ***********************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ToggleDebugCamera_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ToggleDebugCamera", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ToggleDebugCamera_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ToggleDebugCamera_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ToggleDebugCamera()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ToggleDebugCamera_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execToggleDebugCamera)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ToggleDebugCamera();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ToggleDebugCamera ***********************************

// ********** Begin Class UCheatManager Function ToggleServerStatReplicatorClientOverwrite *********
struct Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function ToggleServerStatReplicatorClientOverwrite constinit property declarations 
// ********** End Function ToggleServerStatReplicatorClientOverwrite constinit property declarations 
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ToggleServerStatReplicatorClientOverwrite", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execToggleServerStatReplicatorClientOverwrite)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ToggleServerStatReplicatorClientOverwrite();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ToggleServerStatReplicatorClientOverwrite ***********

// ********** Begin Class UCheatManager Function ToggleServerStatReplicatorUpdateStatNet ***********
struct Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function ToggleServerStatReplicatorUpdateStatNet constinit property declarations 
// ********** End Function ToggleServerStatReplicatorUpdateStatNet constinit property declarations *
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ToggleServerStatReplicatorUpdateStatNet", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execToggleServerStatReplicatorUpdateStatNet)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ToggleServerStatReplicatorUpdateStatNet();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ToggleServerStatReplicatorUpdateStatNet *************

// ********** Begin Class UCheatManager Function UpdateSafeArea ************************************
struct Z_Construct_UFunction_UCheatManager_UpdateSafeArea_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
	};
#endif // WITH_METADATA

// ********** Begin Function UpdateSafeArea constinit property declarations ************************
// ********** End Function UpdateSafeArea constinit property declarations **************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_UpdateSafeArea_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "UpdateSafeArea", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020603, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_UpdateSafeArea_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_UpdateSafeArea_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_UpdateSafeArea()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_UpdateSafeArea_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execUpdateSafeArea)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->UpdateSafeArea();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function UpdateSafeArea **************************************

// ********** Begin Class UCheatManager Function ViewActor *****************************************
struct Z_Construct_UFunction_UCheatManager_ViewActor_Statics
{
	struct CheatManager_eventViewActor_Parms
	{
		FName ActorName;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** View from the point of view of AActor with Name ActorName. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "View from the point of view of AActor with Name ActorName." },
	};
#endif // WITH_METADATA

// ********** Begin Function ViewActor constinit property declarations *****************************
	static const UECodeGen_Private::FNamePropertyParams NewProp_ActorName;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function ViewActor constinit property declarations *******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function ViewActor Property Definitions ****************************************
const UECodeGen_Private::FNamePropertyParams Z_Construct_UFunction_UCheatManager_ViewActor_Statics::NewProp_ActorName = { "ActorName", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventViewActor_Parms, ActorName), METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_ViewActor_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_ViewActor_Statics::NewProp_ActorName,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewActor_Statics::PropPointers) < 2048);
// ********** End Function ViewActor Property Definitions ******************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ViewActor_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ViewActor", 	Z_Construct_UFunction_UCheatManager_ViewActor_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewActor_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_ViewActor_Statics::CheatManager_eventViewActor_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewActor_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ViewActor_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_ViewActor_Statics::CheatManager_eventViewActor_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_ViewActor()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ViewActor_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execViewActor)
{
	P_GET_PROPERTY(FNameProperty,Z_Param_ActorName);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ViewActor(Z_Param_ActorName);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ViewActor *******************************************

// ********** Begin Class UCheatManager Function ViewClass *****************************************
struct Z_Construct_UFunction_UCheatManager_ViewClass_Statics
{
	struct CheatManager_eventViewClass_Parms
	{
		TSubclassOf<AActor> DesiredClass;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** View from the point of view of an AActor of class DesiredClass.  Each subsequent ViewClass cycles through the list of actors of that class. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "View from the point of view of an AActor of class DesiredClass.  Each subsequent ViewClass cycles through the list of actors of that class." },
	};
#endif // WITH_METADATA

// ********** Begin Function ViewClass constinit property declarations *****************************
	static const UECodeGen_Private::FClassPropertyParams NewProp_DesiredClass;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function ViewClass constinit property declarations *******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function ViewClass Property Definitions ****************************************
const UECodeGen_Private::FClassPropertyParams Z_Construct_UFunction_UCheatManager_ViewClass_Statics::NewProp_DesiredClass = { "DesiredClass", nullptr, (EPropertyFlags)0x0014000000000080, UECodeGen_Private::EPropertyGenFlags::Class, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventViewClass_Parms, DesiredClass), Z_Construct_UClass_UClass_NoRegister, Z_Construct_UClass_AActor_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_ViewClass_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_ViewClass_Statics::NewProp_DesiredClass,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewClass_Statics::PropPointers) < 2048);
// ********** End Function ViewClass Property Definitions ******************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ViewClass_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ViewClass", 	Z_Construct_UFunction_UCheatManager_ViewClass_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewClass_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_ViewClass_Statics::CheatManager_eventViewClass_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewClass_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ViewClass_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_ViewClass_Statics::CheatManager_eventViewClass_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_ViewClass()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ViewClass_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execViewClass)
{
	P_GET_OBJECT(UClass,Z_Param_DesiredClass);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ViewClass(Z_Param_DesiredClass);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ViewClass *******************************************

// ********** Begin Class UCheatManager Function ViewPlayer ****************************************
struct Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics
{
	struct CheatManager_eventViewPlayer_Parms
	{
		FString S;
	};
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** View from the point of view of player with PlayerName S. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "View from the point of view of player with PlayerName S." },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_S_MetaData[] = {
		{ "NativeConst", "" },
	};
#endif // WITH_METADATA

// ********** Begin Function ViewPlayer constinit property declarations ****************************
	static const UECodeGen_Private::FStrPropertyParams NewProp_S;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Function ViewPlayer constinit property declarations ******************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};

// ********** Begin Function ViewPlayer Property Definitions ***************************************
const UECodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::NewProp_S = { "S", nullptr, (EPropertyFlags)0x0010000000000080, UECodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(CheatManager_eventViewPlayer_Parms, S), METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_S_MetaData), NewProp_S_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::NewProp_S,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::PropPointers) < 2048);
// ********** End Function ViewPlayer Property Definitions *****************************************
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ViewPlayer", 	Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::PropPointers, 
	UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::PropPointers), 
sizeof(Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::CheatManager_eventViewPlayer_Parms),
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::Function_MetaDataParams)},  };
static_assert(sizeof(Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::CheatManager_eventViewPlayer_Parms) < MAX_uint16);
UFunction* Z_Construct_UFunction_UCheatManager_ViewPlayer()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ViewPlayer_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execViewPlayer)
{
	P_GET_PROPERTY(FStrProperty,Z_Param_S);
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ViewPlayer(Z_Param_S);
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ViewPlayer ******************************************

// ********** Begin Class UCheatManager Function ViewSelf ******************************************
struct Z_Construct_UFunction_UCheatManager_ViewSelf_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Comment", "/** Make controlled pawn the viewtarget again. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Make controlled pawn the viewtarget again." },
	};
#endif // WITH_METADATA

// ********** Begin Function ViewSelf constinit property declarations ******************************
// ********** End Function ViewSelf constinit property declarations ********************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_ViewSelf_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "ViewSelf", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_ViewSelf_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_ViewSelf_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_ViewSelf()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_ViewSelf_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execViewSelf)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->ViewSelf();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function ViewSelf ********************************************

// ********** Begin Class UCheatManager Function Walk **********************************************
struct Z_Construct_UFunction_UCheatManager_Walk_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Function_MetaDataParams[] = {
		{ "Category", "Cheat Manager" },
		{ "Comment", "/** Return to walking movement mode from Fly or Ghost cheat. */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Return to walking movement mode from Fly or Ghost cheat." },
	};
#endif // WITH_METADATA

// ********** Begin Function Walk constinit property declarations **********************************
// ********** End Function Walk constinit property declarations ************************************
	static const UECodeGen_Private::FFunctionParams FuncParams;
};
const UECodeGen_Private::FFunctionParams Z_Construct_UFunction_UCheatManager_Walk_Statics::FuncParams = { { (UObject*(*)())Z_Construct_UClass_UCheatManager, nullptr, "Walk", 	nullptr, 
	0, 
0,
RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020602, 0, 0, METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UFunction_UCheatManager_Walk_Statics::Function_MetaDataParams), Z_Construct_UFunction_UCheatManager_Walk_Statics::Function_MetaDataParams)},  };
UFunction* Z_Construct_UFunction_UCheatManager_Walk()
{
	static UFunction* ReturnFunction = nullptr;
	if (!ReturnFunction)
	{
		UECodeGen_Private::ConstructUFunction(&ReturnFunction, Z_Construct_UFunction_UCheatManager_Walk_Statics::FuncParams);
	}
	return ReturnFunction;
}
DEFINE_FUNCTION(UCheatManager::execWalk)
{
	P_FINISH;
	P_NATIVE_BEGIN;
	P_THIS->Walk();
	P_NATIVE_END;
}
// ********** End Class UCheatManager Function Walk ************************************************

// ********** Begin Class UCheatManager ************************************************************
FClassRegistrationInfo Z_Registration_Info_UClass_UCheatManager;
UClass* UCheatManager::GetPrivateStaticClass()
{
	using TClass = UCheatManager;
	if (!Z_Registration_Info_UClass_UCheatManager.InnerSingleton)
	{
		GetPrivateStaticClassBody(
			TClass::StaticPackage(),
			TEXT("CheatManager"),
			Z_Registration_Info_UClass_UCheatManager.InnerSingleton,
			StaticRegisterNativesUCheatManager,
			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_UCheatManager.InnerSingleton;
}
UClass* Z_Construct_UClass_UCheatManager_NoRegister()
{
	return UCheatManager::GetPrivateStaticClass();
}
struct Z_Construct_UClass_UCheatManager_Statics
{
#if WITH_METADATA
	static constexpr UECodeGen_Private::FMetaDataPairParam Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "/** \n\x09""Cheat Manager is a central blueprint to implement test and debug code and actions that are not to ship with the game.\n\x09""As the Cheat Manager is not instanced in shipping builds, it is for debugging purposes only\n*/" },
		{ "IncludePath", "GameFramework/CheatManager.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Cheat Manager is a central blueprint to implement test and debug code and actions that are not to ship with the game.\nAs the Cheat Manager is not instanced in shipping builds, it is for debugging purposes only" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DebugCameraControllerRef_MetaData[] = {
		{ "Comment", "/** Debug camera - used to have independent camera without stopping gameplay */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Debug camera - used to have independent camera without stopping gameplay" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_DebugCameraControllerClass_MetaData[] = {
		{ "Category", "Debug Camera" },
		{ "Comment", "/** Debug camera - used to have independent camera without stopping gameplay */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "Debug camera - used to have independent camera without stopping gameplay" },
	};
	static constexpr UECodeGen_Private::FMetaDataPairParam NewProp_CheatManagerExtensions_MetaData[] = {
		{ "Comment", "/** List of registered cheat manager extensions */" },
		{ "ModuleRelativePath", "Classes/GameFramework/CheatManager.h" },
		{ "ToolTip", "List of registered cheat manager extensions" },
	};
#endif // WITH_METADATA

// ********** Begin Class UCheatManager constinit property declarations ****************************
	static const UECodeGen_Private::FObjectPropertyParams NewProp_DebugCameraControllerRef;
	static const UECodeGen_Private::FClassPropertyParams NewProp_DebugCameraControllerClass;
	static const UECodeGen_Private::FObjectPropertyParams NewProp_CheatManagerExtensions_Inner;
	static const UECodeGen_Private::FArrayPropertyParams NewProp_CheatManagerExtensions;
	static const UECodeGen_Private::FPropertyParamsBase* const PropPointers[];
// ********** End Class UCheatManager constinit property declarations ******************************
	static constexpr UE::CodeGen::FClassNativeFunction Funcs[] = {
		{ .NameUTF8 = UTF8TEXT("BugIt"), .Pointer = &UCheatManager::execBugIt },
		{ .NameUTF8 = UTF8TEXT("BugItGo"), .Pointer = &UCheatManager::execBugItGo },
		{ .NameUTF8 = UTF8TEXT("BugItStringCreator"), .Pointer = &UCheatManager::execBugItStringCreator },
		{ .NameUTF8 = UTF8TEXT("ChangeSize"), .Pointer = &UCheatManager::execChangeSize },
		{ .NameUTF8 = UTF8TEXT("CheatScript"), .Pointer = &UCheatManager::execCheatScript },
		{ .NameUTF8 = UTF8TEXT("DamageTarget"), .Pointer = &UCheatManager::execDamageTarget },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweep"), .Pointer = &UCheatManager::execDebugCapsuleSweep },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepCapture"), .Pointer = &UCheatManager::execDebugCapsuleSweepCapture },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepChannel"), .Pointer = &UCheatManager::execDebugCapsuleSweepChannel },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepClear"), .Pointer = &UCheatManager::execDebugCapsuleSweepClear },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepComplex"), .Pointer = &UCheatManager::execDebugCapsuleSweepComplex },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepPawn"), .Pointer = &UCheatManager::execDebugCapsuleSweepPawn },
		{ .NameUTF8 = UTF8TEXT("DebugCapsuleSweepSize"), .Pointer = &UCheatManager::execDebugCapsuleSweepSize },
		{ .NameUTF8 = UTF8TEXT("DestroyAll"), .Pointer = &UCheatManager::execDestroyAll },
		{ .NameUTF8 = UTF8TEXT("DestroyAllPawnsExceptTarget"), .Pointer = &UCheatManager::execDestroyAllPawnsExceptTarget },
		{ .NameUTF8 = UTF8TEXT("DestroyPawns"), .Pointer = &UCheatManager::execDestroyPawns },
		{ .NameUTF8 = UTF8TEXT("DestroyServerStatReplicator"), .Pointer = &UCheatManager::execDestroyServerStatReplicator },
		{ .NameUTF8 = UTF8TEXT("DestroyTarget"), .Pointer = &UCheatManager::execDestroyTarget },
		{ .NameUTF8 = UTF8TEXT("DisableDebugCamera"), .Pointer = &UCheatManager::execDisableDebugCamera },
		{ .NameUTF8 = UTF8TEXT("DumpChatState"), .Pointer = &UCheatManager::execDumpChatState },
		{ .NameUTF8 = UTF8TEXT("DumpOnlineSessionState"), .Pointer = &UCheatManager::execDumpOnlineSessionState },
		{ .NameUTF8 = UTF8TEXT("DumpPartyState"), .Pointer = &UCheatManager::execDumpPartyState },
		{ .NameUTF8 = UTF8TEXT("DumpVoiceMutingState"), .Pointer = &UCheatManager::execDumpVoiceMutingState },
		{ .NameUTF8 = UTF8TEXT("EnableDebugCamera"), .Pointer = &UCheatManager::execEnableDebugCamera },
		{ .NameUTF8 = UTF8TEXT("FlushLog"), .Pointer = &UCheatManager::execFlushLog },
		{ .NameUTF8 = UTF8TEXT("Fly"), .Pointer = &UCheatManager::execFly },
		{ .NameUTF8 = UTF8TEXT("FreezeFrame"), .Pointer = &UCheatManager::execFreezeFrame },
		{ .NameUTF8 = UTF8TEXT("GetPlayerController"), .Pointer = &UCheatManager::execGetPlayerController },
		{ .NameUTF8 = UTF8TEXT("Ghost"), .Pointer = &UCheatManager::execGhost },
		{ .NameUTF8 = UTF8TEXT("God"), .Pointer = &UCheatManager::execGod },
		{ .NameUTF8 = UTF8TEXT("InvertMouse"), .Pointer = &UCheatManager::execInvertMouse },
		{ .NameUTF8 = UTF8TEXT("LogLoc"), .Pointer = &UCheatManager::execLogLoc },
		{ .NameUTF8 = UTF8TEXT("OnlyLoadLevel"), .Pointer = &UCheatManager::execOnlyLoadLevel },
		{ .NameUTF8 = UTF8TEXT("OnPlayerEndPlayed"), .Pointer = &UCheatManager::execOnPlayerEndPlayed },
		{ .NameUTF8 = UTF8TEXT("PlayersOnly"), .Pointer = &UCheatManager::execPlayersOnly },
		{ .NameUTF8 = UTF8TEXT("ServerToggleAILogging"), .Pointer = &UCheatManager::execServerToggleAILogging },
		{ .NameUTF8 = UTF8TEXT("SetMouseSensitivityToDefault"), .Pointer = &UCheatManager::execSetMouseSensitivityToDefault },
		{ .NameUTF8 = UTF8TEXT("SetWorldOrigin"), .Pointer = &UCheatManager::execSetWorldOrigin },
		{ .NameUTF8 = UTF8TEXT("Slomo"), .Pointer = &UCheatManager::execSlomo },
		{ .NameUTF8 = UTF8TEXT("SpawnServerStatReplicator"), .Pointer = &UCheatManager::execSpawnServerStatReplicator },
		{ .NameUTF8 = UTF8TEXT("StreamLevelIn"), .Pointer = &UCheatManager::execStreamLevelIn },
		{ .NameUTF8 = UTF8TEXT("StreamLevelOut"), .Pointer = &UCheatManager::execStreamLevelOut },
		{ .NameUTF8 = UTF8TEXT("Summon"), .Pointer = &UCheatManager::execSummon },
		{ .NameUTF8 = UTF8TEXT("Teleport"), .Pointer = &UCheatManager::execTeleport },
		{ .NameUTF8 = UTF8TEXT("TestCollisionDistance"), .Pointer = &UCheatManager::execTestCollisionDistance },
		{ .NameUTF8 = UTF8TEXT("ToggleAILogging"), .Pointer = &UCheatManager::execToggleAILogging },
		{ .NameUTF8 = UTF8TEXT("ToggleDebugCamera"), .Pointer = &UCheatManager::execToggleDebugCamera },
		{ .NameUTF8 = UTF8TEXT("ToggleServerStatReplicatorClientOverwrite"), .Pointer = &UCheatManager::execToggleServerStatReplicatorClientOverwrite },
		{ .NameUTF8 = UTF8TEXT("ToggleServerStatReplicatorUpdateStatNet"), .Pointer = &UCheatManager::execToggleServerStatReplicatorUpdateStatNet },
		{ .NameUTF8 = UTF8TEXT("UpdateSafeArea"), .Pointer = &UCheatManager::execUpdateSafeArea },
		{ .NameUTF8 = UTF8TEXT("ViewActor"), .Pointer = &UCheatManager::execViewActor },
		{ .NameUTF8 = UTF8TEXT("ViewClass"), .Pointer = &UCheatManager::execViewClass },
		{ .NameUTF8 = UTF8TEXT("ViewPlayer"), .Pointer = &UCheatManager::execViewPlayer },
		{ .NameUTF8 = UTF8TEXT("ViewSelf"), .Pointer = &UCheatManager::execViewSelf },
		{ .NameUTF8 = UTF8TEXT("Walk"), .Pointer = &UCheatManager::execWalk },
	};
	static UObject* (*const DependentSingletons[])();
	static constexpr FClassFunctionLinkInfo FuncInfo[] = {
		{ &Z_Construct_UFunction_UCheatManager_BugIt, "BugIt" }, // 696479565
		{ &Z_Construct_UFunction_UCheatManager_BugItGo, "BugItGo" }, // 3186895037
		{ &Z_Construct_UFunction_UCheatManager_BugItStringCreator, "BugItStringCreator" }, // 2283647169
		{ &Z_Construct_UFunction_UCheatManager_ChangeSize, "ChangeSize" }, // 1153746751
		{ &Z_Construct_UFunction_UCheatManager_CheatScript, "CheatScript" }, // 3924041624
		{ &Z_Construct_UFunction_UCheatManager_DamageTarget, "DamageTarget" }, // 2773303623
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweep, "DebugCapsuleSweep" }, // 2195887251
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepCapture, "DebugCapsuleSweepCapture" }, // 217393698
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepChannel, "DebugCapsuleSweepChannel" }, // 1492736000
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepClear, "DebugCapsuleSweepClear" }, // 3253541788
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepComplex, "DebugCapsuleSweepComplex" }, // 2638648535
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepPawn, "DebugCapsuleSweepPawn" }, // 3318358578
		{ &Z_Construct_UFunction_UCheatManager_DebugCapsuleSweepSize, "DebugCapsuleSweepSize" }, // 3764955321
		{ &Z_Construct_UFunction_UCheatManager_DestroyAll, "DestroyAll" }, // 3303649131
		{ &Z_Construct_UFunction_UCheatManager_DestroyAllPawnsExceptTarget, "DestroyAllPawnsExceptTarget" }, // 4275744498
		{ &Z_Construct_UFunction_UCheatManager_DestroyPawns, "DestroyPawns" }, // 3264462337
		{ &Z_Construct_UFunction_UCheatManager_DestroyServerStatReplicator, "DestroyServerStatReplicator" }, // 3422998993
		{ &Z_Construct_UFunction_UCheatManager_DestroyTarget, "DestroyTarget" }, // 824107221
		{ &Z_Construct_UFunction_UCheatManager_DisableDebugCamera, "DisableDebugCamera" }, // 4037934425
		{ &Z_Construct_UFunction_UCheatManager_DumpChatState, "DumpChatState" }, // 3852148985
		{ &Z_Construct_UFunction_UCheatManager_DumpOnlineSessionState, "DumpOnlineSessionState" }, // 300211620
		{ &Z_Construct_UFunction_UCheatManager_DumpPartyState, "DumpPartyState" }, // 2029005455
		{ &Z_Construct_UFunction_UCheatManager_DumpVoiceMutingState, "DumpVoiceMutingState" }, // 852043963
		{ &Z_Construct_UFunction_UCheatManager_EnableDebugCamera, "EnableDebugCamera" }, // 854545051
		{ &Z_Construct_UFunction_UCheatManager_FlushLog, "FlushLog" }, // 3414529718
		{ &Z_Construct_UFunction_UCheatManager_Fly, "Fly" }, // 1633707420
		{ &Z_Construct_UFunction_UCheatManager_FreezeFrame, "FreezeFrame" }, // 714710679
		{ &Z_Construct_UFunction_UCheatManager_GetPlayerController, "GetPlayerController" }, // 3593683433
		{ &Z_Construct_UFunction_UCheatManager_Ghost, "Ghost" }, // 4039540776
		{ &Z_Construct_UFunction_UCheatManager_God, "God" }, // 1664709628
		{ &Z_Construct_UFunction_UCheatManager_InvertMouse, "InvertMouse" }, // 633773780
		{ &Z_Construct_UFunction_UCheatManager_LogLoc, "LogLoc" }, // 1772818098
		{ &Z_Construct_UFunction_UCheatManager_OnlyLoadLevel, "OnlyLoadLevel" }, // 228560385
		{ &Z_Construct_UFunction_UCheatManager_OnPlayerEndPlayed, "OnPlayerEndPlayed" }, // 1518344717
		{ &Z_Construct_UFunction_UCheatManager_PlayersOnly, "PlayersOnly" }, // 2550664172
		{ &Z_Construct_UFunction_UCheatManager_ReceiveEndPlay, "ReceiveEndPlay" }, // 1509911353
		{ &Z_Construct_UFunction_UCheatManager_ReceiveInitCheatManager, "ReceiveInitCheatManager" }, // 4111296011
		{ &Z_Construct_UFunction_UCheatManager_ServerToggleAILogging, "ServerToggleAILogging" }, // 2203141902
		{ &Z_Construct_UFunction_UCheatManager_SetMouseSensitivityToDefault, "SetMouseSensitivityToDefault" }, // 3841707325
		{ &Z_Construct_UFunction_UCheatManager_SetWorldOrigin, "SetWorldOrigin" }, // 3979843441
		{ &Z_Construct_UFunction_UCheatManager_Slomo, "Slomo" }, // 4270966571
		{ &Z_Construct_UFunction_UCheatManager_SpawnServerStatReplicator, "SpawnServerStatReplicator" }, // 4039358594
		{ &Z_Construct_UFunction_UCheatManager_StreamLevelIn, "StreamLevelIn" }, // 2937527525
		{ &Z_Construct_UFunction_UCheatManager_StreamLevelOut, "StreamLevelOut" }, // 2133216322
		{ &Z_Construct_UFunction_UCheatManager_Summon, "Summon" }, // 2909964176
		{ &Z_Construct_UFunction_UCheatManager_Teleport, "Teleport" }, // 397164106
		{ &Z_Construct_UFunction_UCheatManager_TestCollisionDistance, "TestCollisionDistance" }, // 1166670144
		{ &Z_Construct_UFunction_UCheatManager_ToggleAILogging, "ToggleAILogging" }, // 2081484605
		{ &Z_Construct_UFunction_UCheatManager_ToggleDebugCamera, "ToggleDebugCamera" }, // 161963669
		{ &Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorClientOverwrite, "ToggleServerStatReplicatorClientOverwrite" }, // 518442602
		{ &Z_Construct_UFunction_UCheatManager_ToggleServerStatReplicatorUpdateStatNet, "ToggleServerStatReplicatorUpdateStatNet" }, // 403024926
		{ &Z_Construct_UFunction_UCheatManager_UpdateSafeArea, "UpdateSafeArea" }, // 2497383285
		{ &Z_Construct_UFunction_UCheatManager_ViewActor, "ViewActor" }, // 4105387307
		{ &Z_Construct_UFunction_UCheatManager_ViewClass, "ViewClass" }, // 302038547
		{ &Z_Construct_UFunction_UCheatManager_ViewPlayer, "ViewPlayer" }, // 2450367068
		{ &Z_Construct_UFunction_UCheatManager_ViewSelf, "ViewSelf" }, // 2292630959
		{ &Z_Construct_UFunction_UCheatManager_Walk, "Walk" }, // 1492531491
	};
	static_assert(UE_ARRAY_COUNT(FuncInfo) < 2048);
	static constexpr FCppClassTypeInfoStatic StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UCheatManager>::IsAbstract,
	};
	static const UECodeGen_Private::FClassParams ClassParams;
}; // struct Z_Construct_UClass_UCheatManager_Statics

// ********** Begin Class UCheatManager Property Definitions ***************************************
const UECodeGen_Private::FObjectPropertyParams Z_Construct_UClass_UCheatManager_Statics::NewProp_DebugCameraControllerRef = { "DebugCameraControllerRef", nullptr, (EPropertyFlags)0x0114000000000000, UECodeGen_Private::EPropertyGenFlags::Object | UECodeGen_Private::EPropertyGenFlags::ObjectPtr, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UCheatManager, DebugCameraControllerRef), Z_Construct_UClass_ADebugCameraController_NoRegister, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DebugCameraControllerRef_MetaData), NewProp_DebugCameraControllerRef_MetaData) };
const UECodeGen_Private::FClassPropertyParams Z_Construct_UClass_UCheatManager_Statics::NewProp_DebugCameraControllerClass = { "DebugCameraControllerClass", nullptr, (EPropertyFlags)0x0014000000010015, UECodeGen_Private::EPropertyGenFlags::Class, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UCheatManager, DebugCameraControllerClass), Z_Construct_UClass_UClass_NoRegister, Z_Construct_UClass_ADebugCameraController_NoRegister, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_DebugCameraControllerClass_MetaData), NewProp_DebugCameraControllerClass_MetaData) };
const UECodeGen_Private::FObjectPropertyParams Z_Construct_UClass_UCheatManager_Statics::NewProp_CheatManagerExtensions_Inner = { "CheatManagerExtensions", nullptr, (EPropertyFlags)0x0104000000000000, UECodeGen_Private::EPropertyGenFlags::Object | UECodeGen_Private::EPropertyGenFlags::ObjectPtr, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, 0, Z_Construct_UClass_UCheatManagerExtension_NoRegister, METADATA_PARAMS(0, nullptr) };
const UECodeGen_Private::FArrayPropertyParams Z_Construct_UClass_UCheatManager_Statics::NewProp_CheatManagerExtensions = { "CheatManagerExtensions", nullptr, (EPropertyFlags)0x0124080000002000, UECodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, nullptr, nullptr, 1, STRUCT_OFFSET(UCheatManager, CheatManagerExtensions), EArrayPropertyFlags::None, METADATA_PARAMS(UE_ARRAY_COUNT(NewProp_CheatManagerExtensions_MetaData), NewProp_CheatManagerExtensions_MetaData) };
const UECodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UCheatManager_Statics::PropPointers[] = {
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UCheatManager_Statics::NewProp_DebugCameraControllerRef,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UCheatManager_Statics::NewProp_DebugCameraControllerClass,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UCheatManager_Statics::NewProp_CheatManagerExtensions_Inner,
	(const UECodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UCheatManager_Statics::NewProp_CheatManagerExtensions,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManager_Statics::PropPointers) < 2048);
// ********** End Class UCheatManager Property Definitions *****************************************
UObject* (*const Z_Construct_UClass_UCheatManager_Statics::DependentSingletons[])() = {
	(UObject* (*)())Z_Construct_UClass_UObject,
	(UObject* (*)())Z_Construct_UPackage__Script_Engine,
};
static_assert(UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManager_Statics::DependentSingletons) < 16);
const UECodeGen_Private::FClassParams Z_Construct_UClass_UCheatManager_Statics::ClassParams = {
	&UCheatManager::StaticClass,
	nullptr,
	&StaticCppClassTypeInfo,
	DependentSingletons,
	FuncInfo,
	Z_Construct_UClass_UCheatManager_Statics::PropPointers,
	nullptr,
	UE_ARRAY_COUNT(DependentSingletons),
	UE_ARRAY_COUNT(FuncInfo),
	UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManager_Statics::PropPointers),
	0,
	0x000800A0u,
	METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UClass_UCheatManager_Statics::Class_MetaDataParams), Z_Construct_UClass_UCheatManager_Statics::Class_MetaDataParams)
};
void UCheatManager::StaticRegisterNativesUCheatManager()
{
	UClass* Class = UCheatManager::StaticClass();
	FNativeFunctionRegistrar::RegisterFunctions(Class, MakeConstArrayView(Z_Construct_UClass_UCheatManager_Statics::Funcs));
}
UClass* Z_Construct_UClass_UCheatManager()
{
	if (!Z_Registration_Info_UClass_UCheatManager.OuterSingleton)
	{
		UECodeGen_Private::ConstructUClass(Z_Registration_Info_UClass_UCheatManager.OuterSingleton, Z_Construct_UClass_UCheatManager_Statics::ClassParams);
	}
	return Z_Registration_Info_UClass_UCheatManager.OuterSingleton;
}
DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, UCheatManager);
UCheatManager::~UCheatManager() {}
// ********** End Class UCheatManager **************************************************************

// ********** Begin Registration *******************************************************************
struct Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_GameFramework_CheatManager_h__Script_Engine_Statics
{
	static constexpr FClassRegisterCompiledInInfo ClassInfo[] = {
		{ Z_Construct_UClass_UCheatManagerExtension, UCheatManagerExtension::StaticClass, TEXT("UCheatManagerExtension"), &Z_Registration_Info_UClass_UCheatManagerExtension, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UCheatManagerExtension), 1282223773U) },
		{ Z_Construct_UClass_UCheatManager, UCheatManager::StaticClass, TEXT("UCheatManager"), &Z_Registration_Info_UClass_UCheatManager, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(UCheatManager), 941795323U) },
	};
}; // Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_GameFramework_CheatManager_h__Script_Engine_Statics 
static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_GameFramework_CheatManager_h__Script_Engine_4003865123{
	TEXT("/Script/Engine"),
	Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_GameFramework_CheatManager_h__Script_Engine_Statics::ClassInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_Engine_Source_Runtime_Engine_Classes_GameFramework_CheatManager_h__Script_Engine_Statics::ClassInfo),
	nullptr, 0,
	nullptr, 0,
};
// ********** End Registration *********************************************************************

PRAGMA_ENABLE_DEPRECATION_WARNINGS