aliases.js

try { UObject.prototype.ToText = UObject.prototype.Conv_ObjectToText; } catch (e) {};
try { UObject.prototype.ToString = UObject.prototype.Conv_SoftObjectReferenceToString; } catch (e) {};
try { UObject.prototype.Equal = UObject.prototype.EqualEqual_SoftObjectReference; } catch (e) {};
try { UObject.prototype.ClearTimerbyFunctionName = UObject.prototype.K2_ClearTimer; } catch (e) {};
try { UObject.prototype.GetTimerElapsedTimebyFunctionName = UObject.prototype.K2_GetTimerElapsedTime; } catch (e) {};
try { UObject.prototype.GetTimerRemainingTimebyFunctionName = UObject.prototype.K2_GetTimerRemainingTime; } catch (e) {};
try { UObject.prototype.IsTimerActivebyFunctionName = UObject.prototype.K2_IsTimerActive; } catch (e) {};
try { UObject.prototype.IsTimerPausedbyFunctionName = UObject.prototype.K2_IsTimerPaused; } catch (e) {};
try { UObject.prototype.PauseTimerbyFunctionName = UObject.prototype.K2_PauseTimer; } catch (e) {};
try { UObject.prototype.SetTimerbyFunctionName = UObject.prototype.K2_SetTimer; } catch (e) {};
try { UObject.prototype.DoesTimerExistbyFunctionName = UObject.prototype.K2_TimerExists; } catch (e) {};
try { UObject.prototype.UnpauseTimerbyFunctionName = UObject.prototype.K2_UnPauseTimer; } catch (e) {};
try { UObject.prototype.NotEqual = UObject.prototype.NotEqual_SoftObjectReference; } catch (e) {};
try { UObject.prototype.ToString = UObject.prototype.Conv_ObjectToString; } catch (e) {};
try { UObject.prototype.Equal = UObject.prototype.EqualEqual_ObjectObject; } catch (e) {};
try { UObject.prototype.NotEqual = UObject.prototype.NotEqual_ObjectObject; } catch (e) {};
try { UObject.prototype.GetClass = UObject.prototype.GetObjectClass; } catch (e) {};
try { Class.prototype.ToString = Class.prototype.Conv_SoftClassReferenceToString; } catch (e) {};
try { Class.prototype.Equal = Class.prototype.EqualEqual_SoftClassReference; } catch (e) {};
try { Class.prototype.GetDisplayName = Class.prototype.GetClassDisplayName; } catch (e) {};
try { Class.prototype.NotEqual = Class.prototype.NotEqual_SoftClassReference; } catch (e) {};
try { Class.prototype.Equal = Class.prototype.EqualEqual_ClassClass; } catch (e) {};
try { Class.prototype.NotEqual = Class.prototype.NotEqual_ClassClass; } catch (e) {};
try { let fnprepatch_0 = AssetRegistryHelpers.prototype.CreateAssetData;AssetRegistryHelpers.prototype.CreateAssetData = function (InAsset, bAllowBlueprintClass = false) { return fnprepatch_0.call(this, InAsset, bAllowBlueprintClass) }; } catch (e) {};
try { let fnprepatch_1 = AssetRegistry.prototype.ScanPathsSynchronous;AssetRegistry.prototype.ScanPathsSynchronous = function (InPaths, bForceRescan = false) { return fnprepatch_1.call(this, InPaths, bForceRescan) }; } catch (e) {};
try { let fnprepatch_2 = AssetRegistry.prototype.ScanFilesSynchronous;AssetRegistry.prototype.ScanFilesSynchronous = function (InFilePaths, bForceRescan = false) { return fnprepatch_2.call(this, InFilePaths, bForceRescan) }; } catch (e) {};
try { let fnprepatch_3 = AssetRegistry.prototype.HasAssets;AssetRegistry.prototype.HasAssets = function (PackagePath, bRecursive = false) { return fnprepatch_3.call(this, PackagePath, bRecursive) }; } catch (e) {};
try { let fnprepatch_4 = AssetRegistry.prototype.GetAssetsByPath;AssetRegistry.prototype.GetAssetsByPath = function (PackagePath, OutAssetData, bRecursive = false, bIncludeOnlyOnDiskAssets = false) { return fnprepatch_4.call(this, PackagePath, OutAssetData, bRecursive, bIncludeOnlyOnDiskAssets) }; } catch (e) {};
try { let fnprepatch_5 = AssetRegistry.prototype.GetAssetsByPackageName;AssetRegistry.prototype.GetAssetsByPackageName = function (PackageName, OutAssetData, bIncludeOnlyOnDiskAssets = false) { return fnprepatch_5.call(this, PackageName, OutAssetData, bIncludeOnlyOnDiskAssets) }; } catch (e) {};
try { let fnprepatch_6 = AssetRegistry.prototype.GetAssetsByClass;AssetRegistry.prototype.GetAssetsByClass = function (ClassName, OutAssetData, bSearchSubClasses = false) { return fnprepatch_6.call(this, ClassName, OutAssetData, bSearchSubClasses) }; } catch (e) {};
try { let fnprepatch_7 = AssetRegistry.prototype.GetAssetByObjectPath;AssetRegistry.prototype.GetAssetByObjectPath = function (ObjectPath, bIncludeOnlyOnDiskAssets = false) { return fnprepatch_7.call(this, ObjectPath, bIncludeOnlyOnDiskAssets) }; } catch (e) {};
try { let fnprepatch_8 = AssetRegistry.prototype.GetAllAssets;AssetRegistry.prototype.GetAllAssets = function (OutAssetData, bIncludeOnlyOnDiskAssets = false) { return fnprepatch_8.call(this, OutAssetData, bIncludeOnlyOnDiskAssets) }; } catch (e) {};
try { let fnprepatch_9 = Actor.prototype.WasRecentlyRendered;Actor.prototype.WasRecentlyRendered = function (Tolerance = 0.20000000298023224) { return fnprepatch_9.call(this, Tolerance) }; } catch (e) {};
try { let fnprepatch_10 = Actor.prototype.SetActorLabel;Actor.prototype.SetActorLabel = function (NewActorLabel, bMarkDirty = true) { return fnprepatch_10.call(this, NewActorLabel, bMarkDirty) }; } catch (e) {};
try { let fnprepatch_11 = Actor.prototype.PrestreamTextures;Actor.prototype.PrestreamTextures = function (Seconds, bEnableStreaming, CinematicTextureGroups = 0) { return fnprepatch_11.call(this, Seconds, bEnableStreaming, CinematicTextureGroups) }; } catch (e) {};
try { let fnprepatch_12 = Actor.prototype.MakeNoise;Actor.prototype.MakeNoise = function (Loudness = 1, NoiseInstigator = undefined, NoiseLocation, MaxRange = 0, Tag = "None") { return fnprepatch_12.call(this, Loudness, NoiseInstigator, NoiseLocation, MaxRange, Tag) }; } catch (e) {};
try { let fnprepatch_13 = Actor.prototype.K2_DetachFromActor;Actor.prototype.K2_DetachFromActor = function (LocationRule = "KeepRelative", RotationRule = "KeepRelative", ScaleRule = "KeepRelative") { return fnprepatch_13.call(this, LocationRule, RotationRule, ScaleRule) }; } catch (e) {};
try { let fnprepatch_14 = Actor.prototype.K2_AttachRootComponentToActor;Actor.prototype.K2_AttachRootComponentToActor = function (InParentActor, InSocketName = "None", AttachLocationType = "KeepRelativeOffset", bWeldSimulatedBodies = true) { return fnprepatch_14.call(this, InParentActor, InSocketName, AttachLocationType, bWeldSimulatedBodies) }; } catch (e) {};
try { let fnprepatch_15 = Actor.prototype.K2_AttachRootComponentTo;Actor.prototype.K2_AttachRootComponentTo = function (InParent, InSocketName = "None", AttachLocationType = "KeepRelativeOffset", bWeldSimulatedBodies = true) { return fnprepatch_15.call(this, InParent, InSocketName, AttachLocationType, bWeldSimulatedBodies) }; } catch (e) {};
try { let fnprepatch_16 = Actor.prototype.IsTemporarilyHiddenInEditor;Actor.prototype.IsTemporarilyHiddenInEditor = function (bIncludeParent = false) { return fnprepatch_16.call(this, bIncludeParent) }; } catch (e) {};
try { let fnprepatch_17 = Actor.prototype.GetOverlappingActors;Actor.prototype.GetOverlappingActors = function (OverlappingActors, ClassFilter = null) { return fnprepatch_17.call(this, OverlappingActors, ClassFilter) }; } catch (e) {};
try { let fnprepatch_18 = Actor.prototype.GetAllChildActors;Actor.prototype.GetAllChildActors = function (ChildActors, bIncludeDescendants = true) { return fnprepatch_18.call(this, ChildActors, bIncludeDescendants) }; } catch (e) {};
try { let fnprepatch_19 = Actor.prototype.DetachRootComponentFromParent;Actor.prototype.DetachRootComponentFromParent = function (bMaintainWorldPosition = true) { return fnprepatch_19.call(this, bMaintainWorldPosition) }; } catch (e) {};
try { Actor.prototype.ConstructionScript = Actor.prototype.UserConstructionScript; } catch (e) {};
try { Actor.prototype.SnapActorTo = Actor.prototype.SnapRootComponentTo; } catch (e) {};
try { Actor.prototype.Tick = Actor.prototype.ReceiveTick; } catch (e) {};
try { Actor.prototype.RadialDamage = Actor.prototype.ReceiveRadialDamage; } catch (e) {};
try { Actor.prototype.PointDamage = Actor.prototype.ReceivePointDamage; } catch (e) {};
try { Actor.prototype.Hit = Actor.prototype.ReceiveHit; } catch (e) {};
try { Actor.prototype.EndPlay = Actor.prototype.ReceiveEndPlay; } catch (e) {};
try { Actor.prototype.Destroyed = Actor.prototype.ReceiveDestroyed; } catch (e) {};
try { Actor.prototype.BeginPlay = Actor.prototype.ReceiveBeginPlay; } catch (e) {};
try { Actor.prototype.AnyDamage = Actor.prototype.ReceiveAnyDamage; } catch (e) {};
try { Actor.prototype.ActorOnReleased = Actor.prototype.ReceiveActorOnReleased; } catch (e) {};
try { Actor.prototype.TouchLeave = Actor.prototype.ReceiveActorOnInputTouchLeave; } catch (e) {};
try { Actor.prototype.TouchEnter = Actor.prototype.ReceiveActorOnInputTouchEnter; } catch (e) {};
try { Actor.prototype.EndInputTouch = Actor.prototype.ReceiveActorOnInputTouchEnd; } catch (e) {};
try { Actor.prototype.BeginInputTouch = Actor.prototype.ReceiveActorOnInputTouchBegin; } catch (e) {};
try { Actor.prototype.ActorOnClicked = Actor.prototype.ReceiveActorOnClicked; } catch (e) {};
try { Actor.prototype.ActorEndOverlap = Actor.prototype.ReceiveActorEndOverlap; } catch (e) {};
try { Actor.prototype.ActorEndCursorOver = Actor.prototype.ReceiveActorEndCursorOver; } catch (e) {};
try { Actor.prototype.ActorBeginOverlap = Actor.prototype.ReceiveActorBeginOverlap; } catch (e) {};
try { Actor.prototype.ActorBeginCursorOver = Actor.prototype.ReceiveActorBeginCursorOver; } catch (e) {};
try { Actor.prototype.Teleport = Actor.prototype.K2_TeleportTo; } catch (e) {};
try { Actor.prototype.SetActorTransform = Actor.prototype.K2_SetActorTransform; } catch (e) {};
try { Actor.prototype.SetActorRotation = Actor.prototype.K2_SetActorRotation; } catch (e) {};
try { Actor.prototype.SetActorRelativeTransform = Actor.prototype.K2_SetActorRelativeTransform; } catch (e) {};
try { Actor.prototype.SetActorRelativeRotation = Actor.prototype.K2_SetActorRelativeRotation; } catch (e) {};
try { Actor.prototype.SetActorRelativeLocation = Actor.prototype.K2_SetActorRelativeLocation; } catch (e) {};
try { Actor.prototype.SetActorLocationAndRotation = Actor.prototype.K2_SetActorLocationAndRotation; } catch (e) {};
try { Actor.prototype.SetActorLocation = Actor.prototype.K2_SetActorLocation; } catch (e) {};
try { Actor.prototype.OnReset = Actor.prototype.K2_OnReset; } catch (e) {};
try { Actor.prototype.OnEndViewTarget = Actor.prototype.K2_OnEndViewTarget; } catch (e) {};
try { Actor.prototype.OnBecomeViewTarget = Actor.prototype.K2_OnBecomeViewTarget; } catch (e) {};
try { Actor.prototype.GetActorRotation = Actor.prototype.K2_GetActorRotation; } catch (e) {};
try { Actor.prototype.GetActorLocation = Actor.prototype.K2_GetActorLocation; } catch (e) {};
try { Actor.prototype.DetachFromActor = Actor.prototype.K2_DetachFromActor; } catch (e) {};
try { Actor.prototype.DestroyComponent = Actor.prototype.K2_DestroyComponent; } catch (e) {};
try { Actor.prototype.DestroyActor = Actor.prototype.K2_DestroyActor; } catch (e) {};
try { Actor.prototype.AttachToComponent = Actor.prototype.K2_AttachToComponent; } catch (e) {};
try { Actor.prototype.AttachToActor = Actor.prototype.K2_AttachToActor; } catch (e) {};
try { Actor.prototype.AttachActorToActor = Actor.prototype.K2_AttachRootComponentToActor; } catch (e) {};
try { Actor.prototype.AttachActorToComponent = Actor.prototype.K2_AttachRootComponentTo; } catch (e) {};
try { Actor.prototype.AddActorWorldTransform = Actor.prototype.K2_AddActorWorldTransform; } catch (e) {};
try { Actor.prototype.AddActorWorldRotation = Actor.prototype.K2_AddActorWorldRotation; } catch (e) {};
try { Actor.prototype.AddActorWorldOffset = Actor.prototype.K2_AddActorWorldOffset; } catch (e) {};
try { Actor.prototype.AddActorLocalTransform = Actor.prototype.K2_AddActorLocalTransform; } catch (e) {};
try { Actor.prototype.AddActorLocalRotation = Actor.prototype.K2_AddActorLocalRotation; } catch (e) {};
try { Actor.prototype.AddActorLocalOffset = Actor.prototype.K2_AddActorLocalOffset; } catch (e) {};
try { Actor.prototype.GetActorTransform = Actor.prototype.GetTransform; } catch (e) {};
try { Actor.prototype.DetachActorFromActor = Actor.prototype.DetachRootComponentFromParent; } catch (e) {};
try { let fnprepatch_20 = Widget.prototype.HasMouseCaptureByUser;Widget.prototype.HasMouseCaptureByUser = function (UserIndex, PointerIndex = -1) { return fnprepatch_20.call(this, UserIndex, PointerIndex) }; } catch (e) {};
try { Widget.prototype.HasAnyUserFocusedDescendants = Widget.prototype.HasFocusedDescendants; } catch (e) {};
try { let fnprepatch_21 = UserWidget.prototype.SetPositionInViewport;UserWidget.prototype.SetPositionInViewport = function (Position, bRemoveDPIScale = true) { return fnprepatch_21.call(this, Position, bRemoveDPIScale) }; } catch (e) {};
try { let fnprepatch_22 = UserWidget.prototype.SetPlaybackSpeed;UserWidget.prototype.SetPlaybackSpeed = function (InAnimation, PlaybackSpeed = 1) { return fnprepatch_22.call(this, InAnimation, PlaybackSpeed) }; } catch (e) {};
try { let fnprepatch_23 = UserWidget.prototype.PlayAnimationTimeRange;UserWidget.prototype.PlayAnimationTimeRange = function (InAnimation, StartAtTime = 0, EndAtTime = 0, NumLoopsToPlay = 1, PlayMode = "Forward", PlaybackSpeed = 1) { return fnprepatch_23.call(this, InAnimation, StartAtTime, EndAtTime, NumLoopsToPlay, PlayMode, PlaybackSpeed) }; } catch (e) {};
try { let fnprepatch_24 = UserWidget.prototype.PlayAnimationReverse;UserWidget.prototype.PlayAnimationReverse = function (InAnimation, PlaybackSpeed = 1) { return fnprepatch_24.call(this, InAnimation, PlaybackSpeed) }; } catch (e) {};
try { let fnprepatch_25 = UserWidget.prototype.PlayAnimationForward;UserWidget.prototype.PlayAnimationForward = function (InAnimation, PlaybackSpeed = 1) { return fnprepatch_25.call(this, InAnimation, PlaybackSpeed) }; } catch (e) {};
try { let fnprepatch_26 = UserWidget.prototype.PlayAnimation;UserWidget.prototype.PlayAnimation = function (InAnimation, StartAtTime = 0, NumLoopsToPlay = 1, PlayMode = "Forward", PlaybackSpeed = 1) { return fnprepatch_26.call(this, InAnimation, StartAtTime, NumLoopsToPlay, PlayMode, PlaybackSpeed) }; } catch (e) {};
try { let fnprepatch_27 = UserWidget.prototype.BindToAnimationEvent;UserWidget.prototype.BindToAnimationEvent = function (Animation, Delegate, AnimationEvent, UserTag = "None") { return fnprepatch_27.call(this, Animation, Delegate, AnimationEvent, UserTag) }; } catch (e) {};
try { let fnprepatch_28 = UserWidget.prototype.AddToViewport;UserWidget.prototype.AddToViewport = function (ZOrder = 0) { return fnprepatch_28.call(this, ZOrder) }; } catch (e) {};
try { let fnprepatch_29 = UserWidget.prototype.AddToPlayerScreen;UserWidget.prototype.AddToPlayerScreen = function (ZOrder = 0) { return fnprepatch_29.call(this, ZOrder) }; } catch (e) {};
try { let fnprepatch_30 = ViewportInteractor.prototype.GetLaserPointer;ViewportInteractor.prototype.GetLaserPointer = function (LaserPointerStart, LaserPointerEnd, bEvenIfBlocked = false, LaserLengthOverride = 0) { return fnprepatch_30.call(this, LaserPointerStart, LaserPointerEnd, bEvenIfBlocked, LaserLengthOverride) }; } catch (e) {};
try { ViewportInteractor.prototype.HandleInputKey = ViewportInteractor.prototype.HandleInputKey_BP; } catch (e) {};
try { ViewportInteractor.prototype.HandleInputAxis = ViewportInteractor.prototype.HandleInputAxis_BP; } catch (e) {};
try { let fnprepatch_31 = ActorComponent.prototype.SetActive;ActorComponent.prototype.SetActive = function (bNewActive, bReset = false) { return fnprepatch_31.call(this, bNewActive, bReset) }; } catch (e) {};
try { let fnprepatch_32 = ActorComponent.prototype.Activate;ActorComponent.prototype.Activate = function (bReset = false) { return fnprepatch_32.call(this, bReset) }; } catch (e) {};
try { ActorComponent.prototype.Tick = ActorComponent.prototype.ReceiveTick; } catch (e) {};
try { ActorComponent.prototype.EndPlay = ActorComponent.prototype.ReceiveEndPlay; } catch (e) {};
try { ActorComponent.prototype.BeginPlay = ActorComponent.prototype.ReceiveBeginPlay; } catch (e) {};
try { ActorComponent.prototype.DestroyComponent = ActorComponent.prototype.K2_DestroyComponent; } catch (e) {};
try { ActorComponent.prototype.IsComponentBeingDestroyed = ActorComponent.prototype.IsBeingDestroyed; } catch (e) {};
try { let fnprepatch_33 = SceneComponent.prototype.ToggleVisibility;SceneComponent.prototype.ToggleVisibility = function (bPropagateToChildren = false) { return fnprepatch_33.call(this, bPropagateToChildren) }; } catch (e) {};
try { let fnprepatch_34 = SceneComponent.prototype.SnapTo;SceneComponent.prototype.SnapTo = function (InParent, InSocketName = "None") { return fnprepatch_34.call(this, InParent, InSocketName) }; } catch (e) {};
try { let fnprepatch_35 = SceneComponent.prototype.SetVisibility;SceneComponent.prototype.SetVisibility = function (bNewVisibility, bPropagateToChildren = false) { return fnprepatch_35.call(this, bNewVisibility, bPropagateToChildren) }; } catch (e) {};
try { let fnprepatch_36 = SceneComponent.prototype.SetHiddenInGame;SceneComponent.prototype.SetHiddenInGame = function (NewHidden, bPropagateToChildren = false) { return fnprepatch_36.call(this, NewHidden, bPropagateToChildren) }; } catch (e) {};
try { let fnprepatch_37 = SceneComponent.prototype.SetAbsolute;SceneComponent.prototype.SetAbsolute = function (bNewAbsoluteLocation = false, bNewAbsoluteRotation = false, bNewAbsoluteScale = false) { return fnprepatch_37.call(this, bNewAbsoluteLocation, bNewAbsoluteRotation, bNewAbsoluteScale) }; } catch (e) {};
try { let fnprepatch_38 = SceneComponent.prototype.K2_DetachFromComponent;SceneComponent.prototype.K2_DetachFromComponent = function (LocationRule = "KeepRelative", RotationRule = "KeepRelative", ScaleRule = "KeepRelative", bCallModify = true) { return fnprepatch_38.call(this, LocationRule, RotationRule, ScaleRule, bCallModify) }; } catch (e) {};
try { let fnprepatch_39 = SceneComponent.prototype.K2_AttachTo;SceneComponent.prototype.K2_AttachTo = function (InParent, InSocketName = "None", AttachType = "KeepRelativeOffset", bWeldSimulatedBodies = true) { return fnprepatch_39.call(this, InParent, InSocketName, AttachType, bWeldSimulatedBodies) }; } catch (e) {};
try { let fnprepatch_40 = SceneComponent.prototype.IsSimulatingPhysics;SceneComponent.prototype.IsSimulatingPhysics = function (BoneName = "None") { return fnprepatch_40.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_41 = SceneComponent.prototype.GetSocketTransform;SceneComponent.prototype.GetSocketTransform = function (InSocketName, TransformSpace = "RTS_World") { return fnprepatch_41.call(this, InSocketName, TransformSpace) }; } catch (e) {};
try { let fnprepatch_42 = SceneComponent.prototype.DetachFromParent;SceneComponent.prototype.DetachFromParent = function (bMaintainWorldPosition = false, bCallModify = true) { return fnprepatch_42.call(this, bMaintainWorldPosition, bCallModify) }; } catch (e) {};
try { SceneComponent.prototype.SetWorldTransform = SceneComponent.prototype.K2_SetWorldTransform; } catch (e) {};
try { SceneComponent.prototype.SetWorldRotation = SceneComponent.prototype.K2_SetWorldRotation; } catch (e) {};
try { SceneComponent.prototype.SetWorldLocationAndRotation = SceneComponent.prototype.K2_SetWorldLocationAndRotation; } catch (e) {};
try { SceneComponent.prototype.SetWorldLocation = SceneComponent.prototype.K2_SetWorldLocation; } catch (e) {};
try { SceneComponent.prototype.SetRelativeTransform = SceneComponent.prototype.K2_SetRelativeTransform; } catch (e) {};
try { SceneComponent.prototype.SetRelativeRotation = SceneComponent.prototype.K2_SetRelativeRotation; } catch (e) {};
try { SceneComponent.prototype.SetRelativeLocationAndRotation = SceneComponent.prototype.K2_SetRelativeLocationAndRotation; } catch (e) {};
try { SceneComponent.prototype.SetRelativeLocation = SceneComponent.prototype.K2_SetRelativeLocation; } catch (e) {};
try { SceneComponent.prototype.GetWorldTransform = SceneComponent.prototype.K2_GetComponentToWorld; } catch (e) {};
try { SceneComponent.prototype.GetWorldScale = SceneComponent.prototype.K2_GetComponentScale; } catch (e) {};
try { SceneComponent.prototype.GetWorldRotation = SceneComponent.prototype.K2_GetComponentRotation; } catch (e) {};
try { SceneComponent.prototype.GetWorldLocation = SceneComponent.prototype.K2_GetComponentLocation; } catch (e) {};
try { SceneComponent.prototype.DetachFromComponent = SceneComponent.prototype.K2_DetachFromComponent; } catch (e) {};
try { SceneComponent.prototype.AttachToComponent = SceneComponent.prototype.K2_AttachToComponent; } catch (e) {};
try { SceneComponent.prototype.AttachTo = SceneComponent.prototype.K2_AttachTo; } catch (e) {};
try { SceneComponent.prototype.AddWorldTransform = SceneComponent.prototype.K2_AddWorldTransform; } catch (e) {};
try { SceneComponent.prototype.AddWorldRotation = SceneComponent.prototype.K2_AddWorldRotation; } catch (e) {};
try { SceneComponent.prototype.AddWorldOffset = SceneComponent.prototype.K2_AddWorldOffset; } catch (e) {};
try { SceneComponent.prototype.AddRelativeRotation = SceneComponent.prototype.K2_AddRelativeRotation; } catch (e) {};
try { SceneComponent.prototype.AddRelativeLocation = SceneComponent.prototype.K2_AddRelativeLocation; } catch (e) {};
try { SceneComponent.prototype.AddLocalTransform = SceneComponent.prototype.K2_AddLocalTransform; } catch (e) {};
try { SceneComponent.prototype.AddLocalRotation = SceneComponent.prototype.K2_AddLocalRotation; } catch (e) {};
try { SceneComponent.prototype.AddLocalOffset = SceneComponent.prototype.K2_AddLocalOffset; } catch (e) {};
try { let fnprepatch_43 = PrimitiveComponent.prototype.WakeRigidBody;PrimitiveComponent.prototype.WakeRigidBody = function (BoneName = "None") { return fnprepatch_43.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_44 = PrimitiveComponent.prototype.SetUseCCD;PrimitiveComponent.prototype.SetUseCCD = function (InUseCCD, BoneName = "None") { return fnprepatch_44.call(this, InUseCCD, BoneName) }; } catch (e) {};
try { let fnprepatch_45 = PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocityInRadians;PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocityInRadians = function (NewMaxAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_45.call(this, NewMaxAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_46 = PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocityInDegrees;PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocityInDegrees = function (NewMaxAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_46.call(this, NewMaxAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_47 = PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocity;PrimitiveComponent.prototype.SetPhysicsMaxAngularVelocity = function (NewMaxAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_47.call(this, NewMaxAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_48 = PrimitiveComponent.prototype.SetPhysicsLinearVelocity;PrimitiveComponent.prototype.SetPhysicsLinearVelocity = function (NewVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_48.call(this, NewVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_49 = PrimitiveComponent.prototype.SetPhysicsAngularVelocityInRadians;PrimitiveComponent.prototype.SetPhysicsAngularVelocityInRadians = function (NewAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_49.call(this, NewAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_50 = PrimitiveComponent.prototype.SetPhysicsAngularVelocityInDegrees;PrimitiveComponent.prototype.SetPhysicsAngularVelocityInDegrees = function (NewAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_50.call(this, NewAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_51 = PrimitiveComponent.prototype.SetPhysicsAngularVelocity;PrimitiveComponent.prototype.SetPhysicsAngularVelocity = function (NewAngVel, bAddToCurrent = false, BoneName = "None") { return fnprepatch_51.call(this, NewAngVel, bAddToCurrent, BoneName) }; } catch (e) {};
try { let fnprepatch_52 = PrimitiveComponent.prototype.SetMassScale;PrimitiveComponent.prototype.SetMassScale = function (BoneName = "None", InMassScale = 1) { return fnprepatch_52.call(this, BoneName, InMassScale) }; } catch (e) {};
try { let fnprepatch_53 = PrimitiveComponent.prototype.SetMassOverrideInKg;PrimitiveComponent.prototype.SetMassOverrideInKg = function (BoneName = "None", MassInKg = 1, bOverrideMass = true) { return fnprepatch_53.call(this, BoneName, MassInKg, bOverrideMass) }; } catch (e) {};
try { let fnprepatch_54 = PrimitiveComponent.prototype.SetCenterOfMass;PrimitiveComponent.prototype.SetCenterOfMass = function (CenterOfMassOffset, BoneName = "None") { return fnprepatch_54.call(this, CenterOfMassOffset, BoneName) }; } catch (e) {};
try { let fnprepatch_55 = PrimitiveComponent.prototype.SetBoundsScale;PrimitiveComponent.prototype.SetBoundsScale = function (NewBoundsScale = 1) { return fnprepatch_55.call(this, NewBoundsScale) }; } catch (e) {};
try { let fnprepatch_56 = PrimitiveComponent.prototype.SetAllPhysicsLinearVelocity;PrimitiveComponent.prototype.SetAllPhysicsLinearVelocity = function (NewVel, bAddToCurrent = false) { return fnprepatch_56.call(this, NewVel, bAddToCurrent) }; } catch (e) {};
try { let fnprepatch_57 = PrimitiveComponent.prototype.SetAllPhysicsAngularVelocityInRadians;PrimitiveComponent.prototype.SetAllPhysicsAngularVelocityInRadians = function (NewAngVel, bAddToCurrent = false) { return fnprepatch_57.call(this, NewAngVel, bAddToCurrent) }; } catch (e) {};
try { let fnprepatch_58 = PrimitiveComponent.prototype.SetAllPhysicsAngularVelocityInDegrees;PrimitiveComponent.prototype.SetAllPhysicsAngularVelocityInDegrees = function (NewAngVel, bAddToCurrent = false) { return fnprepatch_58.call(this, NewAngVel, bAddToCurrent) }; } catch (e) {};
try { let fnprepatch_59 = PrimitiveComponent.prototype.SetAllMassScale;PrimitiveComponent.prototype.SetAllMassScale = function (InMassScale = 1) { return fnprepatch_59.call(this, InMassScale) }; } catch (e) {};
try { let fnprepatch_60 = PrimitiveComponent.prototype.ScaleByMomentOfInertia;PrimitiveComponent.prototype.ScaleByMomentOfInertia = function (InputVector, BoneName = "None") { return fnprepatch_60.call(this, InputVector, BoneName) }; } catch (e) {};
try { let fnprepatch_61 = PrimitiveComponent.prototype.PutRigidBodyToSleep;PrimitiveComponent.prototype.PutRigidBodyToSleep = function (BoneName = "None") { return fnprepatch_61.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_62 = PrimitiveComponent.prototype.GetPhysicsLinearVelocityAtPoint;PrimitiveComponent.prototype.GetPhysicsLinearVelocityAtPoint = function (Point, BoneName = "None") { return fnprepatch_62.call(this, Point, BoneName) }; } catch (e) {};
try { let fnprepatch_63 = PrimitiveComponent.prototype.GetPhysicsLinearVelocity;PrimitiveComponent.prototype.GetPhysicsLinearVelocity = function (BoneName = "None") { return fnprepatch_63.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_64 = PrimitiveComponent.prototype.GetPhysicsAngularVelocityInRadians;PrimitiveComponent.prototype.GetPhysicsAngularVelocityInRadians = function (BoneName = "None") { return fnprepatch_64.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_65 = PrimitiveComponent.prototype.GetPhysicsAngularVelocityInDegrees;PrimitiveComponent.prototype.GetPhysicsAngularVelocityInDegrees = function (BoneName = "None") { return fnprepatch_65.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_66 = PrimitiveComponent.prototype.GetPhysicsAngularVelocity;PrimitiveComponent.prototype.GetPhysicsAngularVelocity = function (BoneName = "None") { return fnprepatch_66.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_67 = PrimitiveComponent.prototype.GetOverlappingActors;PrimitiveComponent.prototype.GetOverlappingActors = function (OverlappingActors, ClassFilter = null) { return fnprepatch_67.call(this, OverlappingActors, ClassFilter) }; } catch (e) {};
try { let fnprepatch_68 = PrimitiveComponent.prototype.GetMassScale;PrimitiveComponent.prototype.GetMassScale = function (BoneName = "None") { return fnprepatch_68.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_69 = PrimitiveComponent.prototype.GetInertiaTensor;PrimitiveComponent.prototype.GetInertiaTensor = function (BoneName = "None") { return fnprepatch_69.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_70 = PrimitiveComponent.prototype.GetClosestPointOnCollision;PrimitiveComponent.prototype.GetClosestPointOnCollision = function (Point, OutPointOnBody, BoneName = "None") { return fnprepatch_70.call(this, Point, OutPointOnBody, BoneName) }; } catch (e) {};
try { let fnprepatch_71 = PrimitiveComponent.prototype.GetCenterOfMass;PrimitiveComponent.prototype.GetCenterOfMass = function (BoneName = "None") { return fnprepatch_71.call(this, BoneName) }; } catch (e) {};
try { let fnprepatch_72 = PrimitiveComponent.prototype.CreateDynamicMaterialInstance;PrimitiveComponent.prototype.CreateDynamicMaterialInstance = function (ElementIndex, SourceMaterial = undefined, OptionalName = "None") { return fnprepatch_72.call(this, ElementIndex, SourceMaterial, OptionalName) }; } catch (e) {};
try { let fnprepatch_73 = PrimitiveComponent.prototype.AddTorqueInRadians;PrimitiveComponent.prototype.AddTorqueInRadians = function (Torque, BoneName = "None", bAccelChange = false) { return fnprepatch_73.call(this, Torque, BoneName, bAccelChange) }; } catch (e) {};
try { let fnprepatch_74 = PrimitiveComponent.prototype.AddTorqueInDegrees;PrimitiveComponent.prototype.AddTorqueInDegrees = function (Torque, BoneName = "None", bAccelChange = false) { return fnprepatch_74.call(this, Torque, BoneName, bAccelChange) }; } catch (e) {};
try { let fnprepatch_75 = PrimitiveComponent.prototype.AddTorque;PrimitiveComponent.prototype.AddTorque = function (Torque, BoneName = "None", bAccelChange = false) { return fnprepatch_75.call(this, Torque, BoneName, bAccelChange) }; } catch (e) {};
try { let fnprepatch_76 = PrimitiveComponent.prototype.AddRadialImpulse;PrimitiveComponent.prototype.AddRadialImpulse = function (Origin, Radius, Strength, Falloff, bVelChange = false) { return fnprepatch_76.call(this, Origin, Radius, Strength, Falloff, bVelChange) }; } catch (e) {};
try { let fnprepatch_77 = PrimitiveComponent.prototype.AddRadialForce;PrimitiveComponent.prototype.AddRadialForce = function (Origin, Radius, Strength, Falloff, bAccelChange = false) { return fnprepatch_77.call(this, Origin, Radius, Strength, Falloff, bAccelChange) }; } catch (e) {};
try { let fnprepatch_78 = PrimitiveComponent.prototype.AddImpulseAtLocation;PrimitiveComponent.prototype.AddImpulseAtLocation = function (Impulse, Location, BoneName = "None") { return fnprepatch_78.call(this, Impulse, Location, BoneName) }; } catch (e) {};
try { let fnprepatch_79 = PrimitiveComponent.prototype.AddImpulse;PrimitiveComponent.prototype.AddImpulse = function (Impulse, BoneName = "None", bVelChange = false) { return fnprepatch_79.call(this, Impulse, BoneName, bVelChange) }; } catch (e) {};
try { let fnprepatch_80 = PrimitiveComponent.prototype.AddForceAtLocationLocal;PrimitiveComponent.prototype.AddForceAtLocationLocal = function (Force, Location, BoneName = "None") { return fnprepatch_80.call(this, Force, Location, BoneName) }; } catch (e) {};
try { let fnprepatch_81 = PrimitiveComponent.prototype.AddForceAtLocation;PrimitiveComponent.prototype.AddForceAtLocation = function (Force, Location, BoneName = "None") { return fnprepatch_81.call(this, Force, Location, BoneName) }; } catch (e) {};
try { let fnprepatch_82 = PrimitiveComponent.prototype.AddForce;PrimitiveComponent.prototype.AddForce = function (Force, BoneName = "None", bAccelChange = false) { return fnprepatch_82.call(this, Force, BoneName, bAccelChange) }; } catch (e) {};
try { let fnprepatch_83 = PrimitiveComponent.prototype.AddAngularImpulseInRadians;PrimitiveComponent.prototype.AddAngularImpulseInRadians = function (Impulse, BoneName = "None", bVelChange = false) { return fnprepatch_83.call(this, Impulse, BoneName, bVelChange) }; } catch (e) {};
try { let fnprepatch_84 = PrimitiveComponent.prototype.AddAngularImpulseInDegrees;PrimitiveComponent.prototype.AddAngularImpulseInDegrees = function (Impulse, BoneName = "None", bVelChange = false) { return fnprepatch_84.call(this, Impulse, BoneName, bVelChange) }; } catch (e) {};
try { let fnprepatch_85 = PrimitiveComponent.prototype.AddAngularImpulse;PrimitiveComponent.prototype.AddAngularImpulse = function (Impulse, BoneName = "None", bVelChange = false) { return fnprepatch_85.call(this, Impulse, BoneName, bVelChange) }; } catch (e) {};
try { PrimitiveComponent.prototype.SetPhysicalMaterialOverride = PrimitiveComponent.prototype.SetPhysMaterialOverride; } catch (e) {};
try { PrimitiveComponent.prototype.SetMaxDrawDistance = PrimitiveComponent.prototype.SetCullDistance; } catch (e) {};
try { PrimitiveComponent.prototype.SphereTraceComponent = PrimitiveComponent.prototype.K2_SphereTraceComponent; } catch (e) {};
try { PrimitiveComponent.prototype.SphereOverlapComponent = PrimitiveComponent.prototype.K2_SphereOverlapComponent; } catch (e) {};
try { PrimitiveComponent.prototype.LineTraceComponent = PrimitiveComponent.prototype.K2_LineTraceComponent; } catch (e) {};
try { PrimitiveComponent.prototype.IsQueryCollisionEnabled = PrimitiveComponent.prototype.K2_IsQueryCollisionEnabled; } catch (e) {};
try { PrimitiveComponent.prototype.IsPhysicsCollisionEnabled = PrimitiveComponent.prototype.K2_IsPhysicsCollisionEnabled; } catch (e) {};
try { PrimitiveComponent.prototype.IsCollisionEnabled = PrimitiveComponent.prototype.K2_IsCollisionEnabled; } catch (e) {};
try { PrimitiveComponent.prototype.BoxOverlapComponent = PrimitiveComponent.prototype.K2_BoxOverlapComponent; } catch (e) {};
try { PrimitiveComponent.prototype.CreateMIDForElementFromMaterial = PrimitiveComponent.prototype.CreateAndSetMaterialInstanceDynamicFromMaterial; } catch (e) {};
try { PrimitiveComponent.prototype.CreateMIDForElement = PrimitiveComponent.prototype.CreateAndSetMaterialInstanceDynamic; } catch (e) {};
try { PrimitiveComponent.prototype.GetMoveIgnoreComponents = PrimitiveComponent.prototype.CopyArrayOfMoveIgnoreComponents; } catch (e) {};
try { PrimitiveComponent.prototype.GetMoveIgnoreActors = PrimitiveComponent.prototype.CopyArrayOfMoveIgnoreActors; } catch (e) {};
try { let fnprepatch_86 = MeshComponent.prototype.PrestreamTextures;MeshComponent.prototype.PrestreamTextures = function (Seconds, bPrioritizeCharacterTextures, CinematicTextureGroups = 0) { return fnprepatch_86.call(this, Seconds, bPrioritizeCharacterTextures, CinematicTextureGroups) }; } catch (e) {};
try { let fnprepatch_87 = MaterialEditingLibrary.prototype.UpdateMaterialFunction;MaterialEditingLibrary.prototype.UpdateMaterialFunction = function (MaterialFunction, PreviewMaterial = undefined) { return fnprepatch_87.call(this, MaterialFunction, PreviewMaterial) }; } catch (e) {};
try { let fnprepatch_88 = MaterialEditingLibrary.prototype.CreateMaterialExpressionInFunction;MaterialEditingLibrary.prototype.CreateMaterialExpressionInFunction = function (MaterialFunction, ExpressionClass, NodePosX = 0, NodePosY = 0) { return fnprepatch_88.call(this, MaterialFunction, ExpressionClass, NodePosX, NodePosY) }; } catch (e) {};
try { let fnprepatch_89 = MaterialEditingLibrary.prototype.CreateMaterialExpression;MaterialEditingLibrary.prototype.CreateMaterialExpression = function (Material, ExpressionClass, NodePosX = 0, NodePosY = 0) { return fnprepatch_89.call(this, Material, ExpressionClass, NodePosX, NodePosY) }; } catch (e) {};
try { let fnprepatch_90 = ARBlueprintLibrary.prototype.PinComponentToTraceResult;ARBlueprintLibrary.prototype.PinComponentToTraceResult = function (ComponentToPin, TraceResult, DebugName = "None") { return fnprepatch_90.call(this, ComponentToPin, TraceResult, DebugName) }; } catch (e) {};
try { let fnprepatch_91 = ARBlueprintLibrary.prototype.PinComponent;ARBlueprintLibrary.prototype.PinComponent = function (ComponentToPin, PinToWorldTransform, TrackedGeometry = undefined, DebugName = "None") { return fnprepatch_91.call(this, ComponentToPin, PinToWorldTransform, TrackedGeometry, DebugName) }; } catch (e) {};
try { let fnprepatch_92 = ARBlueprintLibrary.prototype.LineTraceTrackedObjects3D;ARBlueprintLibrary.prototype.LineTraceTrackedObjects3D = function (Start, End, bTestFeaturePoints = true, bTestGroundPlane = true, bTestPlaneExtents = true, bTestPlaneBoundaryPolygon = true) { return fnprepatch_92.call(this, Start, End, bTestFeaturePoints, bTestGroundPlane, bTestPlaneExtents, bTestPlaneBoundaryPolygon) }; } catch (e) {};
try { let fnprepatch_93 = ARBlueprintLibrary.prototype.LineTraceTrackedObjects;ARBlueprintLibrary.prototype.LineTraceTrackedObjects = function (ScreenCoord, bTestFeaturePoints = true, bTestGroundPlane = true, bTestPlaneExtents = true, bTestPlaneBoundaryPolygon = true) { return fnprepatch_93.call(this, ScreenCoord, bTestFeaturePoints, bTestGroundPlane, bTestPlaneExtents, bTestPlaneBoundaryPolygon) }; } catch (e) {};
try { let fnprepatch_94 = ARBlueprintLibrary.prototype.DebugDrawTrackedGeometry;ARBlueprintLibrary.prototype.DebugDrawTrackedGeometry = function (TrackedGeometry, WorldContextObject, Color = {"R":1,"G":1,"B":0,"A":0.75}, OutlineThickness = 5, PersistForSeconds = 0) { return fnprepatch_94.call(this, TrackedGeometry, WorldContextObject, Color, OutlineThickness, PersistForSeconds) }; } catch (e) {};
try { let fnprepatch_95 = ARBlueprintLibrary.prototype.DebugDrawPin;ARBlueprintLibrary.prototype.DebugDrawPin = function (ARPin, WorldContextObject, Color = {"R":1,"G":1,"B":0,"A":0.75}, Scale = 5, PersistForSeconds = 0) { return fnprepatch_95.call(this, ARPin, WorldContextObject, Color, Scale, PersistForSeconds) }; } catch (e) {};
try { ARBlueprintLibrary.prototype.SetARAlignmentTransform = ARBlueprintLibrary.prototype.SetAlignmentTransform; } catch (e) {};
try { ARBlueprintLibrary.SetARAlignmentTransform = ARBlueprintLibrary.SetAlignmentTransform; } catch (e) {};
try { ARBlueprintLibrary.prototype.IsARSessionTypeSupported = ARBlueprintLibrary.prototype.IsSessionTypeSupported; } catch (e) {};
try { ARBlueprintLibrary.IsARSessionTypeSupported = ARBlueprintLibrary.IsSessionTypeSupported; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARWorldMappingStatus = ARBlueprintLibrary.prototype.GetWorldMappingStatus; } catch (e) {};
try { ARBlueprintLibrary.GetARWorldMappingStatus = ARBlueprintLibrary.GetWorldMappingStatus; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARTrackingQuality = ARBlueprintLibrary.prototype.GetTrackingQuality; } catch (e) {};
try { ARBlueprintLibrary.GetARTrackingQuality = ARBlueprintLibrary.GetTrackingQuality; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetSupportedARVideoFormats = ARBlueprintLibrary.prototype.GetSupportedVideoFormats; } catch (e) {};
try { ARBlueprintLibrary.GetSupportedARVideoFormats = ARBlueprintLibrary.GetSupportedVideoFormats; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARSessionConfig = ARBlueprintLibrary.prototype.GetSessionConfig; } catch (e) {};
try { ARBlueprintLibrary.GetARSessionConfig = ARBlueprintLibrary.GetSessionConfig; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARPointCloud = ARBlueprintLibrary.prototype.GetPointCloud; } catch (e) {};
try { ARBlueprintLibrary.GetARPointCloud = ARBlueprintLibrary.GetPointCloud; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARCameraImage = ARBlueprintLibrary.prototype.GetCameraImage; } catch (e) {};
try { ARBlueprintLibrary.GetARCameraImage = ARBlueprintLibrary.GetCameraImage; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetARCameraDepth = ARBlueprintLibrary.prototype.GetCameraDepth; } catch (e) {};
try { ARBlueprintLibrary.GetARCameraDepth = ARBlueprintLibrary.GetCameraDepth; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetAllARTrackedPlanes = ARBlueprintLibrary.prototype.GetAllTrackedPlanes; } catch (e) {};
try { ARBlueprintLibrary.GetAllARTrackedPlanes = ARBlueprintLibrary.GetAllTrackedPlanes; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetAllARTrackedImages = ARBlueprintLibrary.prototype.GetAllTrackedImages; } catch (e) {};
try { ARBlueprintLibrary.GetAllARTrackedImages = ARBlueprintLibrary.GetAllTrackedImages; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetAllARTrackedEnvironmentProbes = ARBlueprintLibrary.prototype.GetAllTrackedEnvironmentCaptureProbes; } catch (e) {};
try { ARBlueprintLibrary.GetAllARTrackedEnvironmentProbes = ARBlueprintLibrary.GetAllTrackedEnvironmentCaptureProbes; } catch (e) {};
try { ARBlueprintLibrary.prototype.GetAllARGeometries = ARBlueprintLibrary.prototype.GetAllGeometries; } catch (e) {};
try { ARBlueprintLibrary.GetAllARGeometries = ARBlueprintLibrary.GetAllGeometries; } catch (e) {};
try { ARBlueprintLibrary.prototype.AddAREnvironmentProbe = ARBlueprintLibrary.prototype.AddManualEnvironmentCaptureProbe; } catch (e) {};
try { ARBlueprintLibrary.AddAREnvironmentProbe = ARBlueprintLibrary.AddManualEnvironmentCaptureProbe; } catch (e) {};
try { ARSaveWorldAsyncTaskBlueprintProxy.prototype.SaveARWorld = ARSaveWorldAsyncTaskBlueprintProxy.prototype.ARSaveWorld; } catch (e) {};
try { ARSaveWorldAsyncTaskBlueprintProxy.SaveARWorld = ARSaveWorldAsyncTaskBlueprintProxy.ARSaveWorld; } catch (e) {};
try { ARGetCandidateObjectAsyncTaskBlueprintProxy.prototype.GetARCandidateObject = ARGetCandidateObjectAsyncTaskBlueprintProxy.prototype.ARGetCandidateObject; } catch (e) {};
try { ARGetCandidateObjectAsyncTaskBlueprintProxy.GetARCandidateObject = ARGetCandidateObjectAsyncTaskBlueprintProxy.ARGetCandidateObject; } catch (e) {};
try { GameModeBase.prototype.OnPostLogin = GameModeBase.prototype.K2_PostLogin; } catch (e) {};
try { GameModeBase.prototype.OnSwapPlayerControllers = GameModeBase.prototype.K2_OnSwapPlayerControllers; } catch (e) {};
try { GameModeBase.prototype.OnRestartPlayer = GameModeBase.prototype.K2_OnRestartPlayer; } catch (e) {};
try { GameModeBase.prototype.OnLogout = GameModeBase.prototype.K2_OnLogout; } catch (e) {};
try { GameModeBase.prototype.OnChangeName = GameModeBase.prototype.K2_OnChangeName; } catch (e) {};
try { GameModeBase.prototype.FindPlayerStart = GameModeBase.prototype.K2_FindPlayerStart; } catch (e) {};
try { GameMode.prototype.OnSetMatchState = GameMode.prototype.K2_OnSetMatchState; } catch (e) {};
try { ARSharedWorldGameMode.prototype.SetARPreviewImageData = ARSharedWorldGameMode.prototype.SetPreviewImageData; } catch (e) {};
try { ARSharedWorldGameState.prototype.OnARWorldMapIsReady = ARSharedWorldGameState.prototype.K2_OnARWorldMapIsReady; } catch (e) {};
try { let fnprepatch_96 = Controller.prototype.LineOfSightTo;Controller.prototype.LineOfSightTo = function (Other, ViewPoint, bAlternateChecks = false) { return fnprepatch_96.call(this, Other, ViewPoint, bAlternateChecks) }; } catch (e) {};
try { Controller.prototype.OnUnPossess = Controller.prototype.ReceiveUnPossess; } catch (e) {};
try { Controller.prototype.OnPossess = Controller.prototype.ReceivePossess; } catch (e) {};
try { Controller.prototype.GetControlledPawn = Controller.prototype.K2_GetPawn; } catch (e) {};
try { let fnprepatch_97 = PlayerController.prototype.StartFire;PlayerController.prototype.StartFire = function (FireModeNum = 0) { return fnprepatch_97.call(this, FireModeNum) }; } catch (e) {};
try { let fnprepatch_98 = PlayerController.prototype.SetViewTargetWithBlend;PlayerController.prototype.SetViewTargetWithBlend = function (NewViewTarget, BlendTime = 0, BlendFunc = "VTBlend_Linear", BlendExp = 0, bLockOutgoing = false) { return fnprepatch_98.call(this, NewViewTarget, BlendTime, BlendFunc, BlendExp, bLockOutgoing) }; } catch (e) {};
try { let fnprepatch_99 = PlayerController.prototype.ProjectWorldLocationToScreen;PlayerController.prototype.ProjectWorldLocationToScreen = function (WorldLocation, ScreenLocation, bPlayerViewportRelative = false) { return fnprepatch_99.call(this, WorldLocation, ScreenLocation, bPlayerViewportRelative) }; } catch (e) {};
try { let fnprepatch_100 = PlayerController.prototype.PlayHapticEffect;PlayerController.prototype.PlayHapticEffect = function (HapticEffect, Hand, Scale = 1, bLoop = false) { return fnprepatch_100.call(this, HapticEffect, Hand, Scale, bLoop) }; } catch (e) {};
try { let fnprepatch_101 = PlayerController.prototype.ClientStopCameraShake;PlayerController.prototype.ClientStopCameraShake = function (Shake, bImmediately = true) { return fnprepatch_101.call(this, Shake, bImmediately) }; } catch (e) {};
try { let fnprepatch_102 = PlayerController.prototype.ClientPlayCameraShake;PlayerController.prototype.ClientPlayCameraShake = function (Shake, Scale = 1, PlaySpace = "CameraLocal", UserPlaySpaceRot) { return fnprepatch_102.call(this, Shake, Scale, PlaySpace, UserPlaySpaceRot) }; } catch (e) {};
try { let fnprepatch_103 = PlayerController.prototype.ClientPlayCameraAnim;PlayerController.prototype.ClientPlayCameraAnim = function (AnimToPlay, Scale = 1, Rate = 1, BlendInTime = 0, BlendOutTime = 0, bLoop = false, bRandomStartTime = false, Space = "CameraLocal", CustomPlaySpace) { return fnprepatch_103.call(this, AnimToPlay, Scale, Rate, BlendInTime, BlendOutTime, bLoop, bRandomStartTime, Space, CustomPlaySpace) }; } catch (e) {};
try { PlayerController.prototype.SetInputModeGameAndUI = PlayerController.prototype.SetInputMode_GameAndUI; } catch (e) {};
try { PlayerController.prototype.SetInputModeGameAndUI = PlayerController.prototype.SetInputMode_GameAndUIEx; } catch (e) {};
try { PlayerController.prototype.SetInputModeUIOnly = PlayerController.prototype.SetInputMode_UIOnly; } catch (e) {};
try { PlayerController.prototype.SetInputModeUIOnly = PlayerController.prototype.SetInputMode_UIOnlyEx; } catch (e) {};
try { PlayerController.prototype.SetMousePosition = PlayerController.prototype.SetMouseLocation; } catch (e) {};
try { PlayerController.prototype.ConvertWorldLocationToScreenLocation = PlayerController.prototype.ProjectWorldLocationToScreen; } catch (e) {};
try { PlayerController.prototype.ClientPlayForceFeedback = PlayerController.prototype.K2_ClientPlayForceFeedback; } catch (e) {};
try { PlayerController.prototype.ConvertScreenLocationToWorldSpace = PlayerController.prototype.DeprojectScreenPositionToWorld; } catch (e) {};
try { PlayerController.prototype.ConvertMouseLocationToWorldSpace = PlayerController.prototype.DeprojectMousePositionToWorld; } catch (e) {};
try { let fnprepatch_104 = HeadMountedDisplayFunctionLibrary.prototype.SetWorldToMetersScale;HeadMountedDisplayFunctionLibrary.prototype.SetWorldToMetersScale = function (WorldContext, NewScale = 100) { return fnprepatch_104.call(this, WorldContext, NewScale) }; } catch (e) {};
try { let fnprepatch_105 = HeadMountedDisplayFunctionLibrary.prototype.SetSpectatorScreenModeTexturePlusEyeLayout;HeadMountedDisplayFunctionLibrary.prototype.SetSpectatorScreenModeTexturePlusEyeLayout = function (EyeRectMin, EyeRectMax, TextureRectMin, TextureRectMax, bDrawEyeFirst = true, bClearBlack = false, bUseAlpha = false) { return fnprepatch_105.call(this, EyeRectMin, EyeRectMax, TextureRectMin, TextureRectMax, bDrawEyeFirst, bClearBlack, bUseAlpha) }; } catch (e) {};
try { let fnprepatch_106 = HeadMountedDisplayFunctionLibrary.prototype.ResetOrientationAndPosition;HeadMountedDisplayFunctionLibrary.prototype.ResetOrientationAndPosition = function (Yaw = 0, Options = "OrientationAndPosition") { return fnprepatch_106.call(this, Yaw, Options) }; } catch (e) {};
try { let fnprepatch_107 = HeadMountedDisplayFunctionLibrary.prototype.GetTrackingSensorParameters;HeadMountedDisplayFunctionLibrary.prototype.GetTrackingSensorParameters = function (Origin, Rotation, LeftFOV, RightFOV, TopFOV, BottomFOV, Distance, NearPlane, FarPlane, IsActive, Index = 0) { return fnprepatch_107.call(this, Origin, Rotation, LeftFOV, RightFOV, TopFOV, BottomFOV, Distance, NearPlane, FarPlane, IsActive, Index) }; } catch (e) {};
try { let fnprepatch_108 = HeadMountedDisplayFunctionLibrary.prototype.EnumerateTrackedDevices;HeadMountedDisplayFunctionLibrary.prototype.EnumerateTrackedDevices = function (SystemId = "None", DeviceType = "HeadMountedDisplay") { return fnprepatch_108.call(this, SystemId, DeviceType) }; } catch (e) {};
try { let fnprepatch_109 = GameplayTask_ClaimResource.prototype.ClaimResources;GameplayTask_ClaimResource.prototype.ClaimResources = function (InTaskOwner, ResourceClasses, Priority = 192, TaskInstanceName = "None") { return fnprepatch_109.call(this, InTaskOwner, ResourceClasses, Priority, TaskInstanceName) }; } catch (e) {};
try { let fnprepatch_110 = GameplayTask_ClaimResource.prototype.ClaimResource;GameplayTask_ClaimResource.prototype.ClaimResource = function (InTaskOwner, ResourceClass, Priority = 192, TaskInstanceName = "None") { return fnprepatch_110.call(this, InTaskOwner, ResourceClass, Priority, TaskInstanceName) }; } catch (e) {};
try { let fnprepatch_111 = GameplayTask_SpawnActor.prototype.SpawnActor;GameplayTask_SpawnActor.prototype.SpawnActor = function (TaskOwner, SpawnLocation, SpawnRotation, Class, bSpawnOnlyOnAuthority = false) { return fnprepatch_111.call(this, TaskOwner, SpawnLocation, SpawnRotation, Class, bSpawnOnlyOnAuthority) }; } catch (e) {};
try { let fnprepatch_112 = GameplayTask_WaitDelay.prototype.TaskWaitDelay;GameplayTask_WaitDelay.prototype.TaskWaitDelay = function (TaskOwner, Time, Priority = 192) { return fnprepatch_112.call(this, TaskOwner, Time, Priority) }; } catch (e) {};
try { BlueprintGameplayTagLibrary.prototype.NotEqual = BlueprintGameplayTagLibrary.prototype.NotEqual_GameplayTagContainer; } catch (e) {};
try { BlueprintGameplayTagLibrary.NotEqual = BlueprintGameplayTagLibrary.NotEqual_GameplayTagContainer; } catch (e) {};
try { BlueprintGameplayTagLibrary.prototype.NotEqual = BlueprintGameplayTagLibrary.prototype.NotEqual_GameplayTag; } catch (e) {};
try { BlueprintGameplayTagLibrary.NotEqual = BlueprintGameplayTagLibrary.NotEqual_GameplayTag; } catch (e) {};
try { BlueprintGameplayTagLibrary.prototype.Equal = BlueprintGameplayTagLibrary.prototype.EqualEqual_GameplayTagContainer; } catch (e) {};
try { BlueprintGameplayTagLibrary.Equal = BlueprintGameplayTagLibrary.EqualEqual_GameplayTagContainer; } catch (e) {};
try { BlueprintGameplayTagLibrary.prototype.Equal = BlueprintGameplayTagLibrary.prototype.EqualEqual_GameplayTag; } catch (e) {};
try { BlueprintGameplayTagLibrary.Equal = BlueprintGameplayTagLibrary.EqualEqual_GameplayTag; } catch (e) {};
try { let fnprepatch_113 = AIBlueprintHelperLibrary.prototype.SpawnAIFromClass;AIBlueprintHelperLibrary.prototype.SpawnAIFromClass = function (WorldContextObject, PawnClass, BehaviorTree, Location, Rotation, bNoCollisionFail = false) { return fnprepatch_113.call(this, WorldContextObject, PawnClass, BehaviorTree, Location, Rotation, bNoCollisionFail) }; } catch (e) {};
try { let fnprepatch_114 = AIBlueprintHelperLibrary.prototype.SendAIMessage;AIBlueprintHelperLibrary.prototype.SendAIMessage = function (Target, Message, MessageSource, bSuccess = true) { return fnprepatch_114.call(this, Target, Message, MessageSource, bSuccess) }; } catch (e) {};
try { let fnprepatch_115 = AIBlueprintHelperLibrary.prototype.CreateMoveToProxyObject;AIBlueprintHelperLibrary.prototype.CreateMoveToProxyObject = function (WorldContextObject, Pawn, Destination, TargetActor = undefined, AcceptanceRadius = 5, bStopOnOverlap = false) { return fnprepatch_115.call(this, WorldContextObject, Pawn, Destination, TargetActor, AcceptanceRadius, bStopOnOverlap) }; } catch (e) {};
try { let fnprepatch_116 = AIController.prototype.MoveToLocation;AIController.prototype.MoveToLocation = function (Dest, AcceptanceRadius = -1, bStopOnOverlap = true, bUsePathfinding = true, bProjectDestinationToNavigation = false, bCanStrafe = true, FilterClass = null, bAllowPartialPath = true) { return fnprepatch_116.call(this, Dest, AcceptanceRadius, bStopOnOverlap, bUsePathfinding, bProjectDestinationToNavigation, bCanStrafe, FilterClass, bAllowPartialPath) }; } catch (e) {};
try { let fnprepatch_117 = AIController.prototype.MoveToActor;AIController.prototype.MoveToActor = function (Goal, AcceptanceRadius = -1, bStopOnOverlap = true, bUsePathfinding = true, bCanStrafe = true, FilterClass = null, bAllowPartialPath = true) { return fnprepatch_117.call(this, Goal, AcceptanceRadius, bStopOnOverlap, bUsePathfinding, bCanStrafe, FilterClass, bAllowPartialPath) }; } catch (e) {};
try { AIController.prototype.SetFocus = AIController.prototype.K2_SetFocus; } catch (e) {};
try { AIController.prototype.SetFocalPoint = AIController.prototype.K2_SetFocalPoint; } catch (e) {};
try { AIController.prototype.ClearFocus = AIController.prototype.K2_ClearFocus; } catch (e) {};
try { AISense_Blueprint.prototype.OnNewPawn = AISense_Blueprint.prototype.K2_OnNewPawn; } catch (e) {};
try { let fnprepatch_118 = AISense_Hearing.prototype.ReportNoiseEvent;AISense_Hearing.prototype.ReportNoiseEvent = function (WorldContextObject, NoiseLocation, Loudness = 1, Instigator = undefined, MaxRange = 0, Tag = "None") { return fnprepatch_118.call(this, WorldContextObject, NoiseLocation, Loudness, Instigator, MaxRange, Tag) }; } catch (e) {};
try { let fnprepatch_119 = AITask_MoveTo.prototype.AIMoveTo;AITask_MoveTo.prototype.AIMoveTo = function (Controller, GoalLocation, GoalActor = undefined, AcceptanceRadius = -1, StopOnOverlap = "Default", AcceptPartialPath = "Default", bUsePathfinding = true, bLockAILogic = true, bUseContinuosGoalTracking = false) { return fnprepatch_119.call(this, Controller, GoalLocation, GoalActor, AcceptanceRadius, StopOnOverlap, AcceptPartialPath, bUsePathfinding, bLockAILogic, bUseContinuosGoalTracking) }; } catch (e) {};
try { AITask_MoveTo.prototype.MoveToLocationorActor = AITask_MoveTo.prototype.AIMoveTo; } catch (e) {};
try { AITask_MoveTo.MoveToLocationorActor = AITask_MoveTo.AIMoveTo; } catch (e) {};
try { let fnprepatch_120 = BTTask_BlueprintBase.prototype.SetFinishOnMessageWithId;BTTask_BlueprintBase.prototype.SetFinishOnMessageWithId = function (MessageName, RequestID = -1) { return fnprepatch_120.call(this, MessageName, RequestID) }; } catch (e) {};
try { let fnprepatch_121 = Pawn.prototype.SetCanAffectNavigationGeneration;Pawn.prototype.SetCanAffectNavigationGeneration = function (bNewValue, bForceUpdate = false) { return fnprepatch_121.call(this, bNewValue, bForceUpdate) }; } catch (e) {};
try { let fnprepatch_122 = Pawn.prototype.PawnMakeNoise;Pawn.prototype.PawnMakeNoise = function (Loudness, NoiseLocation, bUseNoiseMakerLocation = true, NoiseMaker = undefined) { return fnprepatch_122.call(this, Loudness, NoiseLocation, bUseNoiseMakerLocation, NoiseMaker) }; } catch (e) {};
try { let fnprepatch_123 = Pawn.prototype.AddMovementInput;Pawn.prototype.AddMovementInput = function (WorldDirection, ScaleValue = 1, bForce = false) { return fnprepatch_123.call(this, WorldDirection, ScaleValue, bForce) }; } catch (e) {};
try { Pawn.prototype.Unpossessed = Pawn.prototype.ReceiveUnpossessed; } catch (e) {};
try { Pawn.prototype.Possessed = Pawn.prototype.ReceivePossessed; } catch (e) {};
try { Pawn.prototype.GetMovementInputVector = Pawn.prototype.K2_GetMovementInputVector; } catch (e) {};
try { let fnprepatch_124 = Character.prototype.UnCrouch;Character.prototype.UnCrouch = function (bClientSimulation = false) { return fnprepatch_124.call(this, bClientSimulation) }; } catch (e) {};
try { let fnprepatch_125 = Character.prototype.StopAnimMontage;Character.prototype.StopAnimMontage = function (AnimMontage = undefined) { return fnprepatch_125.call(this, AnimMontage) }; } catch (e) {};
try { let fnprepatch_126 = Character.prototype.PlayAnimMontage;Character.prototype.PlayAnimMontage = function (AnimMontage, InPlayRate = 1, StartSectionName = "None") { return fnprepatch_126.call(this, AnimMontage, InPlayRate, StartSectionName) }; } catch (e) {};
try { let fnprepatch_127 = Character.prototype.Crouch;Character.prototype.Crouch = function (bClientSimulation = false) { return fnprepatch_127.call(this, bClientSimulation) }; } catch (e) {};
try { Character.prototype.UpdateCustomMovement = Character.prototype.K2_UpdateCustomMovement; } catch (e) {};
try { Character.prototype.OnStartCrouch = Character.prototype.K2_OnStartCrouch; } catch (e) {};
try { Character.prototype.OnMovementModeChanged = Character.prototype.K2_OnMovementModeChanged; } catch (e) {};
try { Character.prototype.OnEndCrouch = Character.prototype.K2_OnEndCrouch; } catch (e) {};
try { Character.prototype.IsPlayingAnimRootMotion = Character.prototype.IsPlayingRootMotion; } catch (e) {};
try { Character.prototype.GetBaseRotationOffset = Character.prototype.GetBaseRotationOffsetRotator; } catch (e) {};
try { Character.prototype.CanJump = Character.prototype.CanJumpInternal; } catch (e) {};
try { let fnprepatch_128 = NavLocalGridManager.prototype.RemoveLocalNavigationGrid;NavLocalGridManager.prototype.RemoveLocalNavigationGrid = function (WorldContextObject, GridId, bRebuildGrids = true) { return fnprepatch_128.call(this, WorldContextObject, GridId, bRebuildGrids) }; } catch (e) {};
try { let fnprepatch_129 = NavLocalGridManager.prototype.AddLocalNavigationGridForPoints;NavLocalGridManager.prototype.AddLocalNavigationGridForPoints = function (WorldContextObject, Locations, Radius2D = 5, Height = 100, bRebuildGrids = true) { return fnprepatch_129.call(this, WorldContextObject, Locations, Radius2D, Height, bRebuildGrids) }; } catch (e) {};
try { let fnprepatch_130 = NavLocalGridManager.prototype.AddLocalNavigationGridForPoint;NavLocalGridManager.prototype.AddLocalNavigationGridForPoint = function (WorldContextObject, Location, Radius2D = 5, Height = 100, bRebuildGrids = true) { return fnprepatch_130.call(this, WorldContextObject, Location, Radius2D, Height, bRebuildGrids) }; } catch (e) {};
try { let fnprepatch_131 = NavLocalGridManager.prototype.AddLocalNavigationGridForCapsule;NavLocalGridManager.prototype.AddLocalNavigationGridForCapsule = function (WorldContextObject, Location, CapsuleRadius, CapsuleHalfHeight, Radius2D = 5, Height = 100, bRebuildGrids = true) { return fnprepatch_131.call(this, WorldContextObject, Location, CapsuleRadius, CapsuleHalfHeight, Radius2D, Height, bRebuildGrids) }; } catch (e) {};
try { let fnprepatch_132 = NavLocalGridManager.prototype.AddLocalNavigationGridForBox;NavLocalGridManager.prototype.AddLocalNavigationGridForBox = function (WorldContextObject, Location, Extent, Rotation, Radius2D = 5, Height = 100, bRebuildGrids = true) { return fnprepatch_132.call(this, WorldContextObject, Location, Extent, Rotation, Radius2D, Height, bRebuildGrids) }; } catch (e) {};
try { let fnprepatch_133 = PawnActionsComponent.prototype.K2_PushAction;PawnActionsComponent.prototype.K2_PushAction = function (NewAction, Priority, Instigator = undefined) { return fnprepatch_133.call(this, NewAction, Priority, Instigator) }; } catch (e) {};
try { let fnprepatch_134 = PawnActionsComponent.prototype.K2_PerformAction;PawnActionsComponent.prototype.K2_PerformAction = function (Pawn, Action, Priority = "HardScript") { return fnprepatch_134.call(this, Pawn, Action, Priority) }; } catch (e) {};
try { PawnActionsComponent.prototype.PushAction = PawnActionsComponent.prototype.K2_PushAction; } catch (e) {};
try { PawnActionsComponent.prototype.PerformAction = PawnActionsComponent.prototype.K2_PerformAction; } catch (e) {};
try { PawnActionsComponent.PerformAction = PawnActionsComponent.K2_PerformAction; } catch (e) {};
try { PawnActionsComponent.prototype.ForceAbortAction = PawnActionsComponent.prototype.K2_ForceAbortAction; } catch (e) {};
try { PawnActionsComponent.prototype.AbortAction = PawnActionsComponent.prototype.K2_AbortAction; } catch (e) {};
try { let fnprepatch_135 = NavigationPath.prototype.EnableDebugDrawing;NavigationPath.prototype.EnableDebugDrawing = function (bShouldDrawDebugData, PathColor = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_135.call(this, bShouldDrawDebugData, PathColor) }; } catch (e) {};
try { World.prototype.VisLogBoxShape = World.prototype.LogBox; } catch (e) {};
try { World.prototype.VisLogLocation = World.prototype.LogLocation; } catch (e) {};
try { World.prototype.VisLogSegment = World.prototype.LogSegment; } catch (e) {};
try { World.prototype.VisLogText = World.prototype.LogText; } catch (e) {};
try { World.prototype.MultiBoxTraceByChannel = World.prototype.BoxTraceMulti; } catch (e) {};
try { World.prototype.MultiBoxTraceByProfile = World.prototype.BoxTraceMultiByProfile; } catch (e) {};
try { World.prototype.MultiBoxTraceForObjects = World.prototype.BoxTraceMultiForObjects; } catch (e) {};
try { World.prototype.BoxTraceByChannel = World.prototype.BoxTraceSingle; } catch (e) {};
try { World.prototype.BoxTraceByProfile = World.prototype.BoxTraceSingleByProfile; } catch (e) {};
try { World.prototype.BoxTraceForObjects = World.prototype.BoxTraceSingleForObjects; } catch (e) {};
try { World.prototype.MultiCapsuleTraceByChannel = World.prototype.CapsuleTraceMulti; } catch (e) {};
try { World.prototype.MultiCapsuleTraceByProfile = World.prototype.CapsuleTraceMultiByProfile; } catch (e) {};
try { World.prototype.MultiCapsuleTraceForObjects = World.prototype.CapsuleTraceMultiForObjects; } catch (e) {};
try { World.prototype.CapsuleTraceByChannel = World.prototype.CapsuleTraceSingle; } catch (e) {};
try { World.prototype.CapsuleTraceByProfile = World.prototype.CapsuleTraceSingleByProfile; } catch (e) {};
try { World.prototype.CapsuleTraceForObjects = World.prototype.CapsuleTraceSingleForObjects; } catch (e) {};
try { World.prototype.DrawDebugCone = World.prototype.DrawDebugConeInDegrees; } catch (e) {};
try { World.prototype.ClearandInvalidateTimerbyHandle = World.prototype.K2_ClearAndInvalidateTimerHandle; } catch (e) {};
try { World.prototype.ClearTimerbyHandle = World.prototype.K2_ClearTimerHandle; } catch (e) {};
try { World.prototype.GetTimerElapsedTimebyHandle = World.prototype.K2_GetTimerElapsedTimeHandle; } catch (e) {};
try { World.prototype.GetTimerRemainingTimebyHandle = World.prototype.K2_GetTimerRemainingTimeHandle; } catch (e) {};
try { World.prototype.IsTimerActivebyHandle = World.prototype.K2_IsTimerActiveHandle; } catch (e) {};
try { World.prototype.IsTimerPausedbyHandle = World.prototype.K2_IsTimerPausedHandle; } catch (e) {};
try { World.prototype.PauseTimerbyHandle = World.prototype.K2_PauseTimerHandle; } catch (e) {};
try { World.prototype.DoesTimerExistbyHandle = World.prototype.K2_TimerExistsHandle; } catch (e) {};
try { World.prototype.UnpauseTimerbyHandle = World.prototype.K2_UnPauseTimerHandle; } catch (e) {};
try { World.prototype.MultiLineTraceByChannel = World.prototype.LineTraceMulti; } catch (e) {};
try { World.prototype.MultiLineTraceByProfile = World.prototype.LineTraceMultiByProfile; } catch (e) {};
try { World.prototype.MultiLineTraceForObjects = World.prototype.LineTraceMultiForObjects; } catch (e) {};
try { World.prototype.LineTraceByChannel = World.prototype.LineTraceSingle; } catch (e) {};
try { World.prototype.LineTraceByProfile = World.prototype.LineTraceSingleByProfile; } catch (e) {};
try { World.prototype.LineTraceForObjects = World.prototype.LineTraceSingleForObjects; } catch (e) {};
try { World.prototype.MultiSphereTraceByChannel = World.prototype.SphereTraceMulti; } catch (e) {};
try { World.prototype.MultiSphereTraceByProfile = World.prototype.SphereTraceMultiByProfile; } catch (e) {};
try { World.prototype.MultiSphereTraceForObjects = World.prototype.SphereTraceMultiForObjects; } catch (e) {};
try { World.prototype.SphereTraceByChannel = World.prototype.SphereTraceSingle; } catch (e) {};
try { World.prototype.SphereTraceByProfile = World.prototype.SphereTraceSingleByProfile; } catch (e) {};
try { World.prototype.SphereTraceForObjects = World.prototype.SphereTraceSingleForObjects; } catch (e) {};
try { World.prototype.PredictProjectilePath = World.prototype.Blueprint_PredictProjectilePath_Advanced; } catch (e) {};
try { World.prototype.PredictProjectilePathByObjectType = World.prototype.Blueprint_PredictProjectilePath_ByObjectType; } catch (e) {};
try { World.prototype.PredictProjectilePathByTraceChannel = World.prototype.Blueprint_PredictProjectilePath_ByTraceChannel; } catch (e) {};
try { World.prototype.SuggestProjectileVelocity = World.prototype.BlueprintSuggestProjectileVelocity; } catch (e) {};
try { World.prototype.SuggestProjectileVelocityCustomArc = World.prototype.SuggestProjectileVelocity_CustomArc; } catch (e) {};
try { World.prototype.CreateWidget = World.prototype.Create; } catch (e) {};
try { World.prototype.ScreenToAbsolute = World.prototype.ScreenToWidgetAbsolute; } catch (e) {};
try { World.prototype.ScreenToLocal = World.prototype.ScreenToWidgetLocal; } catch (e) {};
try { World.prototype.FinishRecordingOutput = World.prototype.StopRecordingOutput; } catch (e) {};
try { World.prototype.GetWorldSettings = World.prototype.K2_GetWorldSettings; } catch (e) {};
try { let fnprepatch_136 = NavigationSystemV1.prototype.RegisterNavigationInvoker;NavigationSystemV1.prototype.RegisterNavigationInvoker = function (Invoker, TileGenerationRadius = 3000, TileRemovalRadius = 5000) { return fnprepatch_136.call(this, Invoker, TileGenerationRadius, TileRemovalRadius) }; } catch (e) {};
try { let fnprepatch_137 = NavigationSystemV1.prototype.ProjectPointToNavigation;NavigationSystemV1.prototype.ProjectPointToNavigation = function (WorldContextObject, Point, NavData = undefined, FilterClass = null, QueryExtent) { return fnprepatch_137.call(this, WorldContextObject, Point, NavData, FilterClass, QueryExtent) }; } catch (e) {};
try { let fnprepatch_138 = NavigationSystemV1.prototype.NavigationRaycast;NavigationSystemV1.prototype.NavigationRaycast = function (WorldContextObject, RayStart, RayEnd, HitLocation, FilterClass = null, Querier = undefined) { return fnprepatch_138.call(this, WorldContextObject, RayStart, RayEnd, HitLocation, FilterClass, Querier) }; } catch (e) {};
try { let fnprepatch_139 = NavigationSystemV1.prototype.K2_GetRandomReachablePointInRadius;NavigationSystemV1.prototype.K2_GetRandomReachablePointInRadius = function (WorldContextObject, Origin, RandomLocation, Radius, NavData = undefined, FilterClass = null) { return fnprepatch_139.call(this, WorldContextObject, Origin, RandomLocation, Radius, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_140 = NavigationSystemV1.prototype.K2_GetRandomPointInNavigableRadius;NavigationSystemV1.prototype.K2_GetRandomPointInNavigableRadius = function (WorldContextObject, Origin, RandomLocation, Radius, NavData = undefined, FilterClass = null) { return fnprepatch_140.call(this, WorldContextObject, Origin, RandomLocation, Radius, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_141 = NavigationSystemV1.prototype.GetRandomReachablePointInRadius;NavigationSystemV1.prototype.GetRandomReachablePointInRadius = function (WorldContextObject, Origin, Radius, NavData = undefined, FilterClass = null) { return fnprepatch_141.call(this, WorldContextObject, Origin, Radius, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_142 = NavigationSystemV1.prototype.GetRandomPointInNavigableRadius;NavigationSystemV1.prototype.GetRandomPointInNavigableRadius = function (WorldContextObject, Origin, Radius, NavData = undefined, FilterClass = null) { return fnprepatch_142.call(this, WorldContextObject, Origin, Radius, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_143 = NavigationSystemV1.prototype.GetPathLength;NavigationSystemV1.prototype.GetPathLength = function (WorldContextObject, PathStart, PathEnd, PathLength, NavData = undefined, FilterClass = null) { return fnprepatch_143.call(this, WorldContextObject, PathStart, PathEnd, PathLength, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_144 = NavigationSystemV1.prototype.GetPathCost;NavigationSystemV1.prototype.GetPathCost = function (WorldContextObject, PathStart, PathEnd, PathCost, NavData = undefined, FilterClass = null) { return fnprepatch_144.call(this, WorldContextObject, PathStart, PathEnd, PathCost, NavData, FilterClass) }; } catch (e) {};
try { let fnprepatch_145 = NavigationSystemV1.prototype.FindPathToLocationSynchronously;NavigationSystemV1.prototype.FindPathToLocationSynchronously = function (WorldContextObject, PathStart, PathEnd, PathfindingContext = undefined, FilterClass = null) { return fnprepatch_145.call(this, WorldContextObject, PathStart, PathEnd, PathfindingContext, FilterClass) }; } catch (e) {};
try { let fnprepatch_146 = NavigationSystemV1.prototype.FindPathToActorSynchronously;NavigationSystemV1.prototype.FindPathToActorSynchronously = function (WorldContextObject, PathStart, GoalActor, TetherDistance = 50, PathfindingContext = undefined, FilterClass = null) { return fnprepatch_146.call(this, WorldContextObject, PathStart, GoalActor, TetherDistance, PathfindingContext, FilterClass) }; } catch (e) {};
try { NavigationSystemV1.prototype.SimpleMoveToLocation_DEPRECATED = NavigationSystemV1.prototype.SimpleMoveToLocation; } catch (e) {};
try { NavigationSystemV1.SimpleMoveToLocation_DEPRECATED = NavigationSystemV1.SimpleMoveToLocation; } catch (e) {};
try { NavigationSystemV1.prototype.SimpleMoveToActor_DEPRECATED = NavigationSystemV1.prototype.SimpleMoveToActor; } catch (e) {};
try { NavigationSystemV1.SimpleMoveToActor_DEPRECATED = NavigationSystemV1.SimpleMoveToActor; } catch (e) {};
try { NavigationSystemV1.prototype.ProjectPointToNavigation_DEPRECATED = NavigationSystemV1.prototype.ProjectPointToNavigation; } catch (e) {};
try { NavigationSystemV1.ProjectPointToNavigation_DEPRECATED = NavigationSystemV1.ProjectPointToNavigation; } catch (e) {};
try { NavigationSystemV1.prototype.ProjectPointToNavigation = NavigationSystemV1.prototype.K2_ProjectPointToNavigation; } catch (e) {};
try { NavigationSystemV1.ProjectPointToNavigation = NavigationSystemV1.K2_ProjectPointToNavigation; } catch (e) {};
try { NavigationSystemV1.prototype.GetRandomReachablePointInRadius = NavigationSystemV1.prototype.K2_GetRandomReachablePointInRadius; } catch (e) {};
try { NavigationSystemV1.GetRandomReachablePointInRadius = NavigationSystemV1.K2_GetRandomReachablePointInRadius; } catch (e) {};
try { NavigationSystemV1.prototype.GetRandomPointInNavigableRadius = NavigationSystemV1.prototype.K2_GetRandomPointInNavigableRadius; } catch (e) {};
try { NavigationSystemV1.GetRandomPointInNavigableRadius = NavigationSystemV1.K2_GetRandomPointInNavigableRadius; } catch (e) {};
try { NavigationSystemV1.prototype.GetRandomReachablePointInRadius_DEPRECATED = NavigationSystemV1.prototype.GetRandomReachablePointInRadius; } catch (e) {};
try { NavigationSystemV1.GetRandomReachablePointInRadius_DEPRECATED = NavigationSystemV1.GetRandomReachablePointInRadius; } catch (e) {};
try { NavigationSystemV1.prototype.GetRandomPointInNavigableRadius_DEPRECATED = NavigationSystemV1.prototype.GetRandomPointInNavigableRadius; } catch (e) {};
try { NavigationSystemV1.GetRandomPointInNavigableRadius_DEPRECATED = NavigationSystemV1.GetRandomPointInNavigableRadius; } catch (e) {};
try { let fnprepatch_147 = NavModifierVolume.prototype.SetAreaClass;NavModifierVolume.prototype.SetAreaClass = function (NewAreaClass = null) { return fnprepatch_147.call(this, NewAreaClass) }; } catch (e) {};
try { let fnprepatch_148 = UserDefinedImageCaptureProtocol.prototype.WriteImageToDisk;UserDefinedImageCaptureProtocol.prototype.WriteImageToDisk = function (PixelData, StreamID, FrameMetrics, bCopyImageData = false) { return fnprepatch_148.call(this, PixelData, StreamID, FrameMetrics, bCopyImageData) }; } catch (e) {};
try { let fnprepatch_149 = CameraComponent.prototype.AddOrUpdateBlendable;CameraComponent.prototype.AddOrUpdateBlendable = function (InBlendableObject, InWeight = 1) { return fnprepatch_149.call(this, InBlendableObject, InWeight) }; } catch (e) {};
try { let fnprepatch_150 = AudioMixerBlueprintLibrary.prototype.StopRecordingOutput;AudioMixerBlueprintLibrary.prototype.StopRecordingOutput = function (WorldContextObject, ExportType, Name, Path, SubmixToRecord = undefined, ExistingSoundWaveToOverwrite = undefined) { return fnprepatch_150.call(this, WorldContextObject, ExportType, Name, Path, SubmixToRecord, ExistingSoundWaveToOverwrite) }; } catch (e) {};
try { let fnprepatch_151 = AudioMixerBlueprintLibrary.prototype.StopAnalyzingOutput;AudioMixerBlueprintLibrary.prototype.StopAnalyzingOutput = function (WorldContextObject, SubmixToStopAnalyzing = undefined) { return fnprepatch_151.call(this, WorldContextObject, SubmixToStopAnalyzing) }; } catch (e) {};
try { let fnprepatch_152 = AudioMixerBlueprintLibrary.prototype.StartRecordingOutput;AudioMixerBlueprintLibrary.prototype.StartRecordingOutput = function (WorldContextObject, ExpectedDuration, SubmixToRecord = undefined) { return fnprepatch_152.call(this, WorldContextObject, ExpectedDuration, SubmixToRecord) }; } catch (e) {};
try { let fnprepatch_153 = AudioMixerBlueprintLibrary.prototype.StartAnalyzingOutput;AudioMixerBlueprintLibrary.prototype.StartAnalyzingOutput = function (WorldContextObject, SubmixToAnalyze = undefined, FFTSize = "DefaultSize", InterpolationMethod = "NearestNeighbor", WindowType = "None", HopSize = 0) { return fnprepatch_153.call(this, WorldContextObject, SubmixToAnalyze, FFTSize, InterpolationMethod, WindowType, HopSize) }; } catch (e) {};
try { let fnprepatch_154 = AudioMixerBlueprintLibrary.prototype.ResumeRecordingOutput;AudioMixerBlueprintLibrary.prototype.ResumeRecordingOutput = function (WorldContextObject, SubmixToPause = undefined) { return fnprepatch_154.call(this, WorldContextObject, SubmixToPause) }; } catch (e) {};
try { let fnprepatch_155 = AudioMixerBlueprintLibrary.prototype.PauseRecordingOutput;AudioMixerBlueprintLibrary.prototype.PauseRecordingOutput = function (WorldContextObject, SubmixToPause = undefined) { return fnprepatch_155.call(this, WorldContextObject, SubmixToPause) }; } catch (e) {};
try { let fnprepatch_156 = AudioMixerBlueprintLibrary.prototype.GetPhaseForFrequencies;AudioMixerBlueprintLibrary.prototype.GetPhaseForFrequencies = function (WorldContextObject, Frequencies, Phases, SubmixToAnalyze = undefined) { return fnprepatch_156.call(this, WorldContextObject, Frequencies, Phases, SubmixToAnalyze) }; } catch (e) {};
try { let fnprepatch_157 = AudioMixerBlueprintLibrary.prototype.GetMagnitudeForFrequencies;AudioMixerBlueprintLibrary.prototype.GetMagnitudeForFrequencies = function (WorldContextObject, Frequencies, Magnitudes, SubmixToAnalyze = undefined) { return fnprepatch_157.call(this, WorldContextObject, Frequencies, Magnitudes, SubmixToAnalyze) }; } catch (e) {};
try { AudioMixerBlueprintLibrary.prototype.FinishRecordingOutput = AudioMixerBlueprintLibrary.prototype.StopRecordingOutput; } catch (e) {};
try { AudioMixerBlueprintLibrary.FinishRecordingOutput = AudioMixerBlueprintLibrary.StopRecordingOutput; } catch (e) {};
try { let fnprepatch_158 = SubmixEffectReverbPreset.prototype.SetSettingsWithReverbEffect;SubmixEffectReverbPreset.prototype.SetSettingsWithReverbEffect = function (InReverbEffect, WetLevel, DryLevel = 0) { return fnprepatch_158.call(this, InReverbEffect, WetLevel, DryLevel) }; } catch (e) {};
try { let fnprepatch_159 = DynamicEntryBox.prototype.Reset;DynamicEntryBox.prototype.Reset = function (bDeleteWidgets = false) { return fnprepatch_159.call(this, bDeleteWidgets) }; } catch (e) {};
try { DynamicEntryBox.prototype.CreateEntryofClass = DynamicEntryBox.prototype.BP_CreateEntryOfClass; } catch (e) {};
try { DynamicEntryBox.prototype.CreateEntry = DynamicEntryBox.prototype.BP_CreateEntry; } catch (e) {};
try { let fnprepatch_160 = UImage.prototype.SetBrushFromTextureDynamic;UImage.prototype.SetBrushFromTextureDynamic = function (Texture, bMatchSize = false) { return fnprepatch_160.call(this, Texture, bMatchSize) }; } catch (e) {};
try { let fnprepatch_161 = UImage.prototype.SetBrushFromTexture;UImage.prototype.SetBrushFromTexture = function (Texture, bMatchSize = false) { return fnprepatch_161.call(this, Texture, bMatchSize) }; } catch (e) {};
try { let fnprepatch_162 = UImage.prototype.SetBrushFromSoftTexture;UImage.prototype.SetBrushFromSoftTexture = function (SoftTexture, bMatchSize = false) { return fnprepatch_162.call(this, SoftTexture, bMatchSize) }; } catch (e) {};
try { let fnprepatch_163 = UImage.prototype.SetBrushFromAtlasInterface;UImage.prototype.SetBrushFromAtlasInterface = function (AtlasRegion, bMatchSize = false) { return fnprepatch_163.call(this, AtlasRegion, bMatchSize) }; } catch (e) {};
try { UserListEntry.prototype.OnItemSelectionChanged = UserListEntry.prototype.BP_OnItemSelectionChanged; } catch (e) {};
try { UserListEntry.prototype.OnItemExpansionChanged = UserListEntry.prototype.BP_OnItemExpansionChanged; } catch (e) {};
try { UserListEntry.prototype.OnEntryReleased = UserListEntry.prototype.BP_OnEntryReleased; } catch (e) {};
try { ListView.prototype.SetSelectedItem = ListView.prototype.BP_SetSelectedItem; } catch (e) {};
try { ListView.prototype.SetListItems = ListView.prototype.BP_SetListItems; } catch (e) {};
try { ListView.prototype.SetItemSelection = ListView.prototype.BP_SetItemSelection; } catch (e) {};
try { ListView.prototype.ScrollItemIntoView = ListView.prototype.BP_ScrollItemIntoView; } catch (e) {};
try { ListView.prototype.NavigateToItem = ListView.prototype.BP_NavigateToItem; } catch (e) {};
try { ListView.prototype.IsItemVisible = ListView.prototype.BP_IsItemVisible; } catch (e) {};
try { ListView.prototype.GetSelectedItems = ListView.prototype.BP_GetSelectedItems; } catch (e) {};
try { ListView.prototype.GetSelectedItem = ListView.prototype.BP_GetSelectedItem; } catch (e) {};
try { ListView.prototype.GetNumItemsSelected = ListView.prototype.BP_GetNumItemsSelected; } catch (e) {};
try { ListView.prototype.ClearSelection = ListView.prototype.BP_ClearSelection; } catch (e) {};
try { ListView.prototype.CancelScrollIntoView = ListView.prototype.BP_CancelScrollIntoView; } catch (e) {};
try { let fnprepatch_164 = ScrollBox.prototype.ScrollWidgetIntoView;ScrollBox.prototype.ScrollWidgetIntoView = function (WidgetToFind, AnimateScroll = true, ScrollDestination = "IntoView") { return fnprepatch_164.call(this, WidgetToFind, AnimateScroll, ScrollDestination) }; } catch (e) {};
try { SlateBlueprintLibrary.prototype.ScreenToLocal = SlateBlueprintLibrary.prototype.ScreenToWidgetLocal; } catch (e) {};
try { SlateBlueprintLibrary.ScreenToLocal = SlateBlueprintLibrary.ScreenToWidgetLocal; } catch (e) {};
try { SlateBlueprintLibrary.prototype.ScreenToAbsolute = SlateBlueprintLibrary.prototype.ScreenToWidgetAbsolute; } catch (e) {};
try { SlateBlueprintLibrary.ScreenToAbsolute = SlateBlueprintLibrary.ScreenToWidgetAbsolute; } catch (e) {};
try { SlateBlueprintLibrary.prototype.Equal = SlateBlueprintLibrary.prototype.EqualEqual_SlateBrush; } catch (e) {};
try { SlateBlueprintLibrary.Equal = SlateBlueprintLibrary.EqualEqual_SlateBrush; } catch (e) {};
try { let fnprepatch_165 = WidgetBlueprintLibrary.prototype.SetUserFocus;WidgetBlueprintLibrary.prototype.SetUserFocus = function (Reply, FocusWidget, bInAllUsers = false) { return fnprepatch_165.call(this, Reply, FocusWidget, bInAllUsers) }; } catch (e) {};
try { let fnprepatch_166 = WidgetBlueprintLibrary.prototype.SetInputMode_UIOnlyEx;WidgetBlueprintLibrary.prototype.SetInputMode_UIOnlyEx = function (PlayerController, InWidgetToFocus = undefined, InMouseLockMode = "DoNotLock") { return fnprepatch_166.call(this, PlayerController, InWidgetToFocus, InMouseLockMode) }; } catch (e) {};
try { let fnprepatch_167 = WidgetBlueprintLibrary.prototype.SetInputMode_UIOnly;WidgetBlueprintLibrary.prototype.SetInputMode_UIOnly = function (Target, InWidgetToFocus = undefined, bLockMouseToViewport = false) { return fnprepatch_167.call(this, Target, InWidgetToFocus, bLockMouseToViewport) }; } catch (e) {};
try { let fnprepatch_168 = WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUIEx;WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUIEx = function (PlayerController, InWidgetToFocus = undefined, InMouseLockMode = "DoNotLock", bHideCursorDuringCapture = true) { return fnprepatch_168.call(this, PlayerController, InWidgetToFocus, InMouseLockMode, bHideCursorDuringCapture) }; } catch (e) {};
try { let fnprepatch_169 = WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUI;WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUI = function (Target, InWidgetToFocus = undefined, bLockMouseToViewport = false, bHideCursorDuringCapture = true) { return fnprepatch_169.call(this, Target, InWidgetToFocus, bLockMouseToViewport, bHideCursorDuringCapture) }; } catch (e) {};
try { let fnprepatch_170 = WidgetBlueprintLibrary.prototype.ReleaseJoystickCapture;WidgetBlueprintLibrary.prototype.ReleaseJoystickCapture = function (Reply, bInAllJoysticks = false) { return fnprepatch_170.call(this, Reply, bInAllJoysticks) }; } catch (e) {};
try { let fnprepatch_171 = WidgetBlueprintLibrary.prototype.MakeBrushFromTexture;WidgetBlueprintLibrary.prototype.MakeBrushFromTexture = function (Texture, Width = 0, Height = 0) { return fnprepatch_171.call(this, Texture, Width, Height) }; } catch (e) {};
try { let fnprepatch_172 = WidgetBlueprintLibrary.prototype.MakeBrushFromMaterial;WidgetBlueprintLibrary.prototype.MakeBrushFromMaterial = function (Material, Width = 32, Height = 32) { return fnprepatch_172.call(this, Material, Width, Height) }; } catch (e) {};
try { let fnprepatch_173 = WidgetBlueprintLibrary.prototype.GetAllWidgetsOfClass;WidgetBlueprintLibrary.prototype.GetAllWidgetsOfClass = function (WorldContextObject, FoundWidgets, WidgetClass, TopLevelOnly = true) { return fnprepatch_173.call(this, WorldContextObject, FoundWidgets, WidgetClass, TopLevelOnly) }; } catch (e) {};
try { let fnprepatch_174 = WidgetBlueprintLibrary.prototype.DrawTextFormatted;WidgetBlueprintLibrary.prototype.DrawTextFormatted = function (Context, Text, Position, Font, FontSize = 16, FontTypeFace = "Regular", Tint = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_174.call(this, Context, Text, Position, Font, FontSize, FontTypeFace, Tint) }; } catch (e) {};
try { let fnprepatch_175 = WidgetBlueprintLibrary.prototype.DrawText;WidgetBlueprintLibrary.prototype.DrawText = function (Context, InString, Position, Tint = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_175.call(this, Context, InString, Position, Tint) }; } catch (e) {};
try { let fnprepatch_176 = WidgetBlueprintLibrary.prototype.DrawLines;WidgetBlueprintLibrary.prototype.DrawLines = function (Context, Points, Tint = {"R":1,"G":1,"B":1,"A":1}, bAntiAlias = true, Thickness = 1) { return fnprepatch_176.call(this, Context, Points, Tint, bAntiAlias, Thickness) }; } catch (e) {};
try { let fnprepatch_177 = WidgetBlueprintLibrary.prototype.DrawLine;WidgetBlueprintLibrary.prototype.DrawLine = function (Context, PositionA, PositionB, Tint = {"R":1,"G":1,"B":1,"A":1}, bAntiAlias = true, Thickness = 1) { return fnprepatch_177.call(this, Context, PositionA, PositionB, Tint, bAntiAlias, Thickness) }; } catch (e) {};
try { let fnprepatch_178 = WidgetBlueprintLibrary.prototype.DrawBox;WidgetBlueprintLibrary.prototype.DrawBox = function (Context, Position, Size, Brush, Tint = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_178.call(this, Context, Position, Size, Brush, Tint) }; } catch (e) {};
try { let fnprepatch_179 = WidgetBlueprintLibrary.prototype.ClearUserFocus;WidgetBlueprintLibrary.prototype.ClearUserFocus = function (Reply, bInAllUsers = false) { return fnprepatch_179.call(this, Reply, bInAllUsers) }; } catch (e) {};
try { let fnprepatch_180 = WidgetBlueprintLibrary.prototype.CaptureJoystick;WidgetBlueprintLibrary.prototype.CaptureJoystick = function (Reply, CapturingWidget, bInAllJoysticks = false) { return fnprepatch_180.call(this, Reply, CapturingWidget, bInAllJoysticks) }; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.SetInputModeUIOnly = WidgetBlueprintLibrary.prototype.SetInputMode_UIOnlyEx; } catch (e) {};
try { WidgetBlueprintLibrary.SetInputModeUIOnly = WidgetBlueprintLibrary.SetInputMode_UIOnlyEx; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.SetInputModeUIOnly = WidgetBlueprintLibrary.prototype.SetInputMode_UIOnly; } catch (e) {};
try { WidgetBlueprintLibrary.SetInputModeUIOnly = WidgetBlueprintLibrary.SetInputMode_UIOnly; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.SetInputModeGameAndUI = WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUIEx; } catch (e) {};
try { WidgetBlueprintLibrary.SetInputModeGameAndUI = WidgetBlueprintLibrary.SetInputMode_GameAndUIEx; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.SetInputModeGameAndUI = WidgetBlueprintLibrary.prototype.SetInputMode_GameAndUI; } catch (e) {};
try { WidgetBlueprintLibrary.SetInputModeGameAndUI = WidgetBlueprintLibrary.SetInputMode_GameAndUI; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.DrawText = WidgetBlueprintLibrary.prototype.DrawTextFormatted; } catch (e) {};
try { WidgetBlueprintLibrary.DrawText = WidgetBlueprintLibrary.DrawTextFormatted; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.DrawString = WidgetBlueprintLibrary.prototype.DrawText; } catch (e) {};
try { WidgetBlueprintLibrary.DrawString = WidgetBlueprintLibrary.DrawText; } catch (e) {};
try { WidgetBlueprintLibrary.prototype.CreateWidget = WidgetBlueprintLibrary.prototype.Create; } catch (e) {};
try { WidgetBlueprintLibrary.CreateWidget = WidgetBlueprintLibrary.Create; } catch (e) {};
try { let fnprepatch_181 = WidgetInteractionComponent.prototype.SendKeyChar;WidgetInteractionComponent.prototype.SendKeyChar = function (Characters, bRepeat = false) { return fnprepatch_181.call(this, Characters, bRepeat) }; } catch (e) {};
try { let fnprepatch_182 = WidgetInteractionComponent.prototype.PressKey;WidgetInteractionComponent.prototype.PressKey = function (Key, bRepeat = false) { return fnprepatch_182.call(this, Key, bRepeat) }; } catch (e) {};
try { let fnprepatch_183 = SourceControlHelpers.prototype.RevertUnchangedFiles;SourceControlHelpers.prototype.RevertUnchangedFiles = function (InFiles, bSilent = false) { return fnprepatch_183.call(this, InFiles, bSilent) }; } catch (e) {};
try { let fnprepatch_184 = SourceControlHelpers.prototype.RevertUnchangedFile;SourceControlHelpers.prototype.RevertUnchangedFile = function (InFile, bSilent = false) { return fnprepatch_184.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_185 = SourceControlHelpers.prototype.RevertFiles;SourceControlHelpers.prototype.RevertFiles = function (InFiles, bSilent = false) { return fnprepatch_185.call(this, InFiles, bSilent) }; } catch (e) {};
try { let fnprepatch_186 = SourceControlHelpers.prototype.RevertFile;SourceControlHelpers.prototype.RevertFile = function (InFile, bSilent = false) { return fnprepatch_186.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_187 = SourceControlHelpers.prototype.QueryFileState;SourceControlHelpers.prototype.QueryFileState = function (InFile, bSilent = false) { return fnprepatch_187.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_188 = SourceControlHelpers.prototype.MarkFilesForAdd;SourceControlHelpers.prototype.MarkFilesForAdd = function (InFiles, bSilent = false) { return fnprepatch_188.call(this, InFiles, bSilent) }; } catch (e) {};
try { let fnprepatch_189 = SourceControlHelpers.prototype.MarkFileForDelete;SourceControlHelpers.prototype.MarkFileForDelete = function (InFile, bSilent = false) { return fnprepatch_189.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_190 = SourceControlHelpers.prototype.MarkFileForAdd;SourceControlHelpers.prototype.MarkFileForAdd = function (InFile, bSilent = false) { return fnprepatch_190.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_191 = SourceControlHelpers.prototype.CopyFile;SourceControlHelpers.prototype.CopyFile = function (InSourceFile, InDestFile, bSilent = false) { return fnprepatch_191.call(this, InSourceFile, InDestFile, bSilent) }; } catch (e) {};
try { let fnprepatch_192 = SourceControlHelpers.prototype.CheckOutOrAddFile;SourceControlHelpers.prototype.CheckOutOrAddFile = function (InFile, bSilent = false) { return fnprepatch_192.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_193 = SourceControlHelpers.prototype.CheckOutFiles;SourceControlHelpers.prototype.CheckOutFiles = function (InFiles, bSilent = false) { return fnprepatch_193.call(this, InFiles, bSilent) }; } catch (e) {};
try { let fnprepatch_194 = SourceControlHelpers.prototype.CheckOutFile;SourceControlHelpers.prototype.CheckOutFile = function (InFile, bSilent = false) { return fnprepatch_194.call(this, InFile, bSilent) }; } catch (e) {};
try { let fnprepatch_195 = SourceControlHelpers.prototype.CheckInFiles;SourceControlHelpers.prototype.CheckInFiles = function (InFiles, InDescription, bSilent = false) { return fnprepatch_195.call(this, InFiles, InDescription, bSilent) }; } catch (e) {};
try { let fnprepatch_196 = SourceControlHelpers.prototype.CheckInFile;SourceControlHelpers.prototype.CheckInFile = function (InFile, InDescription, bSilent = false) { return fnprepatch_196.call(this, InFile, InDescription, bSilent) }; } catch (e) {};
try { let fnprepatch_197 = SkinnedMeshComponent.prototype.SetSkeletalMesh;SkinnedMeshComponent.prototype.SetSkeletalMesh = function (NewMesh, bReinitPose = true) { return fnprepatch_197.call(this, NewMesh, bReinitPose) }; } catch (e) {};
try { let fnprepatch_198 = SkinnedMeshComponent.prototype.SetPhysicsAsset;SkinnedMeshComponent.prototype.SetPhysicsAsset = function (NewPhysicsAsset, bForceReInit = false) { return fnprepatch_198.call(this, NewPhysicsAsset, bForceReInit) }; } catch (e) {};
try { let fnprepatch_199 = SkinnedMeshComponent.prototype.SetMasterPoseComponent;SkinnedMeshComponent.prototype.SetMasterPoseComponent = function (NewMasterBoneComponent, bForceUpdate = false) { return fnprepatch_199.call(this, NewMasterBoneComponent, bForceUpdate) }; } catch (e) {};
try { let fnprepatch_200 = SkinnedMeshComponent.prototype.GetDeltaTransformFromRefPose;SkinnedMeshComponent.prototype.GetDeltaTransformFromRefPose = function (BoneName, BaseName = "None") { return fnprepatch_200.call(this, BoneName, BaseName) }; } catch (e) {};
try { let fnprepatch_201 = SkinnedMeshComponent.prototype.FindClosestBone_K2;SkinnedMeshComponent.prototype.FindClosestBone_K2 = function (TestLocation, BoneLocation, IgnoreScale = 0, bRequirePhysicsAsset = false) { return fnprepatch_201.call(this, TestLocation, BoneLocation, IgnoreScale, bRequirePhysicsAsset) }; } catch (e) {};
try { SkinnedMeshComponent.prototype.SetVertexColorOverride = SkinnedMeshComponent.prototype.SetVertexColorOverride_LinearColor; } catch (e) {};
try { SkinnedMeshComponent.prototype.FindClosestBone = SkinnedMeshComponent.prototype.FindClosestBone_K2; } catch (e) {};
try { let fnprepatch_202 = SkeletalMeshComponent.prototype.UnbindClothFromMasterPoseComponent;SkeletalMeshComponent.prototype.UnbindClothFromMasterPoseComponent = function (bRestoreSimulationSpace = true) { return fnprepatch_202.call(this, bRestoreSimulationSpace) }; } catch (e) {};
try { let fnprepatch_203 = SkeletalMeshComponent.prototype.SetPosition;SkeletalMeshComponent.prototype.SetPosition = function (InPos, bFireNotifies = true) { return fnprepatch_203.call(this, InPos, bFireNotifies) }; } catch (e) {};
try { let fnprepatch_204 = SkeletalMeshComponent.prototype.SetNotifyRigidBodyCollisionBelow;SkeletalMeshComponent.prototype.SetNotifyRigidBodyCollisionBelow = function (bNewNotifyRigidBodyCollision, BoneName = "None", bIncludeSelf = true) { return fnprepatch_204.call(this, bNewNotifyRigidBodyCollision, BoneName, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_205 = SkeletalMeshComponent.prototype.SetMorphTarget;SkeletalMeshComponent.prototype.SetMorphTarget = function (MorphTargetName, Value, bRemoveZeroWeight = true) { return fnprepatch_205.call(this, MorphTargetName, Value, bRemoveZeroWeight) }; } catch (e) {};
try { let fnprepatch_206 = SkeletalMeshComponent.prototype.SetEnableGravityOnAllBodiesBelow;SkeletalMeshComponent.prototype.SetEnableGravityOnAllBodiesBelow = function (bEnableGravity, BoneName, bIncludeSelf = true) { return fnprepatch_206.call(this, bEnableGravity, BoneName, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_207 = SkeletalMeshComponent.prototype.SetConstraintProfileForAll;SkeletalMeshComponent.prototype.SetConstraintProfileForAll = function (ProfileName, bDefaultIfNotFound = false) { return fnprepatch_207.call(this, ProfileName, bDefaultIfNotFound) }; } catch (e) {};
try { let fnprepatch_208 = SkeletalMeshComponent.prototype.SetConstraintProfile;SkeletalMeshComponent.prototype.SetConstraintProfile = function (JointName, ProfileName, bDefaultIfNotFound = false) { return fnprepatch_208.call(this, JointName, ProfileName, bDefaultIfNotFound) }; } catch (e) {};
try { let fnprepatch_209 = SkeletalMeshComponent.prototype.SetBodyNotifyRigidBodyCollision;SkeletalMeshComponent.prototype.SetBodyNotifyRigidBodyCollision = function (bNewNotifyRigidBodyCollision, BoneName = "None") { return fnprepatch_209.call(this, bNewNotifyRigidBodyCollision, BoneName) }; } catch (e) {};
try { let fnprepatch_210 = SkeletalMeshComponent.prototype.SetAllMotorsAngularVelocityDrive;SkeletalMeshComponent.prototype.SetAllMotorsAngularVelocityDrive = function (bEnableSwingDrive, bEnableTwistDrive, bSkipCustomPhysicsType = false) { return fnprepatch_210.call(this, bEnableSwingDrive, bEnableTwistDrive, bSkipCustomPhysicsType) }; } catch (e) {};
try { let fnprepatch_211 = SkeletalMeshComponent.prototype.SetAllMotorsAngularPositionDrive;SkeletalMeshComponent.prototype.SetAllMotorsAngularPositionDrive = function (bEnableSwingDrive, bEnableTwistDrive, bSkipCustomPhysicsType = false) { return fnprepatch_211.call(this, bEnableSwingDrive, bEnableTwistDrive, bSkipCustomPhysicsType) }; } catch (e) {};
try { let fnprepatch_212 = SkeletalMeshComponent.prototype.SetAllMotorsAngularDriveParams;SkeletalMeshComponent.prototype.SetAllMotorsAngularDriveParams = function (InSpring, InDamping, InForceLimit, bSkipCustomPhysicsType = false) { return fnprepatch_212.call(this, InSpring, InDamping, InForceLimit, bSkipCustomPhysicsType) }; } catch (e) {};
try { let fnprepatch_213 = SkeletalMeshComponent.prototype.SetAllBodiesPhysicsBlendWeight;SkeletalMeshComponent.prototype.SetAllBodiesPhysicsBlendWeight = function (PhysicsBlendWeight, bSkipCustomPhysicsType = false) { return fnprepatch_213.call(this, PhysicsBlendWeight, bSkipCustomPhysicsType) }; } catch (e) {};
try { let fnprepatch_214 = SkeletalMeshComponent.prototype.SetAllBodiesBelowSimulatePhysics;SkeletalMeshComponent.prototype.SetAllBodiesBelowSimulatePhysics = function (InBoneName, bNewSimulate, bIncludeSelf = true) { return fnprepatch_214.call(this, InBoneName, bNewSimulate, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_215 = SkeletalMeshComponent.prototype.SetAllBodiesBelowPhysicsBlendWeight;SkeletalMeshComponent.prototype.SetAllBodiesBelowPhysicsBlendWeight = function (InBoneName, PhysicsBlendWeight, bSkipCustomPhysicsType = false, bIncludeSelf = true) { return fnprepatch_215.call(this, InBoneName, PhysicsBlendWeight, bSkipCustomPhysicsType, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_216 = SkeletalMeshComponent.prototype.ResetAnimInstanceDynamics;SkeletalMeshComponent.prototype.ResetAnimInstanceDynamics = function (InTeleportType = "ResetPhysics") { return fnprepatch_216.call(this, InTeleportType) }; } catch (e) {};
try { let fnprepatch_217 = SkeletalMeshComponent.prototype.OverrideAnimationData;SkeletalMeshComponent.prototype.OverrideAnimationData = function (InAnimToPlay, bIsLooping = true, bIsPlaying = true, Position = 0, PlayRate = 1) { return fnprepatch_217.call(this, InAnimToPlay, bIsLooping, bIsPlaying, Position, PlayRate) }; } catch (e) {};
try { let fnprepatch_218 = SkeletalMeshComponent.prototype.GetBoneMass;SkeletalMeshComponent.prototype.GetBoneMass = function (BoneName = "None", bScaleMass = true) { return fnprepatch_218.call(this, BoneName, bScaleMass) }; } catch (e) {};
try { let fnprepatch_219 = SkeletalMeshComponent.prototype.AddImpulseToAllBodiesBelow;SkeletalMeshComponent.prototype.AddImpulseToAllBodiesBelow = function (Impulse, BoneName = "None", bVelChange = false, bIncludeSelf = true) { return fnprepatch_219.call(this, Impulse, BoneName, bVelChange, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_220 = SkeletalMeshComponent.prototype.AddForceToAllBodiesBelow;SkeletalMeshComponent.prototype.AddForceToAllBodiesBelow = function (Force, BoneName = "None", bAccelChange = false, bIncludeSelf = true) { return fnprepatch_220.call(this, Force, BoneName, bAccelChange, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_221 = SkeletalMeshComponent.prototype.AccumulateAllBodiesBelowPhysicsBlendWeight;SkeletalMeshComponent.prototype.AccumulateAllBodiesBelowPhysicsBlendWeight = function (InBoneName, AddPhysicsBlendWeight, bSkipCustomPhysicsType = false) { return fnprepatch_221.call(this, InBoneName, AddPhysicsBlendWeight, bSkipCustomPhysicsType) }; } catch (e) {};
try { SkeletalMeshComponent.prototype.GetDirectionBetweenSockets = SkeletalMeshComponent.prototype.K2_DirectionBetweenSockets; } catch (e) {};
try { SkeletalMeshComponent.prototype.GetDistanceBetweenTwoSockets = SkeletalMeshComponent.prototype.K2_DistanceBetweenTwoSocketsAndMapRange; } catch (e) {};
try { SkeletalMeshComponent.prototype.SetAnimInstanceClass = SkeletalMeshComponent.prototype.K2_SetAnimInstanceClass; } catch (e) {};
try { SkeletalMeshComponent.prototype.GetClosestPointOnPhysicsAsset = SkeletalMeshComponent.prototype.K2_GetClosestPointOnPhysicsAsset; } catch (e) {};
try { let fnprepatch_222 = AnimInstance.prototype.StopSlotAnimation;AnimInstance.prototype.StopSlotAnimation = function (InBlendOutTime = 0.25, SlotNodeName = "None") { return fnprepatch_222.call(this, InBlendOutTime, SlotNodeName) }; } catch (e) {};
try { let fnprepatch_223 = AnimInstance.prototype.PlaySlotAnimationAsDynamicMontage;AnimInstance.prototype.PlaySlotAnimationAsDynamicMontage = function (Asset, SlotNodeName, BlendInTime = 0.25, BlendOutTime = 0.25, InPlayRate = 1, LoopCount = 1, BlendOutTriggerTime = -1, InTimeToStartMontageAt = 0) { return fnprepatch_223.call(this, Asset, SlotNodeName, BlendInTime, BlendOutTime, InPlayRate, LoopCount, BlendOutTriggerTime, InTimeToStartMontageAt) }; } catch (e) {};
try { let fnprepatch_224 = AnimInstance.prototype.PlaySlotAnimation;AnimInstance.prototype.PlaySlotAnimation = function (Asset, SlotNodeName, BlendInTime = 0.25, BlendOutTime = 0.25, InPlayRate = 1, LoopCount = 1) { return fnprepatch_224.call(this, Asset, SlotNodeName, BlendInTime, BlendOutTime, InPlayRate, LoopCount) }; } catch (e) {};
try { let fnprepatch_225 = AnimInstance.prototype.Montage_Stop;AnimInstance.prototype.Montage_Stop = function (InBlendOutTime, Montage = undefined) { return fnprepatch_225.call(this, InBlendOutTime, Montage) }; } catch (e) {};
try { let fnprepatch_226 = AnimInstance.prototype.Montage_SetPlayRate;AnimInstance.prototype.Montage_SetPlayRate = function (Montage, NewPlayRate = 1) { return fnprepatch_226.call(this, Montage, NewPlayRate) }; } catch (e) {};
try { let fnprepatch_227 = AnimInstance.prototype.Montage_SetNextSection;AnimInstance.prototype.Montage_SetNextSection = function (SectionNameToChange, NextSection, Montage = undefined) { return fnprepatch_227.call(this, SectionNameToChange, NextSection, Montage) }; } catch (e) {};
try { let fnprepatch_228 = AnimInstance.prototype.Montage_Play;AnimInstance.prototype.Montage_Play = function (MontageToPlay, InPlayRate = 1, ReturnValueType = "MontageLength", InTimeToStartMontageAt = 0, bStopAllMontages = true) { return fnprepatch_228.call(this, MontageToPlay, InPlayRate, ReturnValueType, InTimeToStartMontageAt, bStopAllMontages) }; } catch (e) {};
try { let fnprepatch_229 = AnimInstance.prototype.Montage_Pause;AnimInstance.prototype.Montage_Pause = function (Montage = undefined) { return fnprepatch_229.call(this, Montage) }; } catch (e) {};
try { let fnprepatch_230 = AnimInstance.prototype.Montage_JumpToSectionsEnd;AnimInstance.prototype.Montage_JumpToSectionsEnd = function (SectionName, Montage = undefined) { return fnprepatch_230.call(this, SectionName, Montage) }; } catch (e) {};
try { let fnprepatch_231 = AnimInstance.prototype.Montage_JumpToSection;AnimInstance.prototype.Montage_JumpToSection = function (SectionName, Montage = undefined) { return fnprepatch_231.call(this, SectionName, Montage) }; } catch (e) {};
try { let fnprepatch_232 = AnimInstance.prototype.Montage_GetCurrentSection;AnimInstance.prototype.Montage_GetCurrentSection = function (Montage = undefined) { return fnprepatch_232.call(this, Montage) }; } catch (e) {};
try { let fnprepatch_233 = AnimInstance.prototype.IsSyncGroupBetweenMarkers;AnimInstance.prototype.IsSyncGroupBetweenMarkers = function (InSyncGroupName, PreviousMarker, NextMarker, bRespectMarkerOrder = true) { return fnprepatch_233.call(this, InSyncGroupName, PreviousMarker, NextMarker, bRespectMarkerOrder) }; } catch (e) {};
try { AnimInstance.prototype.GetTransitionTimeElapsed = AnimInstance.prototype.GetInstanceTransitionTimeElapsedFraction; } catch (e) {};
try { AnimInstance.prototype.GetTransitionTimeElapsed = AnimInstance.prototype.GetInstanceTransitionTimeElapsed; } catch (e) {};
try { AnimInstance.prototype.GetTransitionCrossfadeDuration = AnimInstance.prototype.GetInstanceTransitionCrossfadeDuration; } catch (e) {};
try { AnimInstance.prototype.StateWeight = AnimInstance.prototype.GetInstanceStateWeight; } catch (e) {};
try { AnimInstance.prototype.MachineWeight = AnimInstance.prototype.GetInstanceMachineWeight; } catch (e) {};
try { AnimInstance.prototype.CurrentStateTime = AnimInstance.prototype.GetInstanceCurrentStateElapsedTime; } catch (e) {};
try { AnimInstance.prototype.TimeRemaining = AnimInstance.prototype.GetInstanceAssetPlayerTimeFromEndFraction; } catch (e) {};
try { AnimInstance.prototype.TimeRemaining = AnimInstance.prototype.GetInstanceAssetPlayerTimeFromEnd; } catch (e) {};
try { AnimInstance.prototype.CurrentTime = AnimInstance.prototype.GetInstanceAssetPlayerTimeFraction; } catch (e) {};
try { AnimInstance.prototype.CurrentTime = AnimInstance.prototype.GetInstanceAssetPlayerTime; } catch (e) {};
try { AnimInstance.prototype.Length = AnimInstance.prototype.GetInstanceAssetPlayerLength; } catch (e) {};
try { let fnprepatch_234 = AnimSingleNodeInstance.prototype.SetPositionWithPreviousTime;AnimSingleNodeInstance.prototype.SetPositionWithPreviousTime = function (InPosition, InPreviousTime, bFireNotifies = true) { return fnprepatch_234.call(this, InPosition, InPreviousTime, bFireNotifies) }; } catch (e) {};
try { let fnprepatch_235 = AnimSingleNodeInstance.prototype.SetPosition;AnimSingleNodeInstance.prototype.SetPosition = function (InPosition, bFireNotifies = true) { return fnprepatch_235.call(this, InPosition, bFireNotifies) }; } catch (e) {};
try { let fnprepatch_236 = AnimSingleNodeInstance.prototype.SetAnimationAsset;AnimSingleNodeInstance.prototype.SetAnimationAsset = function (NewAsset, bIsLooping = true, InPlayRate = 1) { return fnprepatch_236.call(this, NewAsset, bIsLooping, InPlayRate) }; } catch (e) {};
try { let fnprepatch_237 = AnimSingleNodeInstance.prototype.PlayAnim;AnimSingleNodeInstance.prototype.PlayAnim = function (bIsLooping = false, InPlayRate = 1, InStartPosition = 0) { return fnprepatch_237.call(this, bIsLooping, InPlayRate, InStartPosition) }; } catch (e) {};
try { KismetAnimationLibrary.prototype.TwoBoneIKFunction = KismetAnimationLibrary.prototype.K2_TwoBoneIK; } catch (e) {};
try { KismetAnimationLibrary.TwoBoneIKFunction = KismetAnimationLibrary.K2_TwoBoneIK; } catch (e) {};
try { KismetAnimationLibrary.prototype.MakePerlinNoiseVectorandRemap = KismetAnimationLibrary.prototype.K2_MakePerlinNoiseVectorAndRemap; } catch (e) {};
try { KismetAnimationLibrary.MakePerlinNoiseVectorandRemap = KismetAnimationLibrary.K2_MakePerlinNoiseVectorAndRemap; } catch (e) {};
try { KismetAnimationLibrary.prototype.MakePerlinNoiseandRemap = KismetAnimationLibrary.prototype.K2_MakePerlinNoiseAndRemap; } catch (e) {};
try { KismetAnimationLibrary.MakePerlinNoiseandRemap = KismetAnimationLibrary.K2_MakePerlinNoiseAndRemap; } catch (e) {};
try { KismetAnimationLibrary.prototype.LookAtFunction = KismetAnimationLibrary.prototype.K2_LookAt; } catch (e) {};
try { KismetAnimationLibrary.LookAtFunction = KismetAnimationLibrary.K2_LookAt; } catch (e) {};
try { KismetAnimationLibrary.prototype.GetDistanceBetweenTwoSockets = KismetAnimationLibrary.prototype.K2_DistanceBetweenTwoSocketsAndMapRange; } catch (e) {};
try { KismetAnimationLibrary.GetDistanceBetweenTwoSockets = KismetAnimationLibrary.K2_DistanceBetweenTwoSocketsAndMapRange; } catch (e) {};
try { KismetAnimationLibrary.prototype.GetDirectionBetweenSockets = KismetAnimationLibrary.prototype.K2_DirectionBetweenSockets; } catch (e) {};
try { KismetAnimationLibrary.GetDirectionBetweenSockets = KismetAnimationLibrary.K2_DirectionBetweenSockets; } catch (e) {};
try { let fnprepatch_238 = PlayMontageCallbackProxy.prototype.CreateProxyObjectForPlayMontage;PlayMontageCallbackProxy.prototype.CreateProxyObjectForPlayMontage = function (InSkeletalMeshComponent, MontageToPlay, PlayRate = 1, StartingPosition = 0, StartingSection = "None") { return fnprepatch_238.call(this, InSkeletalMeshComponent, MontageToPlay, PlayRate, StartingPosition, StartingSection) }; } catch (e) {};
try { MovieSceneTransformOrigin.prototype.GetTransformOrigin = MovieSceneTransformOrigin.prototype.BP_GetTransformOrigin; } catch (e) {};
try { let fnprepatch_239 = TimeManagementBlueprintLibrary.prototype.Conv_TimecodeToString;TimeManagementBlueprintLibrary.prototype.Conv_TimecodeToString = function (InTimecode, bForceSignDisplay = false) { return fnprepatch_239.call(this, InTimecode, bForceSignDisplay) }; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.TransformFrameTime = TimeManagementBlueprintLibrary.prototype.TransformTime; } catch (e) {};
try { TimeManagementBlueprintLibrary.TransformFrameTime = TimeManagementBlueprintLibrary.TransformTime; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.SnapFrameTime = TimeManagementBlueprintLibrary.prototype.SnapFrameTimeToRate; } catch (e) {};
try { TimeManagementBlueprintLibrary.SnapFrameTime = TimeManagementBlueprintLibrary.SnapFrameTimeToRate; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.IsMultipleOf = TimeManagementBlueprintLibrary.prototype.IsValid_MultipleOf; } catch (e) {};
try { TimeManagementBlueprintLibrary.IsMultipleOf = TimeManagementBlueprintLibrary.IsValid_MultipleOf; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.IsValid = TimeManagementBlueprintLibrary.prototype.IsValid_Framerate; } catch (e) {};
try { TimeManagementBlueprintLibrary.IsValid = TimeManagementBlueprintLibrary.IsValid_Framerate; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.TimecodetoString = TimeManagementBlueprintLibrary.prototype.Conv_TimecodeToString; } catch (e) {};
try { TimeManagementBlueprintLibrary.TimecodetoString = TimeManagementBlueprintLibrary.Conv_TimecodeToString; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.QualifiedFrameTimetoSeconds = TimeManagementBlueprintLibrary.prototype.Conv_QualifiedFrameTimeToSeconds; } catch (e) {};
try { TimeManagementBlueprintLibrary.QualifiedFrameTimetoSeconds = TimeManagementBlueprintLibrary.Conv_QualifiedFrameTimeToSeconds; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.FrameRatetoSeconds = TimeManagementBlueprintLibrary.prototype.Conv_FrameRateToSeconds; } catch (e) {};
try { TimeManagementBlueprintLibrary.FrameRatetoSeconds = TimeManagementBlueprintLibrary.Conv_FrameRateToSeconds; } catch (e) {};
try { TimeManagementBlueprintLibrary.prototype.FrameNumbertoInteger = TimeManagementBlueprintLibrary.prototype.Conv_FrameNumberToInteger; } catch (e) {};
try { TimeManagementBlueprintLibrary.FrameNumbertoInteger = TimeManagementBlueprintLibrary.Conv_FrameNumberToInteger; } catch (e) {};
try { let fnprepatch_240 = MovieSceneSequencePlayer.prototype.PlayLooping;MovieSceneSequencePlayer.prototype.PlayLooping = function (NumLoops = -1) { return fnprepatch_240.call(this, NumLoops) }; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.SetPlayRange = MovieSceneSequencePlayer.prototype.SetTimeRange; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.SetPlayRange = MovieSceneSequencePlayer.prototype.SetFrameRange; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.ScrubTo = MovieSceneSequencePlayer.prototype.ScrubToSeconds; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.ScrubTo = MovieSceneSequencePlayer.prototype.ScrubToFrame; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.PlayTo = MovieSceneSequencePlayer.prototype.PlayToSeconds; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.PlayTo = MovieSceneSequencePlayer.prototype.PlayToFrame; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.JumpTo = MovieSceneSequencePlayer.prototype.JumpToSeconds; } catch (e) {};
try { MovieSceneSequencePlayer.prototype.JumpTo = MovieSceneSequencePlayer.prototype.JumpToFrame; } catch (e) {};
try { let fnprepatch_241 = LevelSequenceActor.prototype.SetBinding;LevelSequenceActor.prototype.SetBinding = function (Binding, Actors, bAllowBindingsFromAsset = false) { return fnprepatch_241.call(this, Binding, Actors, bAllowBindingsFromAsset) }; } catch (e) {};
try { let fnprepatch_242 = LevelSequenceActor.prototype.AddBinding;LevelSequenceActor.prototype.AddBinding = function (Binding, Actor, bAllowBindingsFromAsset = false) { return fnprepatch_242.call(this, Binding, Actor, bAllowBindingsFromAsset) }; } catch (e) {};
try { ActorGroupingUtils.prototype.GetActorGroupingUtils = ActorGroupingUtils.prototype.Get; } catch (e) {};
try { ActorGroupingUtils.GetActorGroupingUtils = ActorGroupingUtils.Get; } catch (e) {};
try { let fnprepatch_243 = EditorLevelUtils.prototype.SetLevelVisibility;EditorLevelUtils.prototype.SetLevelVisibility = function (Level, bShouldBeVisible, bForceLayersVisible, ModifyMode = "ModifyOnChange") { return fnprepatch_243.call(this, Level, bShouldBeVisible, bForceLayersVisible, ModifyMode) }; } catch (e) {};
try { let fnprepatch_244 = EditorLevelUtils.prototype.MoveSelectedActorsToLevel;EditorLevelUtils.prototype.MoveSelectedActorsToLevel = function (DestLevel, bWarnAboutReferences = true) { return fnprepatch_244.call(this, DestLevel, bWarnAboutReferences) }; } catch (e) {};
try { let fnprepatch_245 = EditorLevelUtils.prototype.MoveActorsToLevel;EditorLevelUtils.prototype.MoveActorsToLevel = function (ActorsToMove, DestStreamingLevel, bWarnAboutReferences = true) { return fnprepatch_245.call(this, ActorsToMove, DestStreamingLevel, bWarnAboutReferences) }; } catch (e) {};
try { let fnprepatch_246 = EditorLevelUtils.prototype.CreateNewStreamingLevel;EditorLevelUtils.prototype.CreateNewStreamingLevel = function (LevelStreamingClass, NewLevelPath, bMoveSelectedActorsIntoNewLevel = false) { return fnprepatch_246.call(this, LevelStreamingClass, NewLevelPath, bMoveSelectedActorsIntoNewLevel) }; } catch (e) {};
try { AssetImportData.prototype.GetFirstFilename = AssetImportData.prototype.K2_GetFirstFilename; } catch (e) {};
try { AssetImportData.prototype.ExtractFilenames = AssetImportData.prototype.K2_ExtractFilenames; } catch (e) {};
try { let fnprepatch_247 = MaterialInterface.prototype.SetForceMipLevelsToBeResident;MaterialInterface.prototype.SetForceMipLevelsToBeResident = function (OverrideForceMiplevelsToBeResident, bForceMiplevelsToBeResidentValue, ForceDuration, CinematicTextureGroups = 0) { return fnprepatch_247.call(this, OverrideForceMiplevelsToBeResident, bForceMiplevelsToBeResidentValue, ForceDuration, CinematicTextureGroups) }; } catch (e) {};
try { let fnprepatch_248 = InstancedStaticMeshComponent.prototype.UpdateInstanceTransform;InstancedStaticMeshComponent.prototype.UpdateInstanceTransform = function (InstanceIndex, NewInstanceTransform, bWorldSpace = false, bMarkRenderStateDirty = false, bTeleport = false) { return fnprepatch_248.call(this, InstanceIndex, NewInstanceTransform, bWorldSpace, bMarkRenderStateDirty, bTeleport) }; } catch (e) {};
try { let fnprepatch_249 = InstancedStaticMeshComponent.prototype.GetInstanceTransform;InstancedStaticMeshComponent.prototype.GetInstanceTransform = function (InstanceIndex, OutInstanceTransform, bWorldSpace = false) { return fnprepatch_249.call(this, InstanceIndex, OutInstanceTransform, bWorldSpace) }; } catch (e) {};
try { let fnprepatch_250 = InstancedStaticMeshComponent.prototype.GetInstancesOverlappingSphere;InstancedStaticMeshComponent.prototype.GetInstancesOverlappingSphere = function (Center, Radius, bSphereInWorldSpace = true) { return fnprepatch_250.call(this, Center, Radius, bSphereInWorldSpace) }; } catch (e) {};
try { let fnprepatch_251 = InstancedStaticMeshComponent.prototype.GetInstancesOverlappingBox;InstancedStaticMeshComponent.prototype.GetInstancesOverlappingBox = function (Box, bBoxInWorldSpace = true) { return fnprepatch_251.call(this, Box, bBoxInWorldSpace) }; } catch (e) {};
try { let fnprepatch_252 = ProceduralFoliageSpawner.prototype.Simulate;ProceduralFoliageSpawner.prototype.Simulate = function (NumSteps = -1) { return fnprepatch_252.call(this, NumSteps) }; } catch (e) {};
try { let fnprepatch_253 = LandscapeProxy.prototype.LandscapeImportHeightmapFromRenderTarget;LandscapeProxy.prototype.LandscapeImportHeightmapFromRenderTarget = function (InRenderTarget, InImportHeightFromRGChannel = false) { return fnprepatch_253.call(this, InRenderTarget, InImportHeightFromRGChannel) }; } catch (e) {};
try { let fnprepatch_254 = LandscapeProxy.prototype.LandscapeExportHeightmapToRenderTarget;LandscapeProxy.prototype.LandscapeExportHeightmapToRenderTarget = function (InRenderTarget, InExportHeightIntoRGChannel = false) { return fnprepatch_254.call(this, InRenderTarget, InExportHeightIntoRGChannel) }; } catch (e) {};
try { let fnprepatch_255 = LandscapeProxy.prototype.EditorApplySpline;LandscapeProxy.prototype.EditorApplySpline = function (InSplineComponent, StartWidth = 200, EndWidth = 200, StartSideFalloff = 200, EndSideFalloff = 200, StartRoll = 0, EndRoll = 0, NumSubdivisions = 20, bRaiseHeights = true, bLowerHeights = true, PaintLayer = undefined) { return fnprepatch_255.call(this, InSplineComponent, StartWidth, EndWidth, StartSideFalloff, EndSideFalloff, StartRoll, EndRoll, NumSubdivisions, bRaiseHeights, bLowerHeights, PaintLayer) }; } catch (e) {};
try { MaterialInstanceConstant.prototype.GetVectorParameterValue = MaterialInstanceConstant.prototype.K2_GetVectorParameterValue; } catch (e) {};
try { MaterialInstanceConstant.prototype.GetTextureParameterValue = MaterialInstanceConstant.prototype.K2_GetTextureParameterValue; } catch (e) {};
try { MaterialInstanceConstant.prototype.GetScalarParameterValue = MaterialInstanceConstant.prototype.K2_GetScalarParameterValue; } catch (e) {};
try { let fnprepatch_256 = AmbientSound.prototype.Play;AmbientSound.prototype.Play = function (StartTime = 0) { return fnprepatch_256.call(this, StartTime) }; } catch (e) {};
try { let fnprepatch_257 = AmbientSound.prototype.FadeIn;AmbientSound.prototype.FadeIn = function (FadeInDuration, FadeVolumeLevel = 1) { return fnprepatch_257.call(this, FadeInDuration, FadeVolumeLevel) }; } catch (e) {};
try { let fnprepatch_258 = AudioComponent.prototype.Play;AudioComponent.prototype.Play = function (StartTime = 0) { return fnprepatch_258.call(this, StartTime) }; } catch (e) {};
try { let fnprepatch_259 = AudioComponent.prototype.FadeIn;AudioComponent.prototype.FadeIn = function (FadeInDuration, FadeVolumeLevel = 1, StartTime = 0) { return fnprepatch_259.call(this, FadeInDuration, FadeVolumeLevel, StartTime) }; } catch (e) {};
try { AudioComponent.prototype.SetIntegerParameter = AudioComponent.prototype.SetIntParameter; } catch (e) {};
try { AudioComponent.prototype.SetBooleanParameter = AudioComponent.prototype.SetBoolParameter; } catch (e) {};
try { AudioComponent.prototype.GetAttenuationSettingsToApply = AudioComponent.prototype.BP_GetAttenuationSettingsToApply; } catch (e) {};
try { let fnprepatch_260 = AvoidanceManager.prototype.RegisterMovementComponent;AvoidanceManager.prototype.RegisterMovementComponent = function (MovementComp, AvoidanceWeight = 0.5) { return fnprepatch_260.call(this, MovementComp, AvoidanceWeight) }; } catch (e) {};
try { BlueprintMapLibrary.prototype.Values = BlueprintMapLibrary.prototype.Map_Values; } catch (e) {};
try { BlueprintMapLibrary.Values = BlueprintMapLibrary.Map_Values; } catch (e) {};
try { BlueprintMapLibrary.prototype.Remove = BlueprintMapLibrary.prototype.Map_Remove; } catch (e) {};
try { BlueprintMapLibrary.Remove = BlueprintMapLibrary.Map_Remove; } catch (e) {};
try { BlueprintMapLibrary.prototype.Length = BlueprintMapLibrary.prototype.Map_Length; } catch (e) {};
try { BlueprintMapLibrary.Length = BlueprintMapLibrary.Map_Length; } catch (e) {};
try { BlueprintMapLibrary.prototype.Keys = BlueprintMapLibrary.prototype.Map_Keys; } catch (e) {};
try { BlueprintMapLibrary.Keys = BlueprintMapLibrary.Map_Keys; } catch (e) {};
try { BlueprintMapLibrary.prototype.Find = BlueprintMapLibrary.prototype.Map_Find; } catch (e) {};
try { BlueprintMapLibrary.Find = BlueprintMapLibrary.Map_Find; } catch (e) {};
try { BlueprintMapLibrary.prototype.Contains = BlueprintMapLibrary.prototype.Map_Contains; } catch (e) {};
try { BlueprintMapLibrary.Contains = BlueprintMapLibrary.Map_Contains; } catch (e) {};
try { BlueprintMapLibrary.prototype.Clear = BlueprintMapLibrary.prototype.Map_Clear; } catch (e) {};
try { BlueprintMapLibrary.Clear = BlueprintMapLibrary.Map_Clear; } catch (e) {};
try { BlueprintMapLibrary.prototype.Add = BlueprintMapLibrary.prototype.Map_Add; } catch (e) {};
try { BlueprintMapLibrary.Add = BlueprintMapLibrary.Map_Add; } catch (e) {};
try { let fnprepatch_261 = BlueprintPathsLibrary.prototype.GetExtension;BlueprintPathsLibrary.prototype.GetExtension = function (InPath, bIncludeDot = false) { return fnprepatch_261.call(this, InPath, bIncludeDot) }; } catch (e) {};
try { let fnprepatch_262 = BlueprintPathsLibrary.prototype.GetBaseFilename;BlueprintPathsLibrary.prototype.GetBaseFilename = function (InPath, bRemovePath = true) { return fnprepatch_262.call(this, InPath, bRemovePath) }; } catch (e) {};
try { let fnprepatch_263 = BlueprintPathsLibrary.prototype.CreateTempFilename;BlueprintPathsLibrary.prototype.CreateTempFilename = function (Path, Prefix, Extension = ".tmp") { return fnprepatch_263.call(this, Path, Prefix, Extension) }; } catch (e) {};
try { GameInstance.prototype.Shutdown = GameInstance.prototype.ReceiveShutdown; } catch (e) {};
try { GameInstance.prototype.Init = GameInstance.prototype.ReceiveInit; } catch (e) {};
try { GameInstance.prototype.TravelError = GameInstance.prototype.HandleTravelError; } catch (e) {};
try { GameInstance.prototype.NetworkError = GameInstance.prototype.HandleNetworkError; } catch (e) {};
try { BlueprintSetLibrary.prototype.Union = BlueprintSetLibrary.prototype.Set_Union; } catch (e) {};
try { BlueprintSetLibrary.Union = BlueprintSetLibrary.Set_Union; } catch (e) {};
try { BlueprintSetLibrary.prototype.ToArray = BlueprintSetLibrary.prototype.Set_ToArray; } catch (e) {};
try { BlueprintSetLibrary.ToArray = BlueprintSetLibrary.Set_ToArray; } catch (e) {};
try { BlueprintSetLibrary.prototype.RemoveItems = BlueprintSetLibrary.prototype.Set_RemoveItems; } catch (e) {};
try { BlueprintSetLibrary.RemoveItems = BlueprintSetLibrary.Set_RemoveItems; } catch (e) {};
try { BlueprintSetLibrary.prototype.Remove = BlueprintSetLibrary.prototype.Set_Remove; } catch (e) {};
try { BlueprintSetLibrary.Remove = BlueprintSetLibrary.Set_Remove; } catch (e) {};
try { BlueprintSetLibrary.prototype.Length = BlueprintSetLibrary.prototype.Set_Length; } catch (e) {};
try { BlueprintSetLibrary.Length = BlueprintSetLibrary.Set_Length; } catch (e) {};
try { BlueprintSetLibrary.prototype.Intersection = BlueprintSetLibrary.prototype.Set_Intersection; } catch (e) {};
try { BlueprintSetLibrary.Intersection = BlueprintSetLibrary.Set_Intersection; } catch (e) {};
try { BlueprintSetLibrary.prototype.Difference = BlueprintSetLibrary.prototype.Set_Difference; } catch (e) {};
try { BlueprintSetLibrary.Difference = BlueprintSetLibrary.Set_Difference; } catch (e) {};
try { BlueprintSetLibrary.prototype.ContainsItem = BlueprintSetLibrary.prototype.Set_Contains; } catch (e) {};
try { BlueprintSetLibrary.ContainsItem = BlueprintSetLibrary.Set_Contains; } catch (e) {};
try { BlueprintSetLibrary.prototype.Clear = BlueprintSetLibrary.prototype.Set_Clear; } catch (e) {};
try { BlueprintSetLibrary.Clear = BlueprintSetLibrary.Set_Clear; } catch (e) {};
try { BlueprintSetLibrary.prototype.AddItems = BlueprintSetLibrary.prototype.Set_AddItems; } catch (e) {};
try { BlueprintSetLibrary.AddItems = BlueprintSetLibrary.Set_AddItems; } catch (e) {};
try { BlueprintSetLibrary.prototype.Add = BlueprintSetLibrary.prototype.Set_Add; } catch (e) {};
try { BlueprintSetLibrary.Add = BlueprintSetLibrary.Set_Add; } catch (e) {};
try { let fnprepatch_264 = BoxComponent.prototype.SetBoxExtent;BoxComponent.prototype.SetBoxExtent = function (InBoxExtent, bUpdateOverlaps = true) { return fnprepatch_264.call(this, InBoxExtent, bUpdateOverlaps) }; } catch (e) {};
try { let fnprepatch_265 = CameraAnimInst.prototype.Stop;CameraAnimInst.prototype.Stop = function (bImmediate = false) { return fnprepatch_265.call(this, bImmediate) }; } catch (e) {};
try { let fnprepatch_266 = CameraModifier.prototype.DisableModifier;CameraModifier.prototype.DisableModifier = function (bImmediate = false) { return fnprepatch_266.call(this, bImmediate) }; } catch (e) {};
try { let fnprepatch_267 = Canvas.prototype.K2_TextSize;Canvas.prototype.K2_TextSize = function (RenderFont, RenderText, Scale = {"X":1,"Y":1}) { return fnprepatch_267.call(this, RenderFont, RenderText, Scale) }; } catch (e) {};
try { let fnprepatch_268 = Canvas.prototype.K2_DrawTexture;Canvas.prototype.K2_DrawTexture = function (RenderTexture, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize = {"X":1,"Y":1}, RenderColor = {"R":1,"G":1,"B":1,"A":1}, BlendMode = "BLEND_Translucent", Rotation = 0, PivotPoint = {"X":0.5,"Y":0.5}) { return fnprepatch_268.call(this, RenderTexture, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize, RenderColor, BlendMode, Rotation, PivotPoint) }; } catch (e) {};
try { let fnprepatch_269 = Canvas.prototype.K2_DrawText;Canvas.prototype.K2_DrawText = function (RenderFont, RenderText, ScreenPosition, Scale = {"X":1,"Y":1}, RenderColor = {"R":1,"G":1,"B":1,"A":1}, Kerning = 0, ShadowColor = {"R":0,"G":0,"B":0,"A":1}, ShadowOffset = {"X":1,"Y":1}, bCentreX = false, bCentreY = false, bOutlined = false, OutlineColor = {"R":0,"G":0,"B":0,"A":1}) { return fnprepatch_269.call(this, RenderFont, RenderText, ScreenPosition, Scale, RenderColor, Kerning, ShadowColor, ShadowOffset, bCentreX, bCentreY, bOutlined, OutlineColor) }; } catch (e) {};
try { let fnprepatch_270 = Canvas.prototype.K2_DrawPolygon;Canvas.prototype.K2_DrawPolygon = function (RenderTexture, ScreenPosition, Radius = {"X":1,"Y":1}, NumberOfSides = 3, RenderColor = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_270.call(this, RenderTexture, ScreenPosition, Radius, NumberOfSides, RenderColor) }; } catch (e) {};
try { let fnprepatch_271 = Canvas.prototype.K2_DrawMaterial;Canvas.prototype.K2_DrawMaterial = function (RenderMaterial, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize = {"X":1,"Y":1}, Rotation = 0, PivotPoint = {"X":0.5,"Y":0.5}) { return fnprepatch_271.call(this, RenderMaterial, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize, Rotation, PivotPoint) }; } catch (e) {};
try { let fnprepatch_272 = Canvas.prototype.K2_DrawLine;Canvas.prototype.K2_DrawLine = function (ScreenPositionA, ScreenPositionB, Thickness = 1, RenderColor = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_272.call(this, ScreenPositionA, ScreenPositionB, Thickness, RenderColor) }; } catch (e) {};
try { let fnprepatch_273 = Canvas.prototype.K2_DrawBox;Canvas.prototype.K2_DrawBox = function (ScreenPosition, ScreenSize, Thickness = 1, RenderColor = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_273.call(this, ScreenPosition, ScreenSize, Thickness, RenderColor) }; } catch (e) {};
try { let fnprepatch_274 = Canvas.prototype.K2_DrawBorder;Canvas.prototype.K2_DrawBorder = function (BorderTexture, BackgroundTexture, LeftBorderTexture, RightBorderTexture, TopBorderTexture, BottomBorderTexture, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize = {"X":1,"Y":1}, RenderColor = {"R":1,"G":1,"B":1,"A":1}, BorderScale = {"X":0.10000000149011612,"Y":0.10000000149011612}, BackgroundScale = {"X":0.10000000149011612,"Y":0.10000000149011612}, Rotation = 0, PivotPoint = {"X":0.5,"Y":0.5}, CornerSize) { return fnprepatch_274.call(this, BorderTexture, BackgroundTexture, LeftBorderTexture, RightBorderTexture, TopBorderTexture, BottomBorderTexture, ScreenPosition, ScreenSize, CoordinatePosition, CoordinateSize, RenderColor, BorderScale, BackgroundScale, Rotation, PivotPoint, CornerSize) }; } catch (e) {};
try { Canvas.prototype.ClippedTextSize = Canvas.prototype.K2_TextSize; } catch (e) {};
try { Canvas.prototype.WrappedTextSize = Canvas.prototype.K2_StrLen; } catch (e) {};
try { Canvas.prototype.Project = Canvas.prototype.K2_Project; } catch (e) {};
try { Canvas.prototype.DrawTriangles = Canvas.prototype.K2_DrawTriangle; } catch (e) {};
try { Canvas.prototype.DrawTexture = Canvas.prototype.K2_DrawTexture; } catch (e) {};
try { Canvas.prototype.DrawText = Canvas.prototype.K2_DrawText; } catch (e) {};
try { Canvas.prototype.DrawPolygon = Canvas.prototype.K2_DrawPolygon; } catch (e) {};
try { Canvas.prototype.DrawMaterialTriangles = Canvas.prototype.K2_DrawMaterialTriangle; } catch (e) {};
try { Canvas.prototype.DrawMaterial = Canvas.prototype.K2_DrawMaterial; } catch (e) {};
try { Canvas.prototype.DrawLine = Canvas.prototype.K2_DrawLine; } catch (e) {};
try { Canvas.prototype.DrawBox = Canvas.prototype.K2_DrawBox; } catch (e) {};
try { Canvas.prototype.DrawBorder = Canvas.prototype.K2_DrawBorder; } catch (e) {};
try { Canvas.prototype.Deproject = Canvas.prototype.K2_Deproject; } catch (e) {};
try { TextureRenderTarget2D.prototype.RenderTargetCreateStaticTextureEditorOnly = TextureRenderTarget2D.prototype.RenderTargetCreateStaticTexture2DEditorOnly; } catch (e) {};
try { let fnprepatch_275 = CanvasRenderTarget2D.prototype.CreateCanvasRenderTarget2D;CanvasRenderTarget2D.prototype.CreateCanvasRenderTarget2D = function (WorldContextObject, CanvasRenderTarget2DClass, Width = 1024, Height = 1024) { return fnprepatch_275.call(this, WorldContextObject, CanvasRenderTarget2DClass, Width, Height) }; } catch (e) {};
try { let fnprepatch_276 = CapsuleComponent.prototype.SetCapsuleSize;CapsuleComponent.prototype.SetCapsuleSize = function (InRadius, InHalfHeight, bUpdateOverlaps = true) { return fnprepatch_276.call(this, InRadius, InHalfHeight, bUpdateOverlaps) }; } catch (e) {};
try { let fnprepatch_277 = CapsuleComponent.prototype.SetCapsuleRadius;CapsuleComponent.prototype.SetCapsuleRadius = function (Radius, bUpdateOverlaps = true) { return fnprepatch_277.call(this, Radius, bUpdateOverlaps) }; } catch (e) {};
try { let fnprepatch_278 = CapsuleComponent.prototype.SetCapsuleHalfHeight;CapsuleComponent.prototype.SetCapsuleHalfHeight = function (HalfHeight, bUpdateOverlaps = true) { return fnprepatch_278.call(this, HalfHeight, bUpdateOverlaps) }; } catch (e) {};
try { let fnprepatch_279 = MovementComponent.prototype.K2_MoveUpdatedComponent;MovementComponent.prototype.K2_MoveUpdatedComponent = function (Delta, NewRotation, OutHit, bSweep = true, bTeleport = false) { return fnprepatch_279.call(this, Delta, NewRotation, OutHit, bSweep, bTeleport) }; } catch (e) {};
try { MovementComponent.prototype.MoveUpdatedComponent = MovementComponent.prototype.K2_MoveUpdatedComponent; } catch (e) {};
try { MovementComponent.prototype.GetModifiedMaxSpeed = MovementComponent.prototype.K2_GetModifiedMaxSpeed; } catch (e) {};
try { MovementComponent.prototype.GetMaxSpeedModifier = MovementComponent.prototype.K2_GetMaxSpeedModifier; } catch (e) {};
try { let fnprepatch_280 = PawnMovementComponent.prototype.AddInputVector;PawnMovementComponent.prototype.AddInputVector = function (WorldVector, bForce = false) { return fnprepatch_280.call(this, WorldVector, bForce) }; } catch (e) {};
try { PawnMovementComponent.prototype.GetInputVector = PawnMovementComponent.prototype.K2_GetInputVector; } catch (e) {};
try { let fnprepatch_281 = CharacterMovementComponent.prototype.SetMovementMode;CharacterMovementComponent.prototype.SetMovementMode = function (NewMovementMode, NewCustomMode = 0) { return fnprepatch_281.call(this, NewMovementMode, NewCustomMode) }; } catch (e) {};
try { let fnprepatch_282 = CharacterMovementComponent.prototype.AddImpulse;CharacterMovementComponent.prototype.AddImpulse = function (Impulse, bVelocityChange = false) { return fnprepatch_282.call(this, Impulse, bVelocityChange) }; } catch (e) {};
try { CharacterMovementComponent.prototype.GetWalkableFloorZ = CharacterMovementComponent.prototype.K2_GetWalkableFloorZ; } catch (e) {};
try { CharacterMovementComponent.prototype.GetWalkableFloorAngle = CharacterMovementComponent.prototype.K2_GetWalkableFloorAngle; } catch (e) {};
try { CharacterMovementComponent.prototype.GetModifiedMaxAcceleration = CharacterMovementComponent.prototype.K2_GetModifiedMaxAcceleration; } catch (e) {};
try { CharacterMovementComponent.prototype.FindFloor = CharacterMovementComponent.prototype.K2_FindFloor; } catch (e) {};
try { CharacterMovementComponent.prototype.ComputeFloorDistance = CharacterMovementComponent.prototype.K2_ComputeFloorDist; } catch (e) {};
try { CheatManager.prototype.InitCheatManager = CheatManager.prototype.ReceiveInitCheatManager; } catch (e) {};
try { CheatManager.prototype.Shutdown = CheatManager.prototype.ReceiveEndPlay; } catch (e) {};
try { Texture2D.prototype.GetSizeY = Texture2D.prototype.Blueprint_GetSizeY; } catch (e) {};
try { Texture2D.prototype.GetSizeX = Texture2D.prototype.Blueprint_GetSizeX; } catch (e) {};
try { DebugCameraController.prototype.OnDeactivate = DebugCameraController.prototype.ReceiveOnDeactivate; } catch (e) {};
try { DebugCameraController.prototype.OnActorSelected = DebugCameraController.prototype.ReceiveOnActorSelected; } catch (e) {};
try { DebugCameraController.prototype.OnActivate = DebugCameraController.prototype.ReceiveOnActivate; } catch (e) {};
try { let fnprepatch_283 = HUD.prototype.ShowDebug;HUD.prototype.ShowDebug = function (DebugType = "None") { return fnprepatch_283.call(this, DebugType) }; } catch (e) {};
try { let fnprepatch_284 = HUD.prototype.GetTextSize;HUD.prototype.GetTextSize = function (Text, OutWidth, OutHeight, Font = undefined, Scale = 1) { return fnprepatch_284.call(this, Text, OutWidth, OutHeight, Font, Scale) }; } catch (e) {};
try { let fnprepatch_285 = HUD.prototype.GetActorsInSelectionRectangle;HUD.prototype.GetActorsInSelectionRectangle = function (ClassFilter, FirstPoint, SecondPoint, OutActors, bIncludeNonCollidingComponents = true, bActorMustBeFullyEnclosed = false) { return fnprepatch_285.call(this, ClassFilter, FirstPoint, SecondPoint, OutActors, bIncludeNonCollidingComponents, bActorMustBeFullyEnclosed) }; } catch (e) {};
try { let fnprepatch_286 = HUD.prototype.DrawTextureSimple;HUD.prototype.DrawTextureSimple = function (Texture, ScreenX, ScreenY, Scale = 1, bScalePosition = false) { return fnprepatch_286.call(this, Texture, ScreenX, ScreenY, Scale, bScalePosition) }; } catch (e) {};
try { let fnprepatch_287 = HUD.prototype.DrawTexture;HUD.prototype.DrawTexture = function (Texture, ScreenX, ScreenY, ScreenW, ScreenH, TextureU, TextureV, TextureUWidth, TextureVHeight, TintColor = {"R":1,"G":1,"B":1,"A":1}, BlendMode = "BLEND_Translucent", Scale = 1, bScalePosition = false, Rotation = 0, RotPivot) { return fnprepatch_287.call(this, Texture, ScreenX, ScreenY, ScreenW, ScreenH, TextureU, TextureV, TextureUWidth, TextureVHeight, TintColor, BlendMode, Scale, bScalePosition, Rotation, RotPivot) }; } catch (e) {};
try { let fnprepatch_288 = HUD.prototype.DrawText;HUD.prototype.DrawText = function (Text, TextColor, ScreenX, ScreenY, Font = undefined, Scale = 1, bScalePosition = false) { return fnprepatch_288.call(this, Text, TextColor, ScreenX, ScreenY, Font, Scale, bScalePosition) }; } catch (e) {};
try { let fnprepatch_289 = HUD.prototype.DrawMaterialTriangle;HUD.prototype.DrawMaterialTriangle = function (Material, V0_Pos, V1_Pos, V2_Pos, V0_UV, V1_UV, V2_UV, V0_Color = {"R":1,"G":1,"B":1,"A":1}, V1_Color = {"R":1,"G":1,"B":1,"A":1}, V2_Color = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_289.call(this, Material, V0_Pos, V1_Pos, V2_Pos, V0_UV, V1_UV, V2_UV, V0_Color, V1_Color, V2_Color) }; } catch (e) {};
try { let fnprepatch_290 = HUD.prototype.DrawMaterialSimple;HUD.prototype.DrawMaterialSimple = function (Material, ScreenX, ScreenY, ScreenW, ScreenH, Scale = 1, bScalePosition = false) { return fnprepatch_290.call(this, Material, ScreenX, ScreenY, ScreenW, ScreenH, Scale, bScalePosition) }; } catch (e) {};
try { let fnprepatch_291 = HUD.prototype.DrawMaterial;HUD.prototype.DrawMaterial = function (Material, ScreenX, ScreenY, ScreenW, ScreenH, MaterialU, MaterialV, MaterialUWidth, MaterialVHeight, Scale = 1, bScalePosition = false, Rotation = 0, RotPivot) { return fnprepatch_291.call(this, Material, ScreenX, ScreenY, ScreenW, ScreenH, MaterialU, MaterialV, MaterialUWidth, MaterialVHeight, Scale, bScalePosition, Rotation, RotPivot) }; } catch (e) {};
try { let fnprepatch_292 = HUD.prototype.DrawLine;HUD.prototype.DrawLine = function (StartScreenX, StartScreenY, EndScreenX, EndScreenY, LineColor, LineThickness = 0) { return fnprepatch_292.call(this, StartScreenX, StartScreenY, EndScreenX, EndScreenY, LineColor, LineThickness) }; } catch (e) {};
try { let fnprepatch_293 = HUD.prototype.AddHitBox;HUD.prototype.AddHitBox = function (Position, Size, InName, bConsumesInput, Priority = 0) { return fnprepatch_293.call(this, Position, Size, InName, bConsumesInput, Priority) }; } catch (e) {};
try { HUD.prototype.HitBoxReleased = HUD.prototype.ReceiveHitBoxRelease; } catch (e) {};
try { HUD.prototype.HitBoxEndCursorOver = HUD.prototype.ReceiveHitBoxEndCursorOver; } catch (e) {};
try { HUD.prototype.HitBoxClicked = HUD.prototype.ReceiveHitBoxClick; } catch (e) {};
try { HUD.prototype.HitBoxBeginCursorOver = HUD.prototype.ReceiveHitBoxBeginCursorOver; } catch (e) {};
try { let fnprepatch_294 = DecalComponent.prototype.SetFadeOut;DecalComponent.prototype.SetFadeOut = function (StartDelay, Duration, DestroyOwnerAfterFade = true) { return fnprepatch_294.call(this, StartDelay, Duration, DestroyOwnerAfterFade) }; } catch (e) {};
try { let fnprepatch_295 = LightComponent.prototype.SetLightColor;LightComponent.prototype.SetLightColor = function (NewLightColor, bSRGB = true) { return fnprepatch_295.call(this, NewLightColor, bSRGB) }; } catch (e) {};
try { LightComponent.prototype.SetUseIESIntensity = LightComponent.prototype.SetUseIESBrightness; } catch (e) {};
try { LightComponent.prototype.SetIESIntensityScale = LightComponent.prototype.SetIESBrightnessScale; } catch (e) {};
try { let fnprepatch_296 = SphereComponent.prototype.SetSphereRadius;SphereComponent.prototype.SetSphereRadius = function (InSphereRadius, bUpdateOverlaps = true) { return fnprepatch_296.call(this, InSphereRadius, bUpdateOverlaps) }; } catch (e) {};
try { let fnprepatch_297 = ForceFeedbackComponent.prototype.Play;ForceFeedbackComponent.prototype.Play = function (StartTime = 0) { return fnprepatch_297.call(this, StartTime) }; } catch (e) {};
try { ForceFeedbackComponent.prototype.GetAttenuationSettingsToApply = ForceFeedbackComponent.prototype.BP_GetAttenuationSettingsToApply; } catch (e) {};
try { let fnprepatch_298 = GameplayStatics.prototype.SuggestProjectileVelocity_CustomArc;GameplayStatics.prototype.SuggestProjectileVelocity_CustomArc = function (WorldContextObject, OutLaunchVelocity, StartPos, EndPos, OverrideGravityZ = 0, ArcParam = 0.5) { return fnprepatch_298.call(this, WorldContextObject, OutLaunchVelocity, StartPos, EndPos, OverrideGravityZ, ArcParam) }; } catch (e) {};
try { let fnprepatch_299 = GameplayStatics.prototype.SpawnSoundAttached;GameplayStatics.prototype.SpawnSoundAttached = function (Sound, AttachToComponent, AttachPointName = "None", Location, Rotation, LocationType = "KeepRelativeOffset", bStopWhenAttachedToDestroyed = false, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, ConcurrencySettings = undefined, bAutoDestroy = true) { return fnprepatch_299.call(this, Sound, AttachToComponent, AttachPointName, Location, Rotation, LocationType, bStopWhenAttachedToDestroyed, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, ConcurrencySettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_300 = GameplayStatics.prototype.SpawnSoundAtLocation;GameplayStatics.prototype.SpawnSoundAtLocation = function (WorldContextObject, Sound, Location, Rotation, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, ConcurrencySettings = undefined, bAutoDestroy = true) { return fnprepatch_300.call(this, WorldContextObject, Sound, Location, Rotation, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, ConcurrencySettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_301 = GameplayStatics.prototype.SpawnSound2D;GameplayStatics.prototype.SpawnSound2D = function (WorldContextObject, Sound, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, ConcurrencySettings = undefined, bPersistAcrossLevelTransition = false, bAutoDestroy = true) { return fnprepatch_301.call(this, WorldContextObject, Sound, VolumeMultiplier, PitchMultiplier, StartTime, ConcurrencySettings, bPersistAcrossLevelTransition, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_302 = GameplayStatics.prototype.SpawnForceFeedbackAttached;GameplayStatics.prototype.SpawnForceFeedbackAttached = function (ForceFeedbackEffect, AttachToComponent, AttachPointName = "None", Location, Rotation, LocationType = "KeepRelativeOffset", bStopWhenAttachedToDestroyed = false, bLooping = false, IntensityMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, bAutoDestroy = true) { return fnprepatch_302.call(this, ForceFeedbackEffect, AttachToComponent, AttachPointName, Location, Rotation, LocationType, bStopWhenAttachedToDestroyed, bLooping, IntensityMultiplier, StartTime, AttenuationSettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_303 = GameplayStatics.prototype.SpawnForceFeedbackAtLocation;GameplayStatics.prototype.SpawnForceFeedbackAtLocation = function (WorldContextObject, ForceFeedbackEffect, Location, Rotation, bLooping = false, IntensityMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, bAutoDestroy = true) { return fnprepatch_303.call(this, WorldContextObject, ForceFeedbackEffect, Location, Rotation, bLooping, IntensityMultiplier, StartTime, AttenuationSettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_304 = GameplayStatics.prototype.SpawnEmitterAttached;GameplayStatics.prototype.SpawnEmitterAttached = function (EmitterTemplate, AttachToComponent, AttachPointName = "None", Location, Rotation, Scale, LocationType = "KeepRelativeOffset", bAutoDestroy = true, PoolingMethod = "None") { return fnprepatch_304.call(this, EmitterTemplate, AttachToComponent, AttachPointName, Location, Rotation, Scale, LocationType, bAutoDestroy, PoolingMethod) }; } catch (e) {};
try { let fnprepatch_305 = GameplayStatics.prototype.SpawnEmitterAtLocation;GameplayStatics.prototype.SpawnEmitterAtLocation = function (WorldContextObject, EmitterTemplate, Location, Rotation, Scale, bAutoDestroy = true, PoolingMethod = "None") { return fnprepatch_305.call(this, WorldContextObject, EmitterTemplate, Location, Rotation, Scale, bAutoDestroy, PoolingMethod) }; } catch (e) {};
try { let fnprepatch_306 = GameplayStatics.prototype.SpawnDialogueAttached;GameplayStatics.prototype.SpawnDialogueAttached = function (Dialogue, Context, AttachToComponent, AttachPointName = "None", Location, Rotation, LocationType = "KeepRelativeOffset", bStopWhenAttachedToDestroyed = false, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, bAutoDestroy = true) { return fnprepatch_306.call(this, Dialogue, Context, AttachToComponent, AttachPointName, Location, Rotation, LocationType, bStopWhenAttachedToDestroyed, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_307 = GameplayStatics.prototype.SpawnDialogueAtLocation;GameplayStatics.prototype.SpawnDialogueAtLocation = function (WorldContextObject, Dialogue, Context, Location, Rotation, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, bAutoDestroy = true) { return fnprepatch_307.call(this, WorldContextObject, Dialogue, Context, Location, Rotation, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_308 = GameplayStatics.prototype.SpawnDialogue2D;GameplayStatics.prototype.SpawnDialogue2D = function (WorldContextObject, Dialogue, Context, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, bAutoDestroy = true) { return fnprepatch_308.call(this, WorldContextObject, Dialogue, Context, VolumeMultiplier, PitchMultiplier, StartTime, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_309 = GameplayStatics.prototype.SpawnDecalAttached;GameplayStatics.prototype.SpawnDecalAttached = function (DecalMaterial, DecalSize, AttachToComponent, AttachPointName = "None", Location, Rotation, LocationType = "KeepRelativeOffset", LifeSpan = 0) { return fnprepatch_309.call(this, DecalMaterial, DecalSize, AttachToComponent, AttachPointName, Location, Rotation, LocationType, LifeSpan) }; } catch (e) {};
try { let fnprepatch_310 = GameplayStatics.prototype.SpawnDecalAtLocation;GameplayStatics.prototype.SpawnDecalAtLocation = function (WorldContextObject, DecalMaterial, DecalSize, Location, Rotation, LifeSpan = 0) { return fnprepatch_310.call(this, WorldContextObject, DecalMaterial, DecalSize, Location, Rotation, LifeSpan) }; } catch (e) {};
try { let fnprepatch_311 = GameplayStatics.prototype.SetSoundMixClassOverride;GameplayStatics.prototype.SetSoundMixClassOverride = function (WorldContextObject, InSoundMixModifier, InSoundClass, Volume = 1, Pitch = 1, FadeInTime = 1, bApplyToChildren = true) { return fnprepatch_311.call(this, WorldContextObject, InSoundMixModifier, InSoundClass, Volume, Pitch, FadeInTime, bApplyToChildren) }; } catch (e) {};
try { let fnprepatch_312 = GameplayStatics.prototype.SetGlobalListenerFocusParameters;GameplayStatics.prototype.SetGlobalListenerFocusParameters = function (WorldContextObject, FocusAzimuthScale = 1, NonFocusAzimuthScale = 1, FocusDistanceScale = 1, NonFocusDistanceScale = 1, FocusVolumeScale = 1, NonFocusVolumeScale = 1, FocusPriorityScale = 1, NonFocusPriorityScale = 1) { return fnprepatch_312.call(this, WorldContextObject, FocusAzimuthScale, NonFocusAzimuthScale, FocusDistanceScale, NonFocusDistanceScale, FocusVolumeScale, NonFocusVolumeScale, FocusPriorityScale, NonFocusPriorityScale) }; } catch (e) {};
try { let fnprepatch_313 = GameplayStatics.prototype.ProjectWorldToScreen;GameplayStatics.prototype.ProjectWorldToScreen = function (Player, WorldPosition, ScreenPosition, bPlayerViewportRelative = false) { return fnprepatch_313.call(this, Player, WorldPosition, ScreenPosition, bPlayerViewportRelative) }; } catch (e) {};
try { let fnprepatch_314 = GameplayStatics.prototype.PlayWorldCameraShake;GameplayStatics.prototype.PlayWorldCameraShake = function (WorldContextObject, Shake, Epicenter, InnerRadius, OuterRadius, Falloff = 1, bOrientShakeTowardsEpicenter = false) { return fnprepatch_314.call(this, WorldContextObject, Shake, Epicenter, InnerRadius, OuterRadius, Falloff, bOrientShakeTowardsEpicenter) }; } catch (e) {};
try { let fnprepatch_315 = GameplayStatics.prototype.PlaySoundAtLocation;GameplayStatics.prototype.PlaySoundAtLocation = function (WorldContextObject, Sound, Location, Rotation, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined, ConcurrencySettings = undefined, OwningActor = undefined) { return fnprepatch_315.call(this, WorldContextObject, Sound, Location, Rotation, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings, ConcurrencySettings, OwningActor) }; } catch (e) {};
try { let fnprepatch_316 = GameplayStatics.prototype.PlaySound2D;GameplayStatics.prototype.PlaySound2D = function (WorldContextObject, Sound, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, ConcurrencySettings = undefined, OwningActor = undefined) { return fnprepatch_316.call(this, WorldContextObject, Sound, VolumeMultiplier, PitchMultiplier, StartTime, ConcurrencySettings, OwningActor) }; } catch (e) {};
try { let fnprepatch_317 = GameplayStatics.prototype.PlayDialogueAtLocation;GameplayStatics.prototype.PlayDialogueAtLocation = function (WorldContextObject, Dialogue, Context, Location, Rotation, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, AttenuationSettings = undefined) { return fnprepatch_317.call(this, WorldContextObject, Dialogue, Context, Location, Rotation, VolumeMultiplier, PitchMultiplier, StartTime, AttenuationSettings) }; } catch (e) {};
try { let fnprepatch_318 = GameplayStatics.prototype.PlayDialogue2D;GameplayStatics.prototype.PlayDialogue2D = function (WorldContextObject, Dialogue, Context, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0) { return fnprepatch_318.call(this, WorldContextObject, Dialogue, Context, VolumeMultiplier, PitchMultiplier, StartTime) }; } catch (e) {};
try { let fnprepatch_319 = GameplayStatics.prototype.OpenLevel;GameplayStatics.prototype.OpenLevel = function (WorldContextObject, LevelName, bAbsolute = true, Options) { return fnprepatch_319.call(this, WorldContextObject, LevelName, bAbsolute, Options) }; } catch (e) {};
try { let fnprepatch_320 = GameplayStatics.prototype.GetCurrentLevelName;GameplayStatics.prototype.GetCurrentLevelName = function (WorldContextObject, bRemovePrefixString = true) { return fnprepatch_320.call(this, WorldContextObject, bRemovePrefixString) }; } catch (e) {};
try { let fnprepatch_321 = GameplayStatics.prototype.CreateSound2D;GameplayStatics.prototype.CreateSound2D = function (WorldContextObject, Sound, VolumeMultiplier = 1, PitchMultiplier = 1, StartTime = 0, ConcurrencySettings = undefined, bPersistAcrossLevelTransition = false, bAutoDestroy = true) { return fnprepatch_321.call(this, WorldContextObject, Sound, VolumeMultiplier, PitchMultiplier, StartTime, ConcurrencySettings, bPersistAcrossLevelTransition, bAutoDestroy) }; } catch (e) {};
try { let fnprepatch_322 = GameplayStatics.prototype.CreatePlayer;GameplayStatics.prototype.CreatePlayer = function (WorldContextObject, ControllerId = -1, bSpawnPlayerController = true) { return fnprepatch_322.call(this, WorldContextObject, ControllerId, bSpawnPlayerController) }; } catch (e) {};
try { let fnprepatch_323 = GameplayStatics.prototype.ClearSoundMixClassOverride;GameplayStatics.prototype.ClearSoundMixClassOverride = function (WorldContextObject, InSoundMixModifier, InSoundClass, FadeOutTime = 1) { return fnprepatch_323.call(this, WorldContextObject, InSoundMixModifier, InSoundClass, FadeOutTime) }; } catch (e) {};
try { let fnprepatch_324 = GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByTraceChannel;GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByTraceChannel = function (WorldContextObject, OutHit, OutPathPositions, OutLastTraceDestination, StartPos, LaunchVelocity, bTracePath, ProjectileRadius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, DrawDebugTime, SimFrequency = 15, MaxSimTime = 2, OverrideGravityZ = 0) { return fnprepatch_324.call(this, WorldContextObject, OutHit, OutPathPositions, OutLastTraceDestination, StartPos, LaunchVelocity, bTracePath, ProjectileRadius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, DrawDebugTime, SimFrequency, MaxSimTime, OverrideGravityZ) }; } catch (e) {};
try { let fnprepatch_325 = GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByObjectType;GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByObjectType = function (WorldContextObject, OutHit, OutPathPositions, OutLastTraceDestination, StartPos, LaunchVelocity, bTracePath, ProjectileRadius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, DrawDebugTime, SimFrequency = 15, MaxSimTime = 2, OverrideGravityZ = 0) { return fnprepatch_325.call(this, WorldContextObject, OutHit, OutPathPositions, OutLastTraceDestination, StartPos, LaunchVelocity, bTracePath, ProjectileRadius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, DrawDebugTime, SimFrequency, MaxSimTime, OverrideGravityZ) }; } catch (e) {};
try { let fnprepatch_326 = GameplayStatics.prototype.BeginSpawningActorFromClass;GameplayStatics.prototype.BeginSpawningActorFromClass = function (WorldContextObject, ActorClass, SpawnTransform, bNoCollisionFail = false, Owner = undefined) { return fnprepatch_326.call(this, WorldContextObject, ActorClass, SpawnTransform, bNoCollisionFail, Owner) }; } catch (e) {};
try { let fnprepatch_327 = GameplayStatics.prototype.BeginDeferredActorSpawnFromClass;GameplayStatics.prototype.BeginDeferredActorSpawnFromClass = function (WorldContextObject, ActorClass, SpawnTransform, CollisionHandlingOverride = "Undefined", Owner = undefined) { return fnprepatch_327.call(this, WorldContextObject, ActorClass, SpawnTransform, CollisionHandlingOverride, Owner) }; } catch (e) {};
try { let fnprepatch_328 = GameplayStatics.prototype.ApplyRadialDamageWithFalloff;GameplayStatics.prototype.ApplyRadialDamageWithFalloff = function (WorldContextObject, BaseDamage, MinimumDamage, Origin, DamageInnerRadius, DamageOuterRadius, DamageFalloff, DamageTypeClass, IgnoreActors, DamageCauser = undefined, InstigatedByController = undefined, DamagePreventionChannel = "ECC_Visibility") { return fnprepatch_328.call(this, WorldContextObject, BaseDamage, MinimumDamage, Origin, DamageInnerRadius, DamageOuterRadius, DamageFalloff, DamageTypeClass, IgnoreActors, DamageCauser, InstigatedByController, DamagePreventionChannel) }; } catch (e) {};
try { let fnprepatch_329 = GameplayStatics.prototype.ApplyRadialDamage;GameplayStatics.prototype.ApplyRadialDamage = function (WorldContextObject, BaseDamage, Origin, DamageRadius, DamageTypeClass, IgnoreActors, DamageCauser = undefined, InstigatedByController = undefined, bDoFullDamage = false, DamagePreventionChannel = "ECC_Visibility") { return fnprepatch_329.call(this, WorldContextObject, BaseDamage, Origin, DamageRadius, DamageTypeClass, IgnoreActors, DamageCauser, InstigatedByController, bDoFullDamage, DamagePreventionChannel) }; } catch (e) {};
try { let fnprepatch_330 = GameplayStatics.prototype.ActivateReverbEffect;GameplayStatics.prototype.ActivateReverbEffect = function (WorldContextObject, ReverbEffect, TagName, Priority = 0, Volume = 0.5, FadeTime = 2) { return fnprepatch_330.call(this, WorldContextObject, ReverbEffect, TagName, Priority, Volume, FadeTime) }; } catch (e) {};
try { GameplayStatics.prototype.SuggestProjectileVelocityCustomArc = GameplayStatics.prototype.SuggestProjectileVelocity_CustomArc; } catch (e) {};
try { GameplayStatics.SuggestProjectileVelocityCustomArc = GameplayStatics.SuggestProjectileVelocity_CustomArc; } catch (e) {};
try { GameplayStatics.prototype.GetClass = GameplayStatics.prototype.GetObjectClass; } catch (e) {};
try { GameplayStatics.GetClass = GameplayStatics.GetObjectClass; } catch (e) {};
try { GameplayStatics.prototype.SuggestProjectileVelocity = GameplayStatics.prototype.BlueprintSuggestProjectileVelocity; } catch (e) {};
try { GameplayStatics.SuggestProjectileVelocity = GameplayStatics.BlueprintSuggestProjectileVelocity; } catch (e) {};
try { GameplayStatics.prototype.PredictProjectilePathByTraceChannel = GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByTraceChannel; } catch (e) {};
try { GameplayStatics.PredictProjectilePathByTraceChannel = GameplayStatics.Blueprint_PredictProjectilePath_ByTraceChannel; } catch (e) {};
try { GameplayStatics.prototype.PredictProjectilePathByObjectType = GameplayStatics.prototype.Blueprint_PredictProjectilePath_ByObjectType; } catch (e) {};
try { GameplayStatics.PredictProjectilePathByObjectType = GameplayStatics.Blueprint_PredictProjectilePath_ByObjectType; } catch (e) {};
try { GameplayStatics.prototype.PredictProjectilePath = GameplayStatics.prototype.Blueprint_PredictProjectilePath_Advanced; } catch (e) {};
try { GameplayStatics.PredictProjectilePath = GameplayStatics.Blueprint_PredictProjectilePath_Advanced; } catch (e) {};
try { let fnprepatch_331 = GameUserSettings.prototype.RunHardwareBenchmark;GameUserSettings.prototype.RunHardwareBenchmark = function (WorkScale = 10, CPUMultiplier = 1, GPUMultiplier = 1) { return fnprepatch_331.call(this, WorkScale, CPUMultiplier, GPUMultiplier) }; } catch (e) {};
try { let fnprepatch_332 = GameUserSettings.prototype.LoadSettings;GameUserSettings.prototype.LoadSettings = function (bForceReload = false) { return fnprepatch_332.call(this, bForceReload) }; } catch (e) {};
try { let fnprepatch_333 = GameUserSettings.prototype.EnableHDRDisplayOutput;GameUserSettings.prototype.EnableHDRDisplayOutput = function (bEnable, DisplayNits = 1000) { return fnprepatch_333.call(this, bEnable, DisplayNits) }; } catch (e) {};
try { GameUserSettings.prototype.SetResolutionScaleValue = GameUserSettings.prototype.SetResolutionScaleValueEx; } catch (e) {};
try { GameUserSettings.prototype.SetResolutionScaleValue_Deprecated = GameUserSettings.prototype.SetResolutionScaleValue; } catch (e) {};
try { GameUserSettings.prototype.GetResolutionScaleInformation = GameUserSettings.prototype.GetResolutionScaleInformationEx; } catch (e) {};
try { GameUserSettings.prototype.GetResolutionScaleInformation_Deprecated = GameUserSettings.prototype.GetResolutionScaleInformation; } catch (e) {};
try { let fnprepatch_334 = HealthSnapshotBlueprintLibrary.prototype.LogPerformanceSnapshot;HealthSnapshotBlueprintLibrary.prototype.LogPerformanceSnapshot = function (SnapshotTitle, bResetStats = true) { return fnprepatch_334.call(this, SnapshotTitle, bResetStats) }; } catch (e) {};
try { let fnprepatch_335 = ImportanceSamplingLibrary.prototype.RandomSobolCell3D;ImportanceSamplingLibrary.prototype.RandomSobolCell3D = function (Index, NumCells = 1, Cell, Seed) { return fnprepatch_335.call(this, Index, NumCells, Cell, Seed) }; } catch (e) {};
try { let fnprepatch_336 = ImportanceSamplingLibrary.prototype.RandomSobolCell2D;ImportanceSamplingLibrary.prototype.RandomSobolCell2D = function (Index, NumCells = 1, Cell = {"X":0,"Y":0}, Seed = {"X":0,"Y":0}) { return fnprepatch_336.call(this, Index, NumCells, Cell, Seed) }; } catch (e) {};
try { let fnprepatch_337 = ImportanceSamplingLibrary.prototype.NextSobolCell3D;ImportanceSamplingLibrary.prototype.NextSobolCell3D = function (Index, NumCells = 1, PreviousValue) { return fnprepatch_337.call(this, Index, NumCells, PreviousValue) }; } catch (e) {};
try { let fnprepatch_338 = ImportanceSamplingLibrary.prototype.NextSobolCell2D;ImportanceSamplingLibrary.prototype.NextSobolCell2D = function (Index, NumCells = 1, PreviousValue = {"X":0,"Y":0}) { return fnprepatch_338.call(this, Index, NumCells, PreviousValue) }; } catch (e) {};
try { let fnprepatch_339 = InputSettings.prototype.RemoveAxisMapping;InputSettings.prototype.RemoveAxisMapping = function (KeyMapping, bForceRebuildKeymaps = true) { return fnprepatch_339.call(this, KeyMapping, bForceRebuildKeymaps) }; } catch (e) {};
try { let fnprepatch_340 = InputSettings.prototype.RemoveActionMapping;InputSettings.prototype.RemoveActionMapping = function (KeyMapping, bForceRebuildKeymaps = true) { return fnprepatch_340.call(this, KeyMapping, bForceRebuildKeymaps) }; } catch (e) {};
try { let fnprepatch_341 = InputSettings.prototype.AddAxisMapping;InputSettings.prototype.AddAxisMapping = function (KeyMapping, bForceRebuildKeymaps = true) { return fnprepatch_341.call(this, KeyMapping, bForceRebuildKeymaps) }; } catch (e) {};
try { let fnprepatch_342 = InputSettings.prototype.AddActionMapping;InputSettings.prototype.AddActionMapping = function (KeyMapping, bForceRebuildKeymaps = true) { return fnprepatch_342.call(this, KeyMapping, bForceRebuildKeymaps) }; } catch (e) {};
try { let fnprepatch_343 = InterpToMovementComponent.prototype.RestartMovement;InterpToMovementComponent.prototype.RestartMovement = function (InitialDirection = 1) { return fnprepatch_343.call(this, InitialDirection) }; } catch (e) {};
try { KismetArrayLibrary.prototype.SwapArrayElements = KismetArrayLibrary.prototype.Array_Swap; } catch (e) {};
try { KismetArrayLibrary.SwapArrayElements = KismetArrayLibrary.Array_Swap; } catch (e) {};
try { KismetArrayLibrary.prototype.Shuffle = KismetArrayLibrary.prototype.Array_Shuffle; } catch (e) {};
try { KismetArrayLibrary.Shuffle = KismetArrayLibrary.Array_Shuffle; } catch (e) {};
try { KismetArrayLibrary.prototype.SetArrayElem = KismetArrayLibrary.prototype.Array_Set; } catch (e) {};
try { KismetArrayLibrary.SetArrayElem = KismetArrayLibrary.Array_Set; } catch (e) {};
try { KismetArrayLibrary.prototype.Resize = KismetArrayLibrary.prototype.Array_Resize; } catch (e) {};
try { KismetArrayLibrary.Resize = KismetArrayLibrary.Array_Resize; } catch (e) {};
try { KismetArrayLibrary.prototype.RemoveItem = KismetArrayLibrary.prototype.Array_RemoveItem; } catch (e) {};
try { KismetArrayLibrary.RemoveItem = KismetArrayLibrary.Array_RemoveItem; } catch (e) {};
try { KismetArrayLibrary.prototype.RemoveIndex = KismetArrayLibrary.prototype.Array_Remove; } catch (e) {};
try { KismetArrayLibrary.RemoveIndex = KismetArrayLibrary.Array_Remove; } catch (e) {};
try { KismetArrayLibrary.prototype.Length = KismetArrayLibrary.prototype.Array_Length; } catch (e) {};
try { KismetArrayLibrary.Length = KismetArrayLibrary.Array_Length; } catch (e) {};
try { KismetArrayLibrary.prototype.LastIndex = KismetArrayLibrary.prototype.Array_LastIndex; } catch (e) {};
try { KismetArrayLibrary.LastIndex = KismetArrayLibrary.Array_LastIndex; } catch (e) {};
try { KismetArrayLibrary.prototype.IsValidIndex = KismetArrayLibrary.prototype.Array_IsValidIndex; } catch (e) {};
try { KismetArrayLibrary.IsValidIndex = KismetArrayLibrary.Array_IsValidIndex; } catch (e) {};
try { KismetArrayLibrary.prototype.Insert = KismetArrayLibrary.prototype.Array_Insert; } catch (e) {};
try { KismetArrayLibrary.Insert = KismetArrayLibrary.Array_Insert; } catch (e) {};
try { KismetArrayLibrary.prototype.Identical = KismetArrayLibrary.prototype.Array_Identical; } catch (e) {};
try { KismetArrayLibrary.Identical = KismetArrayLibrary.Array_Identical; } catch (e) {};
try { KismetArrayLibrary.prototype.Get = KismetArrayLibrary.prototype.Array_Get; } catch (e) {};
try { KismetArrayLibrary.Get = KismetArrayLibrary.Array_Get; } catch (e) {};
try { KismetArrayLibrary.prototype.FindItem = KismetArrayLibrary.prototype.Array_Find; } catch (e) {};
try { KismetArrayLibrary.FindItem = KismetArrayLibrary.Array_Find; } catch (e) {};
try { KismetArrayLibrary.prototype.ContainsItem = KismetArrayLibrary.prototype.Array_Contains; } catch (e) {};
try { KismetArrayLibrary.ContainsItem = KismetArrayLibrary.Array_Contains; } catch (e) {};
try { KismetArrayLibrary.prototype.Clear = KismetArrayLibrary.prototype.Array_Clear; } catch (e) {};
try { KismetArrayLibrary.Clear = KismetArrayLibrary.Array_Clear; } catch (e) {};
try { KismetArrayLibrary.prototype.AppendArray = KismetArrayLibrary.prototype.Array_Append; } catch (e) {};
try { KismetArrayLibrary.AppendArray = KismetArrayLibrary.Array_Append; } catch (e) {};
try { KismetArrayLibrary.prototype.AddUnique = KismetArrayLibrary.prototype.Array_AddUnique; } catch (e) {};
try { KismetArrayLibrary.AddUnique = KismetArrayLibrary.Array_AddUnique; } catch (e) {};
try { KismetArrayLibrary.prototype.Add = KismetArrayLibrary.prototype.Array_Add; } catch (e) {};
try { KismetArrayLibrary.Add = KismetArrayLibrary.Array_Add; } catch (e) {};
try { KismetGuidLibrary.prototype.ParseStringtoGuid = KismetGuidLibrary.prototype.Parse_StringToGuid; } catch (e) {};
try { KismetGuidLibrary.ParseStringtoGuid = KismetGuidLibrary.Parse_StringToGuid; } catch (e) {};
try { KismetGuidLibrary.prototype.NotEqual = KismetGuidLibrary.prototype.NotEqual_GuidGuid; } catch (e) {};
try { KismetGuidLibrary.NotEqual = KismetGuidLibrary.NotEqual_GuidGuid; } catch (e) {};
try { KismetGuidLibrary.prototype.IsValid = KismetGuidLibrary.prototype.IsValid_Guid; } catch (e) {};
try { KismetGuidLibrary.IsValid = KismetGuidLibrary.IsValid_Guid; } catch (e) {};
try { KismetGuidLibrary.prototype.Equal = KismetGuidLibrary.prototype.EqualEqual_GuidGuid; } catch (e) {};
try { KismetGuidLibrary.Equal = KismetGuidLibrary.EqualEqual_GuidGuid; } catch (e) {};
try { KismetGuidLibrary.prototype.ToString = KismetGuidLibrary.prototype.Conv_GuidToString; } catch (e) {};
try { KismetGuidLibrary.ToString = KismetGuidLibrary.Conv_GuidToString; } catch (e) {};
try { KismetInputLibrary.prototype.IsTouchEvent = KismetInputLibrary.prototype.PointerEvent_IsTouchEvent; } catch (e) {};
try { KismetInputLibrary.IsTouchEvent = KismetInputLibrary.PointerEvent_IsTouchEvent; } catch (e) {};
try { KismetInputLibrary.prototype.IsMouseButtonDown = KismetInputLibrary.prototype.PointerEvent_IsMouseButtonDown; } catch (e) {};
try { KismetInputLibrary.IsMouseButtonDown = KismetInputLibrary.PointerEvent_IsMouseButtonDown; } catch (e) {};
try { KismetInputLibrary.prototype.GetWheelDelta = KismetInputLibrary.prototype.PointerEvent_GetWheelDelta; } catch (e) {};
try { KismetInputLibrary.GetWheelDelta = KismetInputLibrary.PointerEvent_GetWheelDelta; } catch (e) {};
try { KismetInputLibrary.prototype.GetUserIndex = KismetInputLibrary.prototype.PointerEvent_GetUserIndex; } catch (e) {};
try { KismetInputLibrary.GetUserIndex = KismetInputLibrary.PointerEvent_GetUserIndex; } catch (e) {};
try { KismetInputLibrary.prototype.GetTouchpadIndex = KismetInputLibrary.prototype.PointerEvent_GetTouchpadIndex; } catch (e) {};
try { KismetInputLibrary.GetTouchpadIndex = KismetInputLibrary.PointerEvent_GetTouchpadIndex; } catch (e) {};
try { KismetInputLibrary.prototype.GetScreenSpacePosition = KismetInputLibrary.prototype.PointerEvent_GetScreenSpacePosition; } catch (e) {};
try { KismetInputLibrary.GetScreenSpacePosition = KismetInputLibrary.PointerEvent_GetScreenSpacePosition; } catch (e) {};
try { KismetInputLibrary.prototype.GetPointerIndex = KismetInputLibrary.prototype.PointerEvent_GetPointerIndex; } catch (e) {};
try { KismetInputLibrary.GetPointerIndex = KismetInputLibrary.PointerEvent_GetPointerIndex; } catch (e) {};
try { KismetInputLibrary.prototype.GetLastScreenSpacePosition = KismetInputLibrary.prototype.PointerEvent_GetLastScreenSpacePosition; } catch (e) {};
try { KismetInputLibrary.GetLastScreenSpacePosition = KismetInputLibrary.PointerEvent_GetLastScreenSpacePosition; } catch (e) {};
try { KismetInputLibrary.prototype.GetGestureDelta = KismetInputLibrary.prototype.PointerEvent_GetGestureDelta; } catch (e) {};
try { KismetInputLibrary.GetGestureDelta = KismetInputLibrary.PointerEvent_GetGestureDelta; } catch (e) {};
try { KismetInputLibrary.prototype.GetEffectingButton = KismetInputLibrary.prototype.PointerEvent_GetEffectingButton; } catch (e) {};
try { KismetInputLibrary.GetEffectingButton = KismetInputLibrary.PointerEvent_GetEffectingButton; } catch (e) {};
try { KismetInputLibrary.prototype.GetCursorDelta = KismetInputLibrary.prototype.PointerEvent_GetCursorDelta; } catch (e) {};
try { KismetInputLibrary.GetCursorDelta = KismetInputLibrary.PointerEvent_GetCursorDelta; } catch (e) {};
try { KismetInputLibrary.prototype.IsVectorAxis = KismetInputLibrary.prototype.Key_IsVectorAxis; } catch (e) {};
try { KismetInputLibrary.IsVectorAxis = KismetInputLibrary.Key_IsVectorAxis; } catch (e) {};
try { KismetInputLibrary.prototype.IsValid = KismetInputLibrary.prototype.Key_IsValid; } catch (e) {};
try { KismetInputLibrary.IsValid = KismetInputLibrary.Key_IsValid; } catch (e) {};
try { KismetInputLibrary.prototype.IsMouseButton = KismetInputLibrary.prototype.Key_IsMouseButton; } catch (e) {};
try { KismetInputLibrary.IsMouseButton = KismetInputLibrary.Key_IsMouseButton; } catch (e) {};
try { KismetInputLibrary.prototype.IsModifierKey = KismetInputLibrary.prototype.Key_IsModifierKey; } catch (e) {};
try { KismetInputLibrary.IsModifierKey = KismetInputLibrary.Key_IsModifierKey; } catch (e) {};
try { KismetInputLibrary.prototype.IsKeyboardKey = KismetInputLibrary.prototype.Key_IsKeyboardKey; } catch (e) {};
try { KismetInputLibrary.IsKeyboardKey = KismetInputLibrary.Key_IsKeyboardKey; } catch (e) {};
try { KismetInputLibrary.prototype.IsGamepadKey = KismetInputLibrary.prototype.Key_IsGamepadKey; } catch (e) {};
try { KismetInputLibrary.IsGamepadKey = KismetInputLibrary.Key_IsGamepadKey; } catch (e) {};
try { KismetInputLibrary.prototype.IsFloatAxis = KismetInputLibrary.prototype.Key_IsFloatAxis; } catch (e) {};
try { KismetInputLibrary.IsFloatAxis = KismetInputLibrary.Key_IsFloatAxis; } catch (e) {};
try { KismetInputLibrary.prototype.GetKeyDisplayName = KismetInputLibrary.prototype.Key_GetDisplayName; } catch (e) {};
try { KismetInputLibrary.GetKeyDisplayName = KismetInputLibrary.Key_GetDisplayName; } catch (e) {};
try { KismetInputLibrary.prototype.IsShiftDown = KismetInputLibrary.prototype.InputEvent_IsShiftDown; } catch (e) {};
try { KismetInputLibrary.IsShiftDown = KismetInputLibrary.InputEvent_IsShiftDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsRightShiftDown = KismetInputLibrary.prototype.InputEvent_IsRightShiftDown; } catch (e) {};
try { KismetInputLibrary.IsRightShiftDown = KismetInputLibrary.InputEvent_IsRightShiftDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsRightControlDown = KismetInputLibrary.prototype.InputEvent_IsRightControlDown; } catch (e) {};
try { KismetInputLibrary.IsRightControlDown = KismetInputLibrary.InputEvent_IsRightControlDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsRightCommandDown = KismetInputLibrary.prototype.InputEvent_IsRightCommandDown; } catch (e) {};
try { KismetInputLibrary.IsRightCommandDown = KismetInputLibrary.InputEvent_IsRightCommandDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsRightAltDown = KismetInputLibrary.prototype.InputEvent_IsRightAltDown; } catch (e) {};
try { KismetInputLibrary.IsRightAltDown = KismetInputLibrary.InputEvent_IsRightAltDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsRepeat = KismetInputLibrary.prototype.InputEvent_IsRepeat; } catch (e) {};
try { KismetInputLibrary.IsRepeat = KismetInputLibrary.InputEvent_IsRepeat; } catch (e) {};
try { KismetInputLibrary.prototype.IsLeftShiftDown = KismetInputLibrary.prototype.InputEvent_IsLeftShiftDown; } catch (e) {};
try { KismetInputLibrary.IsLeftShiftDown = KismetInputLibrary.InputEvent_IsLeftShiftDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsLeftControlDown = KismetInputLibrary.prototype.InputEvent_IsLeftControlDown; } catch (e) {};
try { KismetInputLibrary.IsLeftControlDown = KismetInputLibrary.InputEvent_IsLeftControlDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsLeftCommandDown = KismetInputLibrary.prototype.InputEvent_IsLeftCommandDown; } catch (e) {};
try { KismetInputLibrary.IsLeftCommandDown = KismetInputLibrary.InputEvent_IsLeftCommandDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsLeftAltDown = KismetInputLibrary.prototype.InputEvent_IsLeftAltDown; } catch (e) {};
try { KismetInputLibrary.IsLeftAltDown = KismetInputLibrary.InputEvent_IsLeftAltDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsControlDown = KismetInputLibrary.prototype.InputEvent_IsControlDown; } catch (e) {};
try { KismetInputLibrary.IsControlDown = KismetInputLibrary.InputEvent_IsControlDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsCommandDown = KismetInputLibrary.prototype.InputEvent_IsCommandDown; } catch (e) {};
try { KismetInputLibrary.IsCommandDown = KismetInputLibrary.InputEvent_IsCommandDown; } catch (e) {};
try { KismetInputLibrary.prototype.IsAltDown = KismetInputLibrary.prototype.InputEvent_IsAltDown; } catch (e) {};
try { KismetInputLibrary.IsAltDown = KismetInputLibrary.InputEvent_IsAltDown; } catch (e) {};
try { KismetInputLibrary.prototype.Equal = KismetInputLibrary.prototype.EqualEqual_KeyKey; } catch (e) {};
try { KismetInputLibrary.Equal = KismetInputLibrary.EqualEqual_KeyKey; } catch (e) {};
try { KismetInputLibrary.prototype.Equal = KismetInputLibrary.prototype.EqualEqual_InputChordInputChord; } catch (e) {};
try { KismetInputLibrary.Equal = KismetInputLibrary.EqualEqual_InputChordInputChord; } catch (e) {};
try { let fnprepatch_344 = KismetInternationalizationLibrary.prototype.SetCurrentLocale;KismetInternationalizationLibrary.prototype.SetCurrentLocale = function (Culture, SaveToConfig = false) { return fnprepatch_344.call(this, Culture, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_345 = KismetInternationalizationLibrary.prototype.SetCurrentLanguageAndLocale;KismetInternationalizationLibrary.prototype.SetCurrentLanguageAndLocale = function (Culture, SaveToConfig = false) { return fnprepatch_345.call(this, Culture, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_346 = KismetInternationalizationLibrary.prototype.SetCurrentLanguage;KismetInternationalizationLibrary.prototype.SetCurrentLanguage = function (Culture, SaveToConfig = false) { return fnprepatch_346.call(this, Culture, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_347 = KismetInternationalizationLibrary.prototype.SetCurrentCulture;KismetInternationalizationLibrary.prototype.SetCurrentCulture = function (Culture, SaveToConfig = false) { return fnprepatch_347.call(this, Culture, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_348 = KismetInternationalizationLibrary.prototype.SetCurrentAssetGroupCulture;KismetInternationalizationLibrary.prototype.SetCurrentAssetGroupCulture = function (AssetGroup, Culture, SaveToConfig = false) { return fnprepatch_348.call(this, AssetGroup, Culture, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_349 = KismetInternationalizationLibrary.prototype.GetSuitableCulture;KismetInternationalizationLibrary.prototype.GetSuitableCulture = function (AvailableCultures, CultureToMatch, FallbackCulture = "en") { return fnprepatch_349.call(this, AvailableCultures, CultureToMatch, FallbackCulture) }; } catch (e) {};
try { let fnprepatch_350 = KismetInternationalizationLibrary.prototype.GetLocalizedCultures;KismetInternationalizationLibrary.prototype.GetLocalizedCultures = function (IncludeGame = true, IncludeEngine = false, IncludeEditor = false, IncludeAdditional = false) { return fnprepatch_350.call(this, IncludeGame, IncludeEngine, IncludeEditor, IncludeAdditional) }; } catch (e) {};
try { let fnprepatch_351 = KismetInternationalizationLibrary.prototype.GetCultureDisplayName;KismetInternationalizationLibrary.prototype.GetCultureDisplayName = function (Culture, Localized = true) { return fnprepatch_351.call(this, Culture, Localized) }; } catch (e) {};
try { let fnprepatch_352 = KismetInternationalizationLibrary.prototype.ClearCurrentAssetGroupCulture;KismetInternationalizationLibrary.prototype.ClearCurrentAssetGroupCulture = function (AssetGroup, SaveToConfig = false) { return fnprepatch_352.call(this, AssetGroup, SaveToConfig) }; } catch (e) {};
try { let fnprepatch_353 = KismetMaterialLibrary.prototype.CreateDynamicMaterialInstance;KismetMaterialLibrary.prototype.CreateDynamicMaterialInstance = function (WorldContextObject, Parent, OptionalName = "None") { return fnprepatch_353.call(this, WorldContextObject, Parent, OptionalName) }; } catch (e) {};
try { let fnprepatch_354 = KismetMathLibrary.prototype.VectorSpringInterp;KismetMathLibrary.prototype.VectorSpringInterp = function (Current, Target, SpringState, Stiffness, CriticalDampingFactor, DeltaTime, Mass = 1) { return fnprepatch_354.call(this, Current, Target, SpringState, Stiffness, CriticalDampingFactor, DeltaTime, Mass) }; } catch (e) {};
try { let fnprepatch_355 = KismetMathLibrary.prototype.Vector_Normalize;KismetMathLibrary.prototype.Vector_Normalize = function (A, Tolerance = 0) { return fnprepatch_355.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_356 = KismetMathLibrary.prototype.Vector_Normal2D;KismetMathLibrary.prototype.Vector_Normal2D = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_356.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_357 = KismetMathLibrary.prototype.Vector_IsUnit;KismetMathLibrary.prototype.Vector_IsUnit = function (A, SquaredLenthTolerance = 0.00009999999747378752) { return fnprepatch_357.call(this, A, SquaredLenthTolerance) }; } catch (e) {};
try { let fnprepatch_358 = KismetMathLibrary.prototype.Vector_IsUniform;KismetMathLibrary.prototype.Vector_IsUniform = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_358.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_359 = KismetMathLibrary.prototype.Vector_IsNearlyZero;KismetMathLibrary.prototype.Vector_IsNearlyZero = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_359.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_360 = KismetMathLibrary.prototype.Vector4_Normalize3;KismetMathLibrary.prototype.Vector4_Normalize3 = function (A, Tolerance = 0) { return fnprepatch_360.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_361 = KismetMathLibrary.prototype.Vector4_Normal3;KismetMathLibrary.prototype.Vector4_Normal3 = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_361.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_362 = KismetMathLibrary.prototype.Vector4_IsUnit3;KismetMathLibrary.prototype.Vector4_IsUnit3 = function (A, SquaredLenthTolerance = 0.00009999999747378752) { return fnprepatch_362.call(this, A, SquaredLenthTolerance) }; } catch (e) {};
try { let fnprepatch_363 = KismetMathLibrary.prototype.Vector4_IsNearlyZero3;KismetMathLibrary.prototype.Vector4_IsNearlyZero3 = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_363.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_364 = KismetMathLibrary.prototype.VEase;KismetMathLibrary.prototype.VEase = function (A, B, Alpha, EasingFunc, BlendExp = 2, Steps = 2) { return fnprepatch_364.call(this, A, B, Alpha, EasingFunc, BlendExp, Steps) }; } catch (e) {};
try { let fnprepatch_365 = KismetMathLibrary.prototype.TLerp;KismetMathLibrary.prototype.TLerp = function (A, B, Alpha, InterpMode = "QuatInterp") { return fnprepatch_365.call(this, A, B, Alpha, InterpMode) }; } catch (e) {};
try { let fnprepatch_366 = KismetMathLibrary.prototype.TEase;KismetMathLibrary.prototype.TEase = function (A, B, Alpha, EasingFunc, BlendExp = 2, Steps = 2) { return fnprepatch_366.call(this, A, B, Alpha, EasingFunc, BlendExp, Steps) }; } catch (e) {};
try { let fnprepatch_367 = KismetMathLibrary.prototype.Subtract_IntInt;KismetMathLibrary.prototype.Subtract_IntInt = function (A, B = 1) { return fnprepatch_367.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_368 = KismetMathLibrary.prototype.Subtract_Int64Int64;KismetMathLibrary.prototype.Subtract_Int64Int64 = function (A, B = "<Unsupported type>") { return fnprepatch_368.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_369 = KismetMathLibrary.prototype.Subtract_FloatFloat;KismetMathLibrary.prototype.Subtract_FloatFloat = function (A, B = 1) { return fnprepatch_369.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_370 = KismetMathLibrary.prototype.Subtract_ByteByte;KismetMathLibrary.prototype.Subtract_ByteByte = function (A, B = 1) { return fnprepatch_370.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_371 = KismetMathLibrary.prototype.REase;KismetMathLibrary.prototype.REase = function (A, B, Alpha, bShortestPath, EasingFunc, BlendExp = 2, Steps = 2) { return fnprepatch_371.call(this, A, B, Alpha, bShortestPath, EasingFunc, BlendExp, Steps) }; } catch (e) {};
try { let fnprepatch_372 = KismetMathLibrary.prototype.RandomRotator;KismetMathLibrary.prototype.RandomRotator = function (bRoll = false) { return fnprepatch_372.call(this, bRoll) }; } catch (e) {};
try { let fnprepatch_373 = KismetMathLibrary.prototype.Quat_Normalized;KismetMathLibrary.prototype.Quat_Normalized = function (Q, Tolerance = 0.00009999999747378752) { return fnprepatch_373.call(this, Q, Tolerance) }; } catch (e) {};
try { let fnprepatch_374 = KismetMathLibrary.prototype.Quat_Normalize;KismetMathLibrary.prototype.Quat_Normalize = function (Q, Tolerance = 0.00009999999747378752) { return fnprepatch_374.call(this, Q, Tolerance) }; } catch (e) {};
try { let fnprepatch_375 = KismetMathLibrary.prototype.Quat_IsIdentity;KismetMathLibrary.prototype.Quat_IsIdentity = function (Q, Tolerance = 0.00009999999747378752) { return fnprepatch_375.call(this, Q, Tolerance) }; } catch (e) {};
try { let fnprepatch_376 = KismetMathLibrary.prototype.PointsAreCoplanar;KismetMathLibrary.prototype.PointsAreCoplanar = function (Points, Tolerance = 0.10000000149011612) { return fnprepatch_376.call(this, Points, Tolerance) }; } catch (e) {};
try { let fnprepatch_377 = KismetMathLibrary.prototype.Percent_IntInt;KismetMathLibrary.prototype.Percent_IntInt = function (A, B = 1) { return fnprepatch_377.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_378 = KismetMathLibrary.prototype.Percent_FloatFloat;KismetMathLibrary.prototype.Percent_FloatFloat = function (A, B = 1) { return fnprepatch_378.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_379 = KismetMathLibrary.prototype.Percent_ByteByte;KismetMathLibrary.prototype.Percent_ByteByte = function (A, B = 1) { return fnprepatch_379.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_380 = KismetMathLibrary.prototype.NotEqual_VectorVector;KismetMathLibrary.prototype.NotEqual_VectorVector = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_380.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_381 = KismetMathLibrary.prototype.NotEqual_Vector4Vector4;KismetMathLibrary.prototype.NotEqual_Vector4Vector4 = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_381.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_382 = KismetMathLibrary.prototype.NotEqual_Vector2DVector2D;KismetMathLibrary.prototype.NotEqual_Vector2DVector2D = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_382.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_383 = KismetMathLibrary.prototype.NotEqual_RotatorRotator;KismetMathLibrary.prototype.NotEqual_RotatorRotator = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_383.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_384 = KismetMathLibrary.prototype.NotEqual_QuatQuat;KismetMathLibrary.prototype.NotEqual_QuatQuat = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_384.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_385 = KismetMathLibrary.prototype.NormalSafe2D;KismetMathLibrary.prototype.NormalSafe2D = function (A, Tolerance = 0) { return fnprepatch_385.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_386 = KismetMathLibrary.prototype.Normalize2D;KismetMathLibrary.prototype.Normalize2D = function (A, Tolerance = 0) { return fnprepatch_386.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_387 = KismetMathLibrary.prototype.Normal;KismetMathLibrary.prototype.Normal = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_387.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_388 = KismetMathLibrary.prototype.NearlyEqual_TransformTransform;KismetMathLibrary.prototype.NearlyEqual_TransformTransform = function (A, B, LocationTolerance = 0.00009999999747378752, RotationTolerance = 0.00009999999747378752, Scale3DTolerance = 0.00009999999747378752) { return fnprepatch_388.call(this, A, B, LocationTolerance, RotationTolerance, Scale3DTolerance) }; } catch (e) {};
try { let fnprepatch_389 = KismetMathLibrary.prototype.NearlyEqual_FloatFloat;KismetMathLibrary.prototype.NearlyEqual_FloatFloat = function (A, B, ErrorTolerance = 9.999999974752427e-7) { return fnprepatch_389.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_390 = KismetMathLibrary.prototype.MinimumAreaRectangle;KismetMathLibrary.prototype.MinimumAreaRectangle = function (WorldContextObject, InVerts, SampleSurfaceNormal, OutRectCenter, OutRectRotation, OutSideLengthX, OutSideLengthY, bDebugDraw = false) { return fnprepatch_390.call(this, WorldContextObject, InVerts, SampleSurfaceNormal, OutRectCenter, OutRectRotation, OutSideLengthX, OutSideLengthY, bDebugDraw) }; } catch (e) {};
try { let fnprepatch_391 = KismetMathLibrary.prototype.MakeQualifiedFrameTime;KismetMathLibrary.prototype.MakeQualifiedFrameTime = function (Frame, FrameRate, SubFrame = 0) { return fnprepatch_391.call(this, Frame, FrameRate, SubFrame) }; } catch (e) {};
try { let fnprepatch_392 = KismetMathLibrary.prototype.MakePulsatingValue;KismetMathLibrary.prototype.MakePulsatingValue = function (InCurrentTime, InPulsesPerSecond = 1, InPhase = 0) { return fnprepatch_392.call(this, InCurrentTime, InPulsesPerSecond, InPhase) }; } catch (e) {};
try { let fnprepatch_393 = KismetMathLibrary.prototype.MakeFrameRate;KismetMathLibrary.prototype.MakeFrameRate = function (Numerator, Denominator = 1) { return fnprepatch_393.call(this, Numerator, Denominator) }; } catch (e) {};
try { let fnprepatch_394 = KismetMathLibrary.prototype.MakeDateTime;KismetMathLibrary.prototype.MakeDateTime = function (Year, Month, Day, Hour = 0, Minute = 0, Second = 0, Millisecond = 0) { return fnprepatch_394.call(this, Year, Month, Day, Hour, Minute, Second, Millisecond) }; } catch (e) {};
try { let fnprepatch_395 = KismetMathLibrary.prototype.MakeColor;KismetMathLibrary.prototype.MakeColor = function (R, G, B, A = 1) { return fnprepatch_395.call(this, R, G, B, A) }; } catch (e) {};
try { let fnprepatch_396 = KismetMathLibrary.prototype.Log;KismetMathLibrary.prototype.Log = function (A, Base = 1) { return fnprepatch_396.call(this, A, Base) }; } catch (e) {};
try { let fnprepatch_397 = KismetMathLibrary.prototype.LinearColor_SetRGBA;KismetMathLibrary.prototype.LinearColor_SetRGBA = function (InOutColor, R, G, B, A = 1) { return fnprepatch_397.call(this, InOutColor, R, G, B, A) }; } catch (e) {};
try { let fnprepatch_398 = KismetMathLibrary.prototype.LinearColor_SetFromHSV;KismetMathLibrary.prototype.LinearColor_SetFromHSV = function (InOutColor, H, S, V, A = 1) { return fnprepatch_398.call(this, InOutColor, H, S, V, A) }; } catch (e) {};
try { let fnprepatch_399 = KismetMathLibrary.prototype.LinearColor_IsNearEqual;KismetMathLibrary.prototype.LinearColor_IsNearEqual = function (A, B, Tolerance = 0.00009999999747378752) { return fnprepatch_399.call(this, A, B, Tolerance) }; } catch (e) {};
try { let fnprepatch_400 = KismetMathLibrary.prototype.IsNearlyZero2D;KismetMathLibrary.prototype.IsNearlyZero2D = function (A, Tolerance = 0.00009999999747378752) { return fnprepatch_400.call(this, A, Tolerance) }; } catch (e) {};
try { let fnprepatch_401 = KismetMathLibrary.prototype.InRange_IntInt;KismetMathLibrary.prototype.InRange_IntInt = function (Value, Min, Max, InclusiveMin = true, InclusiveMax = true) { return fnprepatch_401.call(this, Value, Min, Max, InclusiveMin, InclusiveMax) }; } catch (e) {};
try { let fnprepatch_402 = KismetMathLibrary.prototype.InRange_Int64Int64;KismetMathLibrary.prototype.InRange_Int64Int64 = function (Value, Min, Max, InclusiveMin = true, InclusiveMax = true) { return fnprepatch_402.call(this, Value, Min, Max, InclusiveMin, InclusiveMax) }; } catch (e) {};
try { let fnprepatch_403 = KismetMathLibrary.prototype.InRange_FloatFloat;KismetMathLibrary.prototype.InRange_FloatFloat = function (Value, Min, Max, InclusiveMin = true, InclusiveMax = true) { return fnprepatch_403.call(this, Value, Min, Max, InclusiveMin, InclusiveMax) }; } catch (e) {};
try { let fnprepatch_404 = KismetMathLibrary.prototype.HSVToRGB;KismetMathLibrary.prototype.HSVToRGB = function (H, S, V, A = 1) { return fnprepatch_404.call(this, H, S, V, A) }; } catch (e) {};
try { let fnprepatch_405 = KismetMathLibrary.prototype.FloatSpringInterp;KismetMathLibrary.prototype.FloatSpringInterp = function (Current, Target, SpringState, Stiffness, CriticalDampingFactor, DeltaTime, Mass = 1) { return fnprepatch_405.call(this, Current, Target, SpringState, Stiffness, CriticalDampingFactor, DeltaTime, Mass) }; } catch (e) {};
try { let fnprepatch_406 = KismetMathLibrary.prototype.EqualEqual_VectorVector;KismetMathLibrary.prototype.EqualEqual_VectorVector = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_406.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_407 = KismetMathLibrary.prototype.EqualEqual_Vector4Vector4;KismetMathLibrary.prototype.EqualEqual_Vector4Vector4 = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_407.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_408 = KismetMathLibrary.prototype.EqualEqual_Vector2DVector2D;KismetMathLibrary.prototype.EqualEqual_Vector2DVector2D = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_408.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_409 = KismetMathLibrary.prototype.EqualEqual_RotatorRotator;KismetMathLibrary.prototype.EqualEqual_RotatorRotator = function (A, B, ErrorTolerance = 0.00009999999747378752) { return fnprepatch_409.call(this, A, B, ErrorTolerance) }; } catch (e) {};
try { let fnprepatch_410 = KismetMathLibrary.prototype.EqualEqual_QuatQuat;KismetMathLibrary.prototype.EqualEqual_QuatQuat = function (A, B, Tolerance = 0.00009999999747378752) { return fnprepatch_410.call(this, A, B, Tolerance) }; } catch (e) {};
try { let fnprepatch_411 = KismetMathLibrary.prototype.Ease;KismetMathLibrary.prototype.Ease = function (A, B, Alpha, EasingFunc, BlendExp = 2, Steps = 2) { return fnprepatch_411.call(this, A, B, Alpha, EasingFunc, BlendExp, Steps) }; } catch (e) {};
try { let fnprepatch_412 = KismetMathLibrary.prototype.Divide_VectorInt;KismetMathLibrary.prototype.Divide_VectorInt = function (A, B = 1) { return fnprepatch_412.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_413 = KismetMathLibrary.prototype.Divide_VectorFloat;KismetMathLibrary.prototype.Divide_VectorFloat = function (A, B = 1) { return fnprepatch_413.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_414 = KismetMathLibrary.prototype.Divide_Vector2DFloat;KismetMathLibrary.prototype.Divide_Vector2DFloat = function (A, B = 1) { return fnprepatch_414.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_415 = KismetMathLibrary.prototype.Divide_IntInt;KismetMathLibrary.prototype.Divide_IntInt = function (A, B = 1) { return fnprepatch_415.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_416 = KismetMathLibrary.prototype.Divide_Int64Int64;KismetMathLibrary.prototype.Divide_Int64Int64 = function (A, B = "<Unsupported type>") { return fnprepatch_416.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_417 = KismetMathLibrary.prototype.Divide_FloatFloat;KismetMathLibrary.prototype.Divide_FloatFloat = function (A, B = 1) { return fnprepatch_417.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_418 = KismetMathLibrary.prototype.Divide_ByteByte;KismetMathLibrary.prototype.Divide_ByteByte = function (A, B = 1) { return fnprepatch_418.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_419 = KismetMathLibrary.prototype.CreateVectorFromYawPitch;KismetMathLibrary.prototype.CreateVectorFromYawPitch = function (Yaw, Pitch, Length = 1) { return fnprepatch_419.call(this, Yaw, Pitch, Length) }; } catch (e) {};
try { let fnprepatch_420 = KismetMathLibrary.prototype.Conv_Vector2DToVector;KismetMathLibrary.prototype.Conv_Vector2DToVector = function (InVector2D, Z = 0) { return fnprepatch_420.call(this, InVector2D, Z) }; } catch (e) {};
try { let fnprepatch_421 = KismetMathLibrary.prototype.Conv_LinearColorToColor;KismetMathLibrary.prototype.Conv_LinearColorToColor = function (InLinearColor, InUseSRGB = true) { return fnprepatch_421.call(this, InLinearColor, InUseSRGB) }; } catch (e) {};
try { let fnprepatch_422 = KismetMathLibrary.prototype.Add_IntInt;KismetMathLibrary.prototype.Add_IntInt = function (A, B = 1) { return fnprepatch_422.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_423 = KismetMathLibrary.prototype.Add_Int64Int64;KismetMathLibrary.prototype.Add_Int64Int64 = function (A, B = "<Unsupported type>") { return fnprepatch_423.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_424 = KismetMathLibrary.prototype.Add_FloatFloat;KismetMathLibrary.prototype.Add_FloatFloat = function (A, B = 1) { return fnprepatch_424.call(this, A, B) }; } catch (e) {};
try { let fnprepatch_425 = KismetMathLibrary.prototype.Add_ByteByte;KismetMathLibrary.prototype.Add_ByteByte = function (A, B = 1) { return fnprepatch_425.call(this, A, B) }; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseXOR = KismetMathLibrary.prototype.Xor_IntInt; } catch (e) {};
try { KismetMathLibrary.BitwiseXOR = KismetMathLibrary.Xor_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseXOR = KismetMathLibrary.prototype.Xor_Int64Int64; } catch (e) {};
try { KismetMathLibrary.BitwiseXOR = KismetMathLibrary.Xor_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.VectorLengthXYSquared = KismetMathLibrary.prototype.VSizeXYSquared; } catch (e) {};
try { KismetMathLibrary.VectorLengthXYSquared = KismetMathLibrary.VSizeXYSquared; } catch (e) {};
try { KismetMathLibrary.prototype.VectorLengthXY = KismetMathLibrary.prototype.VSizeXY; } catch (e) {};
try { KismetMathLibrary.VectorLengthXY = KismetMathLibrary.VSizeXY; } catch (e) {};
try { KismetMathLibrary.prototype.VectorLengthSquared = KismetMathLibrary.prototype.VSizeSquared; } catch (e) {};
try { KismetMathLibrary.VectorLengthSquared = KismetMathLibrary.VSizeSquared; } catch (e) {};
try { KismetMathLibrary.prototype.Vector2dLengthSquared = KismetMathLibrary.prototype.VSize2DSquared; } catch (e) {};
try { KismetMathLibrary.Vector2dLengthSquared = KismetMathLibrary.VSize2DSquared; } catch (e) {};
try { KismetMathLibrary.prototype.Vector2dLength = KismetMathLibrary.prototype.VSize2D; } catch (e) {};
try { KismetMathLibrary.Vector2dLength = KismetMathLibrary.VSize2D; } catch (e) {};
try { KismetMathLibrary.prototype.VectorLength = KismetMathLibrary.prototype.VSize; } catch (e) {};
try { KismetMathLibrary.VectorLength = KismetMathLibrary.VSize; } catch (e) {};
try { KismetMathLibrary.prototype.Lerp = KismetMathLibrary.prototype.VLerp; } catch (e) {};
try { KismetMathLibrary.Lerp = KismetMathLibrary.VLerp; } catch (e) {};
try { KismetMathLibrary.prototype.Reciprocal = KismetMathLibrary.prototype.Vector_Reciprocal; } catch (e) {};
try { KismetMathLibrary.Reciprocal = KismetMathLibrary.Vector_Reciprocal; } catch (e) {};
try { KismetMathLibrary.prototype.Normalunsafe = KismetMathLibrary.prototype.Vector_NormalUnsafe; } catch (e) {};
try { KismetMathLibrary.Normalunsafe = KismetMathLibrary.Vector_NormalUnsafe; } catch (e) {};
try { KismetMathLibrary.prototype.NormalizeInPlace = KismetMathLibrary.prototype.Vector_Normalize; } catch (e) {};
try { KismetMathLibrary.NormalizeInPlace = KismetMathLibrary.Vector_Normalize; } catch (e) {};
try { KismetMathLibrary.prototype.Normalize2D = KismetMathLibrary.prototype.Vector_Normal2D; } catch (e) {};
try { KismetMathLibrary.Normalize2D = KismetMathLibrary.Vector_Normal2D; } catch (e) {};
try { KismetMathLibrary.prototype.IsUnit = KismetMathLibrary.prototype.Vector_IsUnit; } catch (e) {};
try { KismetMathLibrary.IsUnit = KismetMathLibrary.Vector_IsUnit; } catch (e) {};
try { KismetMathLibrary.prototype.IsUniform = KismetMathLibrary.prototype.Vector_IsUniform; } catch (e) {};
try { KismetMathLibrary.IsUniform = KismetMathLibrary.Vector_IsUniform; } catch (e) {};
try { KismetMathLibrary.prototype.IsNormal = KismetMathLibrary.prototype.Vector_IsNormal; } catch (e) {};
try { KismetMathLibrary.IsNormal = KismetMathLibrary.Vector_IsNormal; } catch (e) {};
try { KismetMathLibrary.prototype.DistanceSquared = KismetMathLibrary.prototype.Vector_DistanceSquared; } catch (e) {};
try { KismetMathLibrary.DistanceSquared = KismetMathLibrary.Vector_DistanceSquared; } catch (e) {};
try { KismetMathLibrary.prototype.Distance2DSquared = KismetMathLibrary.prototype.Vector_Distance2DSquared; } catch (e) {};
try { KismetMathLibrary.Distance2DSquared = KismetMathLibrary.Vector_Distance2DSquared; } catch (e) {};
try { KismetMathLibrary.prototype.Distance2D = KismetMathLibrary.prototype.Vector_Distance2D; } catch (e) {};
try { KismetMathLibrary.Distance2D = KismetMathLibrary.Vector_Distance2D; } catch (e) {};
try { KismetMathLibrary.prototype.Distance = KismetMathLibrary.prototype.Vector_Distance; } catch (e) {};
try { KismetMathLibrary.Distance = KismetMathLibrary.Vector_Distance; } catch (e) {};
try { KismetMathLibrary.prototype.LengthXYZSquared = KismetMathLibrary.prototype.Vector4_SizeSquared3; } catch (e) {};
try { KismetMathLibrary.LengthXYZSquared = KismetMathLibrary.Vector4_SizeSquared3; } catch (e) {};
try { KismetMathLibrary.prototype.LengthSquared = KismetMathLibrary.prototype.Vector4_SizeSquared; } catch (e) {};
try { KismetMathLibrary.LengthSquared = KismetMathLibrary.Vector4_SizeSquared; } catch (e) {};
try { KismetMathLibrary.prototype.LengthXYZ = KismetMathLibrary.prototype.Vector4_Size3; } catch (e) {};
try { KismetMathLibrary.LengthXYZ = KismetMathLibrary.Vector4_Size3; } catch (e) {};
try { KismetMathLibrary.prototype.Length = KismetMathLibrary.prototype.Vector4_Size; } catch (e) {};
try { KismetMathLibrary.Length = KismetMathLibrary.Vector4_Size; } catch (e) {};
try { KismetMathLibrary.prototype.NormalunsafeXYZ = KismetMathLibrary.prototype.Vector4_NormalUnsafe3; } catch (e) {};
try { KismetMathLibrary.NormalunsafeXYZ = KismetMathLibrary.Vector4_NormalUnsafe3; } catch (e) {};
try { KismetMathLibrary.prototype.NormalizeInPlaceXYZ = KismetMathLibrary.prototype.Vector4_Normalize3; } catch (e) {};
try { KismetMathLibrary.NormalizeInPlaceXYZ = KismetMathLibrary.Vector4_Normalize3; } catch (e) {};
try { KismetMathLibrary.prototype.NormalizeXYZ = KismetMathLibrary.prototype.Vector4_Normal3; } catch (e) {};
try { KismetMathLibrary.NormalizeXYZ = KismetMathLibrary.Vector4_Normal3; } catch (e) {};
try { KismetMathLibrary.prototype.Negated = KismetMathLibrary.prototype.Vector4_Negated; } catch (e) {};
try { KismetMathLibrary.Negated = KismetMathLibrary.Vector4_Negated; } catch (e) {};
try { KismetMathLibrary.prototype.IsUnitXYZ = KismetMathLibrary.prototype.Vector4_IsUnit3; } catch (e) {};
try { KismetMathLibrary.IsUnitXYZ = KismetMathLibrary.Vector4_IsUnit3; } catch (e) {};
try { KismetMathLibrary.prototype.IsNormalXYZ = KismetMathLibrary.prototype.Vector4_IsNormal3; } catch (e) {};
try { KismetMathLibrary.IsNormalXYZ = KismetMathLibrary.Vector4_IsNormal3; } catch (e) {};
try { KismetMathLibrary.prototype.DotProductXYZ = KismetMathLibrary.prototype.Vector4_DotProduct3; } catch (e) {};
try { KismetMathLibrary.DotProductXYZ = KismetMathLibrary.Vector4_DotProduct3; } catch (e) {};
try { KismetMathLibrary.prototype.DotProduct = KismetMathLibrary.prototype.Vector4_DotProduct; } catch (e) {};
try { KismetMathLibrary.DotProduct = KismetMathLibrary.Vector4_DotProduct; } catch (e) {};
try { KismetMathLibrary.prototype.CrossProductXYZ = KismetMathLibrary.prototype.Vector4_CrossProduct3; } catch (e) {};
try { KismetMathLibrary.CrossProductXYZ = KismetMathLibrary.Vector4_CrossProduct3; } catch (e) {};
try { KismetMathLibrary.prototype.Ease = KismetMathLibrary.prototype.VEase; } catch (e) {};
try { KismetMathLibrary.Ease = KismetMathLibrary.VEase; } catch (e) {};
try { KismetMathLibrary.prototype.Determinant = KismetMathLibrary.prototype.Transform_Determinant; } catch (e) {};
try { KismetMathLibrary.Determinant = KismetMathLibrary.Transform_Determinant; } catch (e) {};
try { KismetMathLibrary.prototype.Tosign = KismetMathLibrary.prototype.ToSign2D; } catch (e) {};
try { KismetMathLibrary.Tosign = KismetMathLibrary.ToSign2D; } catch (e) {};
try { KismetMathLibrary.prototype.ToRounded = KismetMathLibrary.prototype.ToRounded2D; } catch (e) {};
try { KismetMathLibrary.ToRounded = KismetMathLibrary.ToRounded2D; } catch (e) {};
try { KismetMathLibrary.prototype.ToDirectionAndLength = KismetMathLibrary.prototype.ToDirectionAndLength2D; } catch (e) {};
try { KismetMathLibrary.ToDirectionAndLength = KismetMathLibrary.ToDirectionAndLength2D; } catch (e) {};
try { KismetMathLibrary.prototype.Lerp = KismetMathLibrary.prototype.TLerp; } catch (e) {};
try { KismetMathLibrary.Lerp = KismetMathLibrary.TLerp; } catch (e) {};
try { KismetMathLibrary.prototype.ZeroValue = KismetMathLibrary.prototype.TimespanZeroValue; } catch (e) {};
try { KismetMathLibrary.ZeroValue = KismetMathLibrary.TimespanZeroValue; } catch (e) {};
try { KismetMathLibrary.prototype.MinValue = KismetMathLibrary.prototype.TimespanMinValue; } catch (e) {};
try { KismetMathLibrary.MinValue = KismetMathLibrary.TimespanMinValue; } catch (e) {};
try { KismetMathLibrary.prototype.MaxValue = KismetMathLibrary.prototype.TimespanMaxValue; } catch (e) {};
try { KismetMathLibrary.MaxValue = KismetMathLibrary.TimespanMaxValue; } catch (e) {};
try { KismetMathLibrary.prototype.Ease = KismetMathLibrary.prototype.TEase; } catch (e) {};
try { KismetMathLibrary.Ease = KismetMathLibrary.TEase; } catch (e) {};
try { KismetMathLibrary.prototype.Sign = KismetMathLibrary.prototype.SignOfInteger64; } catch (e) {};
try { KismetMathLibrary.Sign = KismetMathLibrary.SignOfInteger64; } catch (e) {};
try { KismetMathLibrary.prototype.Sign = KismetMathLibrary.prototype.SignOfInteger; } catch (e) {};
try { KismetMathLibrary.Sign = KismetMathLibrary.SignOfInteger; } catch (e) {};
try { KismetMathLibrary.prototype.Sign = KismetMathLibrary.prototype.SignOfFloat; } catch (e) {};
try { KismetMathLibrary.Sign = KismetMathLibrary.SignOfFloat; } catch (e) {};
try { KismetMathLibrary.prototype.RoundtoInt64 = KismetMathLibrary.prototype.Round64; } catch (e) {};
try { KismetMathLibrary.RoundtoInt64 = KismetMathLibrary.Round64; } catch (e) {};
try { KismetMathLibrary.prototype.RotateVectorAroundAxis = KismetMathLibrary.prototype.RotateAngleAxis; } catch (e) {};
try { KismetMathLibrary.RotateVectorAroundAxis = KismetMathLibrary.RotateAngleAxis; } catch (e) {};
try { KismetMathLibrary.prototype.Lerp = KismetMathLibrary.prototype.RLerp; } catch (e) {};
try { KismetMathLibrary.Lerp = KismetMathLibrary.RLerp; } catch (e) {};
try { KismetMathLibrary.prototype.RGBtoHSV = KismetMathLibrary.prototype.RGBToHSV_Vector; } catch (e) {};
try { KismetMathLibrary.RGBtoHSV = KismetMathLibrary.RGBToHSV_Vector; } catch (e) {};
try { KismetMathLibrary.prototype.RGBtoHSVlinearcolor = KismetMathLibrary.prototype.RGBLinearToHSV; } catch (e) {};
try { KismetMathLibrary.RGBtoHSVlinearcolor = KismetMathLibrary.RGBLinearToHSV; } catch (e) {};
try { KismetMathLibrary.prototype.Ease = KismetMathLibrary.prototype.REase; } catch (e) {};
try { KismetMathLibrary.Ease = KismetMathLibrary.REase; } catch (e) {};
try { KismetMathLibrary.prototype.VectorUp = KismetMathLibrary.prototype.Quat_VectorUp; } catch (e) {};
try { KismetMathLibrary.VectorUp = KismetMathLibrary.Quat_VectorUp; } catch (e) {};
try { KismetMathLibrary.prototype.VectorRight = KismetMathLibrary.prototype.Quat_VectorRight; } catch (e) {};
try { KismetMathLibrary.VectorRight = KismetMathLibrary.Quat_VectorRight; } catch (e) {};
try { KismetMathLibrary.prototype.VectorForward = KismetMathLibrary.prototype.Quat_VectorForward; } catch (e) {};
try { KismetMathLibrary.VectorForward = KismetMathLibrary.Quat_VectorForward; } catch (e) {};
try { KismetMathLibrary.prototype.UnrotateVector = KismetMathLibrary.prototype.Quat_UnrotateVector; } catch (e) {};
try { KismetMathLibrary.UnrotateVector = KismetMathLibrary.Quat_UnrotateVector; } catch (e) {};
try { KismetMathLibrary.prototype.SizeSquared = KismetMathLibrary.prototype.Quat_SizeSquared; } catch (e) {};
try { KismetMathLibrary.SizeSquared = KismetMathLibrary.Quat_SizeSquared; } catch (e) {};
try { KismetMathLibrary.prototype.Size = KismetMathLibrary.prototype.Quat_Size; } catch (e) {};
try { KismetMathLibrary.Size = KismetMathLibrary.Quat_Size; } catch (e) {};
try { KismetMathLibrary.prototype.SetfromEuler = KismetMathLibrary.prototype.Quat_SetFromEuler; } catch (e) {};
try { KismetMathLibrary.SetfromEuler = KismetMathLibrary.Quat_SetFromEuler; } catch (e) {};
try { KismetMathLibrary.prototype.SetComponents = KismetMathLibrary.prototype.Quat_SetComponents; } catch (e) {};
try { KismetMathLibrary.SetComponents = KismetMathLibrary.Quat_SetComponents; } catch (e) {};
try { KismetMathLibrary.prototype.ToRotator = KismetMathLibrary.prototype.Quat_Rotator; } catch (e) {};
try { KismetMathLibrary.ToRotator = KismetMathLibrary.Quat_Rotator; } catch (e) {};
try { KismetMathLibrary.prototype.RotateVector = KismetMathLibrary.prototype.Quat_RotateVector; } catch (e) {};
try { KismetMathLibrary.RotateVector = KismetMathLibrary.Quat_RotateVector; } catch (e) {};
try { KismetMathLibrary.prototype.Normalized = KismetMathLibrary.prototype.Quat_Normalized; } catch (e) {};
try { KismetMathLibrary.Normalized = KismetMathLibrary.Quat_Normalized; } catch (e) {};
try { KismetMathLibrary.prototype.Normalize = KismetMathLibrary.prototype.Quat_Normalize; } catch (e) {};
try { KismetMathLibrary.Normalize = KismetMathLibrary.Quat_Normalize; } catch (e) {};
try { KismetMathLibrary.prototype.MakefromEuler = KismetMathLibrary.prototype.Quat_MakeFromEuler; } catch (e) {};
try { KismetMathLibrary.MakefromEuler = KismetMathLibrary.Quat_MakeFromEuler; } catch (e) {};
try { KismetMathLibrary.prototype.Log = KismetMathLibrary.prototype.Quat_Log; } catch (e) {};
try { KismetMathLibrary.Log = KismetMathLibrary.Quat_Log; } catch (e) {};
try { KismetMathLibrary.prototype.IsNormalized = KismetMathLibrary.prototype.Quat_IsNormalized; } catch (e) {};
try { KismetMathLibrary.IsNormalized = KismetMathLibrary.Quat_IsNormalized; } catch (e) {};
try { KismetMathLibrary.prototype.IsIdentity = KismetMathLibrary.prototype.Quat_IsIdentity; } catch (e) {};
try { KismetMathLibrary.IsIdentity = KismetMathLibrary.Quat_IsIdentity; } catch (e) {};
try { KismetMathLibrary.prototype.IsFinite = KismetMathLibrary.prototype.Quat_IsFinite; } catch (e) {};
try { KismetMathLibrary.IsFinite = KismetMathLibrary.Quat_IsFinite; } catch (e) {};
try { KismetMathLibrary.prototype.Inversed = KismetMathLibrary.prototype.Quat_Inversed; } catch (e) {};
try { KismetMathLibrary.Inversed = KismetMathLibrary.Quat_Inversed; } catch (e) {};
try { KismetMathLibrary.prototype.RotationAxis = KismetMathLibrary.prototype.Quat_GetRotationAxis; } catch (e) {};
try { KismetMathLibrary.RotationAxis = KismetMathLibrary.Quat_GetRotationAxis; } catch (e) {};
try { KismetMathLibrary.prototype.AxisZ = KismetMathLibrary.prototype.Quat_GetAxisZ; } catch (e) {};
try { KismetMathLibrary.AxisZ = KismetMathLibrary.Quat_GetAxisZ; } catch (e) {};
try { KismetMathLibrary.prototype.AxisY = KismetMathLibrary.prototype.Quat_GetAxisY; } catch (e) {};
try { KismetMathLibrary.AxisY = KismetMathLibrary.Quat_GetAxisY; } catch (e) {};
try { KismetMathLibrary.prototype.AxisX = KismetMathLibrary.prototype.Quat_GetAxisX; } catch (e) {};
try { KismetMathLibrary.AxisX = KismetMathLibrary.Quat_GetAxisX; } catch (e) {};
try { KismetMathLibrary.prototype.Angle = KismetMathLibrary.prototype.Quat_GetAngle; } catch (e) {};
try { KismetMathLibrary.Angle = KismetMathLibrary.Quat_GetAngle; } catch (e) {};
try { KismetMathLibrary.prototype.Exp = KismetMathLibrary.prototype.Quat_Exp; } catch (e) {};
try { KismetMathLibrary.Exp = KismetMathLibrary.Quat_Exp; } catch (e) {};
try { KismetMathLibrary.prototype.Euler = KismetMathLibrary.prototype.Quat_Euler; } catch (e) {};
try { KismetMathLibrary.Euler = KismetMathLibrary.Quat_Euler; } catch (e) {};
try { KismetMathLibrary.prototype.Ensureshortestarcto = KismetMathLibrary.prototype.Quat_EnforceShortestArcWith; } catch (e) {};
try { KismetMathLibrary.Ensureshortestarcto = KismetMathLibrary.Quat_EnforceShortestArcWith; } catch (e) {};
try { KismetMathLibrary.prototype.AngularDistance = KismetMathLibrary.prototype.Quat_AngularDistance; } catch (e) {};
try { KismetMathLibrary.AngularDistance = KismetMathLibrary.Quat_AngularDistance; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseOR = KismetMathLibrary.prototype.Or_IntInt; } catch (e) {};
try { KismetMathLibrary.BitwiseOR = KismetMathLibrary.Or_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseOR = KismetMathLibrary.prototype.Or_Int64Int64; } catch (e) {};
try { KismetMathLibrary.BitwiseOR = KismetMathLibrary.Or_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqualExactly = KismetMathLibrary.prototype.NotEqualExactly_VectorVector; } catch (e) {};
try { KismetMathLibrary.NotEqualExactly = KismetMathLibrary.NotEqualExactly_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqualExactly = KismetMathLibrary.prototype.NotEqualExactly_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.NotEqualExactly = KismetMathLibrary.NotEqualExactly_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqualExactly = KismetMathLibrary.prototype.NotEqualExactly_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.NotEqualExactly = KismetMathLibrary.NotEqualExactly_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_VectorVector; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_TimespanTimespan; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_TimespanTimespan; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_RotatorRotator; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_RotatorRotator; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_QuatQuat; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_QuatQuat; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_ObjectObject; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_ObjectObject; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_NameName; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_NameName; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_LinearColorLinearColor; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_LinearColorLinearColor; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_IntInt; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_Int64Int64; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_DateTimeDateTime; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_DateTimeDateTime; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_ClassClass; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_ClassClass; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqual = KismetMathLibrary.prototype.NotEqual_ByteByte; } catch (e) {};
try { KismetMathLibrary.NotEqual = KismetMathLibrary.NotEqual_ByteByte; } catch (e) {};
try { KismetMathLibrary.prototype.NotEqualBoolean = KismetMathLibrary.prototype.NotEqual_BoolBool; } catch (e) {};
try { KismetMathLibrary.NotEqualBoolean = KismetMathLibrary.NotEqual_BoolBool; } catch (e) {};
try { KismetMathLibrary.prototype.NOTBoolean = KismetMathLibrary.prototype.Not_PreBool; } catch (e) {};
try { KismetMathLibrary.NOTBoolean = KismetMathLibrary.Not_PreBool; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseNOT = KismetMathLibrary.prototype.Not_Int64; } catch (e) {};
try { KismetMathLibrary.BitwiseNOT = KismetMathLibrary.Not_Int64; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseNOT = KismetMathLibrary.prototype.Not_Int; } catch (e) {};
try { KismetMathLibrary.BitwiseNOT = KismetMathLibrary.Not_Int; } catch (e) {};
try { KismetMathLibrary.prototype.NormalSafe = KismetMathLibrary.prototype.NormalSafe2D; } catch (e) {};
try { KismetMathLibrary.NormalSafe = KismetMathLibrary.NormalSafe2D; } catch (e) {};
try { KismetMathLibrary.prototype.Delta = KismetMathLibrary.prototype.NormalizedDeltaRotator; } catch (e) {};
try { KismetMathLibrary.Delta = KismetMathLibrary.NormalizedDeltaRotator; } catch (e) {};
try { KismetMathLibrary.prototype.NormalizeInPlace = KismetMathLibrary.prototype.Normalize2D; } catch (e) {};
try { KismetMathLibrary.NormalizeInPlace = KismetMathLibrary.Normalize2D; } catch (e) {};
try { KismetMathLibrary.prototype.Normalize2D = KismetMathLibrary.prototype.Normal2D; } catch (e) {};
try { KismetMathLibrary.Normalize2D = KismetMathLibrary.Normal2D; } catch (e) {};
try { KismetMathLibrary.prototype.Normalize = KismetMathLibrary.prototype.Normal; } catch (e) {};
try { KismetMathLibrary.Normalize = KismetMathLibrary.Normal; } catch (e) {};
try { KismetMathLibrary.prototype.InvertRotator = KismetMathLibrary.prototype.NegateRotator; } catch (e) {};
try { KismetMathLibrary.InvertRotator = KismetMathLibrary.NegateRotator; } catch (e) {};
try { KismetMathLibrary.prototype.NearlyEqual = KismetMathLibrary.prototype.NearlyEqual_TransformTransform; } catch (e) {};
try { KismetMathLibrary.NearlyEqual = KismetMathLibrary.NearlyEqual_TransformTransform; } catch (e) {};
try { KismetMathLibrary.prototype.NearlyEqual = KismetMathLibrary.prototype.NearlyEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.NearlyEqual = KismetMathLibrary.NearlyEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.prototype.Power = KismetMathLibrary.prototype.MultiplyMultiply_FloatFloat; } catch (e) {};
try { KismetMathLibrary.Power = KismetMathLibrary.MultiplyMultiply_FloatFloat; } catch (e) {};
try { KismetMathLibrary.prototype.ScaleRotator = KismetMathLibrary.prototype.Multiply_RotatorInt; } catch (e) {};
try { KismetMathLibrary.ScaleRotator = KismetMathLibrary.Multiply_RotatorInt; } catch (e) {};
try { KismetMathLibrary.prototype.ScaleRotator = KismetMathLibrary.prototype.Multiply_RotatorFloat; } catch (e) {};
try { KismetMathLibrary.ScaleRotator = KismetMathLibrary.Multiply_RotatorFloat; } catch (e) {};
try { KismetMathLibrary.prototype.Min = KismetMathLibrary.prototype.MinInt64; } catch (e) {};
try { KismetMathLibrary.Min = KismetMathLibrary.MinInt64; } catch (e) {};
try { KismetMathLibrary.prototype.Max = KismetMathLibrary.prototype.MaxInt64; } catch (e) {};
try { KismetMathLibrary.Max = KismetMathLibrary.MaxInt64; } catch (e) {};
try { KismetMathLibrary.prototype.GetOrigin = KismetMathLibrary.prototype.Matrix_GetOrigin; } catch (e) {};
try { KismetMathLibrary.GetOrigin = KismetMathLibrary.Matrix_GetOrigin; } catch (e) {};
try { KismetMathLibrary.prototype.LinePlaneIntersection = KismetMathLibrary.prototype.LinePlaneIntersection_OriginNormal; } catch (e) {};
try { KismetMathLibrary.LinePlaneIntersection = KismetMathLibrary.LinePlaneIntersection_OriginNormal; } catch (e) {};
try { KismetMathLibrary.prototype.LerpUsingHSV = KismetMathLibrary.prototype.LinearColorLerpUsingHSV; } catch (e) {};
try { KismetMathLibrary.LerpUsingHSV = KismetMathLibrary.LinearColorLerpUsingHSV; } catch (e) {};
try { KismetMathLibrary.prototype.Lerp = KismetMathLibrary.prototype.LinearColorLerp; } catch (e) {};
try { KismetMathLibrary.Lerp = KismetMathLibrary.LinearColorLerp; } catch (e) {};
try { KismetMathLibrary.prototype.ToRGBE = KismetMathLibrary.prototype.LinearColor_ToRGBE; } catch (e) {};
try { KismetMathLibrary.ToRGBE = KismetMathLibrary.LinearColor_ToRGBE; } catch (e) {};
try { KismetMathLibrary.prototype.NewOpacity = KismetMathLibrary.prototype.LinearColor_ToNewOpacity; } catch (e) {};
try { KismetMathLibrary.NewOpacity = KismetMathLibrary.LinearColor_ToNewOpacity; } catch (e) {};
try { KismetMathLibrary.prototype.NearEqual = KismetMathLibrary.prototype.LinearColor_IsNearEqual; } catch (e) {};
try { KismetMathLibrary.NearEqual = KismetMathLibrary.LinearColor_IsNearEqual; } catch (e) {};
try { KismetMathLibrary.prototype.Min = KismetMathLibrary.prototype.LinearColor_GetMin; } catch (e) {};
try { KismetMathLibrary.Min = KismetMathLibrary.LinearColor_GetMin; } catch (e) {};
try { KismetMathLibrary.prototype.Max = KismetMathLibrary.prototype.LinearColor_GetMax; } catch (e) {};
try { KismetMathLibrary.Max = KismetMathLibrary.LinearColor_GetMax; } catch (e) {};
try { KismetMathLibrary.prototype.Luminance = KismetMathLibrary.prototype.LinearColor_GetLuminance; } catch (e) {};
try { KismetMathLibrary.Luminance = KismetMathLibrary.LinearColor_GetLuminance; } catch (e) {};
try { KismetMathLibrary.prototype.Distance = KismetMathLibrary.prototype.LinearColor_Distance; } catch (e) {};
try { KismetMathLibrary.Distance = KismetMathLibrary.LinearColor_Distance; } catch (e) {};
try { KismetMathLibrary.prototype.Desaturate = KismetMathLibrary.prototype.LinearColor_Desaturated; } catch (e) {};
try { KismetMathLibrary.Desaturate = KismetMathLibrary.LinearColor_Desaturated; } catch (e) {};
try { KismetMathLibrary.prototype.UnrotateVector = KismetMathLibrary.prototype.LessLess_VectorRotator; } catch (e) {};
try { KismetMathLibrary.UnrotateVector = KismetMathLibrary.LessLess_VectorRotator; } catch (e) {};
try { KismetMathLibrary.prototype.InRange = KismetMathLibrary.prototype.InRange_IntInt; } catch (e) {};
try { KismetMathLibrary.InRange = KismetMathLibrary.InRange_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.InRange = KismetMathLibrary.prototype.InRange_Int64Int64; } catch (e) {};
try { KismetMathLibrary.InRange = KismetMathLibrary.InRange_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.InRange = KismetMathLibrary.prototype.InRange_FloatFloat; } catch (e) {};
try { KismetMathLibrary.InRange = KismetMathLibrary.InRange_FloatFloat; } catch (e) {};
try { KismetMathLibrary.prototype.HSVtoRGBlinearcolor = KismetMathLibrary.prototype.HSVToRGBLinear; } catch (e) {};
try { KismetMathLibrary.HSVtoRGBlinearcolor = KismetMathLibrary.HSVToRGBLinear; } catch (e) {};
try { KismetMathLibrary.prototype.HSVtoRGB = KismetMathLibrary.prototype.HSVToRGB_Vector; } catch (e) {};
try { KismetMathLibrary.HSVtoRGB = KismetMathLibrary.HSVToRGB_Vector; } catch (e) {};
try { KismetMathLibrary.prototype.Snaptogrid = KismetMathLibrary.prototype.GridSnap_Float; } catch (e) {};
try { KismetMathLibrary.Snaptogrid = KismetMathLibrary.GridSnap_Float; } catch (e) {};
try { KismetMathLibrary.prototype.RotateVector = KismetMathLibrary.prototype.GreaterGreater_VectorRotator; } catch (e) {};
try { KismetMathLibrary.RotateVector = KismetMathLibrary.GreaterGreater_VectorRotator; } catch (e) {};
try { KismetMathLibrary.prototype.GetUnitDirection = KismetMathLibrary.prototype.GetDirectionUnitVector; } catch (e) {};
try { KismetMathLibrary.GetUnitDirection = KismetMathLibrary.GetDirectionUnitVector; } catch (e) {};
try { KismetMathLibrary.prototype.Truncate = KismetMathLibrary.prototype.FTruncVector; } catch (e) {};
try { KismetMathLibrary.Truncate = KismetMathLibrary.FTruncVector; } catch (e) {};
try { KismetMathLibrary.prototype.TruncatetoInt64 = KismetMathLibrary.prototype.FTrunc64; } catch (e) {};
try { KismetMathLibrary.TruncatetoInt64 = KismetMathLibrary.FTrunc64; } catch (e) {};
try { KismetMathLibrary.prototype.Truncate = KismetMathLibrary.prototype.FTrunc; } catch (e) {};
try { KismetMathLibrary.Truncate = KismetMathLibrary.FTrunc; } catch (e) {};
try { KismetMathLibrary.prototype.Division = KismetMathLibrary.prototype.FMod; } catch (e) {};
try { KismetMathLibrary.Division = KismetMathLibrary.FMod; } catch (e) {};
try { KismetMathLibrary.prototype.Min = KismetMathLibrary.prototype.FMin; } catch (e) {};
try { KismetMathLibrary.Min = KismetMathLibrary.FMin; } catch (e) {};
try { KismetMathLibrary.prototype.Max = KismetMathLibrary.prototype.FMax; } catch (e) {};
try { KismetMathLibrary.Max = KismetMathLibrary.FMax; } catch (e) {};
try { KismetMathLibrary.prototype.FloortoInt64 = KismetMathLibrary.prototype.FFloor64; } catch (e) {};
try { KismetMathLibrary.FloortoInt64 = KismetMathLibrary.FFloor64; } catch (e) {};
try { KismetMathLibrary.prototype.Floor = KismetMathLibrary.prototype.FFloor; } catch (e) {};
try { KismetMathLibrary.Floor = KismetMathLibrary.FFloor; } catch (e) {};
try { KismetMathLibrary.prototype.Clamp = KismetMathLibrary.prototype.FClamp; } catch (e) {};
try { KismetMathLibrary.Clamp = KismetMathLibrary.FClamp; } catch (e) {};
try { KismetMathLibrary.prototype.FloortoInt64 = KismetMathLibrary.prototype.FCeil64; } catch (e) {};
try { KismetMathLibrary.FloortoInt64 = KismetMathLibrary.FCeil64; } catch (e) {};
try { KismetMathLibrary.prototype.EqualExactly = KismetMathLibrary.prototype.EqualExactly_VectorVector; } catch (e) {};
try { KismetMathLibrary.EqualExactly = KismetMathLibrary.EqualExactly_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.EqualExactly = KismetMathLibrary.prototype.EqualExactly_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.EqualExactly = KismetMathLibrary.EqualExactly_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.prototype.EqualExactly = KismetMathLibrary.prototype.EqualExactly_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.EqualExactly = KismetMathLibrary.EqualExactly_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_VectorVector; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_Vector4Vector4; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_Vector2DVector2D; } catch (e) {};
try { KismetMathLibrary.prototype.EqualTransform = KismetMathLibrary.prototype.EqualEqual_TransformTransform; } catch (e) {};
try { KismetMathLibrary.EqualTransform = KismetMathLibrary.EqualEqual_TransformTransform; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_TimespanTimespan; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_TimespanTimespan; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_RotatorRotator; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_RotatorRotator; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_QuatQuat; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_QuatQuat; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_ObjectObject; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_ObjectObject; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_NameName; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_NameName; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_LinearColorLinearColor; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_LinearColorLinearColor; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_IntInt; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_Int64Int64; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_FloatFloat; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_DateTimeDateTime; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_DateTimeDateTime; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_ClassClass; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_ClassClass; } catch (e) {};
try { KismetMathLibrary.prototype.Equal = KismetMathLibrary.prototype.EqualEqual_ByteByte; } catch (e) {};
try { KismetMathLibrary.Equal = KismetMathLibrary.EqualEqual_ByteByte; } catch (e) {};
try { KismetMathLibrary.prototype.EqualBoolean = KismetMathLibrary.prototype.EqualEqual_BoolBool; } catch (e) {};
try { KismetMathLibrary.EqualBoolean = KismetMathLibrary.EqualEqual_BoolBool; } catch (e) {};
try { KismetMathLibrary.prototype.DotProduct = KismetMathLibrary.prototype.DotProduct2D; } catch (e) {};
try { KismetMathLibrary.DotProduct = KismetMathLibrary.DotProduct2D; } catch (e) {};
try { KismetMathLibrary.prototype.DotProduct = KismetMathLibrary.prototype.Dot_VectorVector; } catch (e) {};
try { KismetMathLibrary.DotProduct = KismetMathLibrary.Dot_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.Tan = KismetMathLibrary.prototype.DegTan; } catch (e) {};
try { KismetMathLibrary.Tan = KismetMathLibrary.DegTan; } catch (e) {};
try { KismetMathLibrary.prototype.Sin = KismetMathLibrary.prototype.DegSin; } catch (e) {};
try { KismetMathLibrary.Sin = KismetMathLibrary.DegSin; } catch (e) {};
try { KismetMathLibrary.prototype.Cos = KismetMathLibrary.prototype.DegCos; } catch (e) {};
try { KismetMathLibrary.Cos = KismetMathLibrary.DegCos; } catch (e) {};
try { KismetMathLibrary.prototype.Atan2 = KismetMathLibrary.prototype.DegAtan2; } catch (e) {};
try { KismetMathLibrary.Atan2 = KismetMathLibrary.DegAtan2; } catch (e) {};
try { KismetMathLibrary.prototype.Atan = KismetMathLibrary.prototype.DegAtan; } catch (e) {};
try { KismetMathLibrary.Atan = KismetMathLibrary.DegAtan; } catch (e) {};
try { KismetMathLibrary.prototype.Asin = KismetMathLibrary.prototype.DegAsin; } catch (e) {};
try { KismetMathLibrary.Asin = KismetMathLibrary.DegAsin; } catch (e) {};
try { KismetMathLibrary.prototype.Acos = KismetMathLibrary.prototype.DegAcos; } catch (e) {};
try { KismetMathLibrary.Acos = KismetMathLibrary.DegAcos; } catch (e) {};
try { KismetMathLibrary.prototype.MinValue = KismetMathLibrary.prototype.DateTimeMinValue; } catch (e) {};
try { KismetMathLibrary.MinValue = KismetMathLibrary.DateTimeMinValue; } catch (e) {};
try { KismetMathLibrary.prototype.MaxValue = KismetMathLibrary.prototype.DateTimeMaxValue; } catch (e) {};
try { KismetMathLibrary.MaxValue = KismetMathLibrary.DateTimeMaxValue; } catch (e) {};
try { KismetMathLibrary.prototype.CrossProduct = KismetMathLibrary.prototype.CrossProduct2D; } catch (e) {};
try { KismetMathLibrary.CrossProduct = KismetMathLibrary.CrossProduct2D; } catch (e) {};
try { KismetMathLibrary.prototype.CrossProduct = KismetMathLibrary.prototype.Cross_VectorVector; } catch (e) {};
try { KismetMathLibrary.CrossProduct = KismetMathLibrary.Cross_VectorVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector2D = KismetMathLibrary.prototype.Conv_VectorToVector2D; } catch (e) {};
try { KismetMathLibrary.ToVector2D = KismetMathLibrary.Conv_VectorToVector2D; } catch (e) {};
try { KismetMathLibrary.prototype.ToTransform = KismetMathLibrary.prototype.Conv_VectorToTransform; } catch (e) {};
try { KismetMathLibrary.ToTransform = KismetMathLibrary.Conv_VectorToTransform; } catch (e) {};
try { KismetMathLibrary.prototype.RotationFromXVector = KismetMathLibrary.prototype.Conv_VectorToRotator; } catch (e) {};
try { KismetMathLibrary.RotationFromXVector = KismetMathLibrary.Conv_VectorToRotator; } catch (e) {};
try { KismetMathLibrary.prototype.ToQuaterion = KismetMathLibrary.prototype.Conv_VectorToQuaterion; } catch (e) {};
try { KismetMathLibrary.ToQuaterion = KismetMathLibrary.Conv_VectorToQuaterion; } catch (e) {};
try { KismetMathLibrary.prototype.ToLinearColor = KismetMathLibrary.prototype.Conv_VectorToLinearColor; } catch (e) {};
try { KismetMathLibrary.ToLinearColor = KismetMathLibrary.Conv_VectorToLinearColor; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector = KismetMathLibrary.prototype.Conv_Vector4ToVector; } catch (e) {};
try { KismetMathLibrary.ToVector = KismetMathLibrary.Conv_Vector4ToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToRotation = KismetMathLibrary.prototype.Conv_Vector4ToRotator; } catch (e) {};
try { KismetMathLibrary.ToRotation = KismetMathLibrary.Conv_Vector4ToRotator; } catch (e) {};
try { KismetMathLibrary.prototype.ToQuaterion = KismetMathLibrary.prototype.Conv_Vector4ToQuaterion; } catch (e) {};
try { KismetMathLibrary.ToQuaterion = KismetMathLibrary.Conv_Vector4ToQuaterion; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector = KismetMathLibrary.prototype.Conv_Vector2DToVector; } catch (e) {};
try { KismetMathLibrary.ToVector = KismetMathLibrary.Conv_Vector2DToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToIntPoint = KismetMathLibrary.prototype.Conv_Vector2DToIntPoint; } catch (e) {};
try { KismetMathLibrary.ToIntPoint = KismetMathLibrary.Conv_Vector2DToIntPoint; } catch (e) {};
try { KismetMathLibrary.prototype.GetRotationXVector = KismetMathLibrary.prototype.Conv_RotatorToVector; } catch (e) {};
try { KismetMathLibrary.GetRotationXVector = KismetMathLibrary.Conv_RotatorToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToTransform = KismetMathLibrary.prototype.Conv_RotatorToTransform; } catch (e) {};
try { KismetMathLibrary.ToTransform = KismetMathLibrary.Conv_RotatorToTransform; } catch (e) {};
try { KismetMathLibrary.prototype.ToTransform = KismetMathLibrary.prototype.Conv_MatrixToTransform; } catch (e) {};
try { KismetMathLibrary.ToTransform = KismetMathLibrary.Conv_MatrixToTransform; } catch (e) {};
try { KismetMathLibrary.prototype.ToRotator = KismetMathLibrary.prototype.Conv_MatrixToRotator; } catch (e) {};
try { KismetMathLibrary.ToRotator = KismetMathLibrary.Conv_MatrixToRotator; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector = KismetMathLibrary.prototype.Conv_LinearColorToVector; } catch (e) {};
try { KismetMathLibrary.ToVector = KismetMathLibrary.Conv_LinearColorToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToColor = KismetMathLibrary.prototype.Conv_LinearColorToColor; } catch (e) {};
try { KismetMathLibrary.ToColor = KismetMathLibrary.Conv_LinearColorToColor; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector = KismetMathLibrary.prototype.Conv_IntVectorToVector; } catch (e) {};
try { KismetMathLibrary.ToVector = KismetMathLibrary.Conv_IntVectorToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToIntVector = KismetMathLibrary.prototype.Conv_IntToIntVector; } catch (e) {};
try { KismetMathLibrary.ToIntVector = KismetMathLibrary.Conv_IntToIntVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToInt64 = KismetMathLibrary.prototype.Conv_IntToInt64; } catch (e) {};
try { KismetMathLibrary.ToInt64 = KismetMathLibrary.Conv_IntToInt64; } catch (e) {};
try { KismetMathLibrary.prototype.ToFloat = KismetMathLibrary.prototype.Conv_IntToFloat; } catch (e) {};
try { KismetMathLibrary.ToFloat = KismetMathLibrary.Conv_IntToFloat; } catch (e) {};
try { KismetMathLibrary.prototype.ToByte = KismetMathLibrary.prototype.Conv_IntToByte; } catch (e) {};
try { KismetMathLibrary.ToByte = KismetMathLibrary.Conv_IntToByte; } catch (e) {};
try { KismetMathLibrary.prototype.ToBool = KismetMathLibrary.prototype.Conv_IntToBool; } catch (e) {};
try { KismetMathLibrary.ToBool = KismetMathLibrary.Conv_IntToBool; } catch (e) {};
try { KismetMathLibrary.prototype.ToVector = KismetMathLibrary.prototype.Conv_FloatToVector; } catch (e) {};
try { KismetMathLibrary.ToVector = KismetMathLibrary.Conv_FloatToVector; } catch (e) {};
try { KismetMathLibrary.prototype.ToLinearColor = KismetMathLibrary.prototype.Conv_FloatToLinearColor; } catch (e) {};
try { KismetMathLibrary.ToLinearColor = KismetMathLibrary.Conv_FloatToLinearColor; } catch (e) {};
try { KismetMathLibrary.prototype.ToLinearColor = KismetMathLibrary.prototype.Conv_ColorToLinearColor; } catch (e) {};
try { KismetMathLibrary.ToLinearColor = KismetMathLibrary.Conv_ColorToLinearColor; } catch (e) {};
try { KismetMathLibrary.prototype.ToInt = KismetMathLibrary.prototype.Conv_ByteToInt; } catch (e) {};
try { KismetMathLibrary.ToInt = KismetMathLibrary.Conv_ByteToInt; } catch (e) {};
try { KismetMathLibrary.prototype.ToFloat = KismetMathLibrary.prototype.Conv_ByteToFloat; } catch (e) {};
try { KismetMathLibrary.ToFloat = KismetMathLibrary.Conv_ByteToFloat; } catch (e) {};
try { KismetMathLibrary.prototype.ToInt = KismetMathLibrary.prototype.Conv_BoolToInt; } catch (e) {};
try { KismetMathLibrary.ToInt = KismetMathLibrary.Conv_BoolToInt; } catch (e) {};
try { KismetMathLibrary.prototype.ToFloat = KismetMathLibrary.prototype.Conv_BoolToFloat; } catch (e) {};
try { KismetMathLibrary.ToFloat = KismetMathLibrary.Conv_BoolToFloat; } catch (e) {};
try { KismetMathLibrary.prototype.ToByte = KismetMathLibrary.prototype.Conv_BoolToByte; } catch (e) {};
try { KismetMathLibrary.ToByte = KismetMathLibrary.Conv_BoolToByte; } catch (e) {};
try { KismetMathLibrary.prototype.CombineRotators = KismetMathLibrary.prototype.ComposeRotators; } catch (e) {};
try { KismetMathLibrary.CombineRotators = KismetMathLibrary.ComposeRotators; } catch (e) {};
try { KismetMathLibrary.prototype.Clamp = KismetMathLibrary.prototype.ClampInt64; } catch (e) {};
try { KismetMathLibrary.Clamp = KismetMathLibrary.ClampInt64; } catch (e) {};
try { KismetMathLibrary.prototype.Interpolate = KismetMathLibrary.prototype.CInterpTo; } catch (e) {};
try { KismetMathLibrary.Interpolate = KismetMathLibrary.CInterpTo; } catch (e) {};
try { KismetMathLibrary.prototype.XORBoolean = KismetMathLibrary.prototype.BooleanXOR; } catch (e) {};
try { KismetMathLibrary.XORBoolean = KismetMathLibrary.BooleanXOR; } catch (e) {};
try { KismetMathLibrary.prototype.ORBoolean = KismetMathLibrary.prototype.BooleanOR; } catch (e) {};
try { KismetMathLibrary.ORBoolean = KismetMathLibrary.BooleanOR; } catch (e) {};
try { KismetMathLibrary.prototype.NORBoolean = KismetMathLibrary.prototype.BooleanNOR; } catch (e) {};
try { KismetMathLibrary.NORBoolean = KismetMathLibrary.BooleanNOR; } catch (e) {};
try { KismetMathLibrary.prototype.NANDBoolean = KismetMathLibrary.prototype.BooleanNAND; } catch (e) {};
try { KismetMathLibrary.NANDBoolean = KismetMathLibrary.BooleanNAND; } catch (e) {};
try { KismetMathLibrary.prototype.ANDBoolean = KismetMathLibrary.prototype.BooleanAND; } catch (e) {};
try { KismetMathLibrary.ANDBoolean = KismetMathLibrary.BooleanAND; } catch (e) {};
try { KismetMathLibrary.prototype.Min = KismetMathLibrary.prototype.BMin; } catch (e) {};
try { KismetMathLibrary.Min = KismetMathLibrary.BMin; } catch (e) {};
try { KismetMathLibrary.prototype.Max = KismetMathLibrary.prototype.BMax; } catch (e) {};
try { KismetMathLibrary.Max = KismetMathLibrary.BMax; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseAND = KismetMathLibrary.prototype.And_IntInt; } catch (e) {};
try { KismetMathLibrary.BitwiseAND = KismetMathLibrary.And_IntInt; } catch (e) {};
try { KismetMathLibrary.prototype.BitwiseAND = KismetMathLibrary.prototype.And_Int64Int64; } catch (e) {};
try { KismetMathLibrary.BitwiseAND = KismetMathLibrary.And_Int64Int64; } catch (e) {};
try { KismetMathLibrary.prototype.Absolute = KismetMathLibrary.prototype.Abs_Int64; } catch (e) {};
try { KismetMathLibrary.Absolute = KismetMathLibrary.Abs_Int64; } catch (e) {};
try { KismetMathLibrary.prototype.Absolute = KismetMathLibrary.prototype.Abs_Int; } catch (e) {};
try { KismetMathLibrary.Absolute = KismetMathLibrary.Abs_Int; } catch (e) {};
try { KismetMathLibrary.prototype.Absolute = KismetMathLibrary.prototype.Abs; } catch (e) {};
try { KismetMathLibrary.Absolute = KismetMathLibrary.Abs; } catch (e) {};
try { let fnprepatch_426 = KismetRenderingLibrary.prototype.RenderTargetCreateStaticTexture2DEditorOnly;KismetRenderingLibrary.prototype.RenderTargetCreateStaticTexture2DEditorOnly = function (RenderTarget, Name = "Texture", CompressionSettings = "TC_Default", MipSettings = "TMGS_FromTextureGroup") { return fnprepatch_426.call(this, RenderTarget, Name, CompressionSettings, MipSettings) }; } catch (e) {};
try { let fnprepatch_427 = KismetRenderingLibrary.prototype.CreateRenderTarget2D;KismetRenderingLibrary.prototype.CreateRenderTarget2D = function (WorldContextObject, Width = 256, Height = 256, Format = "RTF_RGBA16f") { return fnprepatch_427.call(this, WorldContextObject, Width, Height, Format) }; } catch (e) {};
try { let fnprepatch_428 = KismetRenderingLibrary.prototype.ClearRenderTarget2D;KismetRenderingLibrary.prototype.ClearRenderTarget2D = function (WorldContextObject, TextureRenderTarget, ClearColor = {"R":0,"G":0,"B":0,"A":1}) { return fnprepatch_428.call(this, WorldContextObject, TextureRenderTarget, ClearColor) }; } catch (e) {};
try { KismetRenderingLibrary.prototype.RenderTargetCreateStaticTextureEditorOnly = KismetRenderingLibrary.prototype.RenderTargetCreateStaticTexture2DEditorOnly; } catch (e) {};
try { KismetRenderingLibrary.RenderTargetCreateStaticTextureEditorOnly = KismetRenderingLibrary.RenderTargetCreateStaticTexture2DEditorOnly; } catch (e) {};
try { let fnprepatch_429 = KismetStringLibrary.prototype.StartsWith;KismetStringLibrary.prototype.StartsWith = function (SourceString, InPrefix, SearchCase = "IgnoreCase") { return fnprepatch_429.call(this, SourceString, InPrefix, SearchCase) }; } catch (e) {};
try { let fnprepatch_430 = KismetStringLibrary.prototype.Split;KismetStringLibrary.prototype.Split = function (SourceString, InStr, LeftS, RightS, SearchCase = "IgnoreCase", SearchDir = "FromStart") { return fnprepatch_430.call(this, SourceString, InStr, LeftS, RightS, SearchCase, SearchDir) }; } catch (e) {};
try { let fnprepatch_431 = KismetStringLibrary.prototype.ReplaceInline;KismetStringLibrary.prototype.ReplaceInline = function (SourceString, SearchText, ReplacementText, SearchCase = "IgnoreCase") { return fnprepatch_431.call(this, SourceString, SearchText, ReplacementText, SearchCase) }; } catch (e) {};
try { let fnprepatch_432 = KismetStringLibrary.prototype.Replace;KismetStringLibrary.prototype.Replace = function (SourceString, From, To, SearchCase = "IgnoreCase") { return fnprepatch_432.call(this, SourceString, From, To, SearchCase) }; } catch (e) {};
try { let fnprepatch_433 = KismetStringLibrary.prototype.ParseIntoArray;KismetStringLibrary.prototype.ParseIntoArray = function (SourceString, Delimiter = " ", CullEmptyStrings = true) { return fnprepatch_433.call(this, SourceString, Delimiter, CullEmptyStrings) }; } catch (e) {};
try { let fnprepatch_434 = KismetStringLibrary.prototype.MatchesWildcard;KismetStringLibrary.prototype.MatchesWildcard = function (SourceString, Wildcard, SearchCase = "IgnoreCase") { return fnprepatch_434.call(this, SourceString, Wildcard, SearchCase) }; } catch (e) {};
try { let fnprepatch_435 = KismetStringLibrary.prototype.JoinStringArray;KismetStringLibrary.prototype.JoinStringArray = function (SourceArray, Separator = " ") { return fnprepatch_435.call(this, SourceArray, Separator) }; } catch (e) {};
try { let fnprepatch_436 = KismetStringLibrary.prototype.GetSubstring;KismetStringLibrary.prototype.GetSubstring = function (SourceString, StartIndex = 0, Length = 1) { return fnprepatch_436.call(this, SourceString, StartIndex, Length) }; } catch (e) {};
try { let fnprepatch_437 = KismetStringLibrary.prototype.GetCharacterAsNumber;KismetStringLibrary.prototype.GetCharacterAsNumber = function (SourceString, Index = 0) { return fnprepatch_437.call(this, SourceString, Index) }; } catch (e) {};
try { let fnprepatch_438 = KismetStringLibrary.prototype.FindSubstring;KismetStringLibrary.prototype.FindSubstring = function (SearchIn, Substring, bUseCase = false, bSearchFromEnd = false, StartPosition = -1) { return fnprepatch_438.call(this, SearchIn, Substring, bUseCase, bSearchFromEnd, StartPosition) }; } catch (e) {};
try { let fnprepatch_439 = KismetStringLibrary.prototype.EndsWith;KismetStringLibrary.prototype.EndsWith = function (SourceString, InSuffix, SearchCase = "IgnoreCase") { return fnprepatch_439.call(this, SourceString, InSuffix, SearchCase) }; } catch (e) {};
try { let fnprepatch_440 = KismetStringLibrary.prototype.Contains;KismetStringLibrary.prototype.Contains = function (SearchIn, Substring, bUseCase = false, bSearchFromEnd = false) { return fnprepatch_440.call(this, SearchIn, Substring, bUseCase, bSearchFromEnd) }; } catch (e) {};
try { KismetStringLibrary.prototype.NotEqual = KismetStringLibrary.prototype.NotEqual_StrStr; } catch (e) {};
try { KismetStringLibrary.NotEqual = KismetStringLibrary.NotEqual_StrStr; } catch (e) {};
try { KismetStringLibrary.prototype.Equal = KismetStringLibrary.prototype.EqualEqual_StrStr; } catch (e) {};
try { KismetStringLibrary.Equal = KismetStringLibrary.EqualEqual_StrStr; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_VectorToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_VectorToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_Vector2dToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_Vector2dToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_TransformToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_TransformToString; } catch (e) {};
try { KismetStringLibrary.prototype.StringtoVector2D = KismetStringLibrary.prototype.Conv_StringToVector2D; } catch (e) {};
try { KismetStringLibrary.StringtoVector2D = KismetStringLibrary.Conv_StringToVector2D; } catch (e) {};
try { KismetStringLibrary.prototype.StringtoVector = KismetStringLibrary.prototype.Conv_StringToVector; } catch (e) {};
try { KismetStringLibrary.StringtoVector = KismetStringLibrary.Conv_StringToVector; } catch (e) {};
try { KismetStringLibrary.prototype.StringtoRotator = KismetStringLibrary.prototype.Conv_StringToRotator; } catch (e) {};
try { KismetStringLibrary.StringtoRotator = KismetStringLibrary.Conv_StringToRotator; } catch (e) {};
try { KismetStringLibrary.prototype.StringToName = KismetStringLibrary.prototype.Conv_StringToName; } catch (e) {};
try { KismetStringLibrary.StringToName = KismetStringLibrary.Conv_StringToName; } catch (e) {};
try { KismetStringLibrary.prototype.StringToInt = KismetStringLibrary.prototype.Conv_StringToInt; } catch (e) {};
try { KismetStringLibrary.StringToInt = KismetStringLibrary.Conv_StringToInt; } catch (e) {};
try { KismetStringLibrary.prototype.StringToFloat = KismetStringLibrary.prototype.Conv_StringToFloat; } catch (e) {};
try { KismetStringLibrary.StringToFloat = KismetStringLibrary.Conv_StringToFloat; } catch (e) {};
try { KismetStringLibrary.prototype.StringtoColor = KismetStringLibrary.prototype.Conv_StringToColor; } catch (e) {};
try { KismetStringLibrary.StringtoColor = KismetStringLibrary.Conv_StringToColor; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_RotatorToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_RotatorToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_ObjectToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_ObjectToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_NameToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_NameToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_IntVectorToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_IntVectorToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_IntToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_IntToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_FloatToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_FloatToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_ColorToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_ColorToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_ByteToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_ByteToString; } catch (e) {};
try { KismetStringLibrary.prototype.ToString = KismetStringLibrary.prototype.Conv_BoolToString; } catch (e) {};
try { KismetStringLibrary.ToString = KismetStringLibrary.Conv_BoolToString; } catch (e) {};
try { KismetStringLibrary.prototype.Append = KismetStringLibrary.prototype.Concat_StrStr; } catch (e) {};
try { KismetStringLibrary.Append = KismetStringLibrary.Concat_StrStr; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Vector2d; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Vector2d; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Vector; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Vector; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Rotator; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Rotator; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Object; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Object; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Name; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Name; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_IntVector; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_IntVector; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Int; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Int; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Float; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Float; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Color; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Color; } catch (e) {};
try { KismetStringLibrary.prototype.BuildString = KismetStringLibrary.prototype.BuildString_Bool; } catch (e) {};
try { KismetStringLibrary.BuildString = KismetStringLibrary.BuildString_Bool; } catch (e) {};
try { KismetStringTableLibrary.prototype.IsStringTableRegistered = KismetStringTableLibrary.prototype.IsRegisteredTableId; } catch (e) {};
try { KismetStringTableLibrary.IsStringTableRegistered = KismetStringTableLibrary.IsRegisteredTableId; } catch (e) {};
try { KismetStringTableLibrary.prototype.IsStringTableEntryRegistered = KismetStringTableLibrary.prototype.IsRegisteredTableEntry; } catch (e) {};
try { KismetStringTableLibrary.IsStringTableEntryRegistered = KismetStringTableLibrary.IsRegisteredTableEntry; } catch (e) {};
try { KismetStringTableLibrary.prototype.GetStringTableNamespace = KismetStringTableLibrary.prototype.GetTableNamespace; } catch (e) {};
try { KismetStringTableLibrary.GetStringTableNamespace = KismetStringTableLibrary.GetTableNamespace; } catch (e) {};
try { KismetStringTableLibrary.prototype.GetStringTableEntrySourceString = KismetStringTableLibrary.prototype.GetTableEntrySourceString; } catch (e) {};
try { KismetStringTableLibrary.GetStringTableEntrySourceString = KismetStringTableLibrary.GetTableEntrySourceString; } catch (e) {};
try { let fnprepatch_441 = KismetSystemLibrary.prototype.SphereTraceSingleForObjects;KismetSystemLibrary.prototype.SphereTraceSingleForObjects = function (WorldContextObject, Start, End, Radius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_441.call(this, WorldContextObject, Start, End, Radius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_442 = KismetSystemLibrary.prototype.SphereTraceSingleByProfile;KismetSystemLibrary.prototype.SphereTraceSingleByProfile = function (WorldContextObject, Start, End, Radius, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_442.call(this, WorldContextObject, Start, End, Radius, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_443 = KismetSystemLibrary.prototype.SphereTraceSingle;KismetSystemLibrary.prototype.SphereTraceSingle = function (WorldContextObject, Start, End, Radius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_443.call(this, WorldContextObject, Start, End, Radius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_444 = KismetSystemLibrary.prototype.SphereTraceMultiForObjects;KismetSystemLibrary.prototype.SphereTraceMultiForObjects = function (WorldContextObject, Start, End, Radius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_444.call(this, WorldContextObject, Start, End, Radius, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_445 = KismetSystemLibrary.prototype.SphereTraceMultiByProfile;KismetSystemLibrary.prototype.SphereTraceMultiByProfile = function (WorldContextObject, Start, End, Radius, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_445.call(this, WorldContextObject, Start, End, Radius, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_446 = KismetSystemLibrary.prototype.SphereTraceMulti;KismetSystemLibrary.prototype.SphereTraceMulti = function (WorldContextObject, Start, End, Radius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_446.call(this, WorldContextObject, Start, End, Radius, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_447 = KismetSystemLibrary.prototype.PrintText;KismetSystemLibrary.prototype.PrintText = function (WorldContextObject, InText = "Hello", bPrintToScreen = true, bPrintToLog = true, TextColor = {"R":0,"G":0.6600000262260437,"B":1,"A":1}, Duration = 2) { return fnprepatch_447.call(this, WorldContextObject, InText, bPrintToScreen, bPrintToLog, TextColor, Duration) }; } catch (e) {};
try { let fnprepatch_448 = KismetSystemLibrary.prototype.PrintString;KismetSystemLibrary.prototype.PrintString = function (WorldContextObject, InString = "Hello", bPrintToScreen = true, bPrintToLog = true, TextColor = {"R":0,"G":0.6600000262260437,"B":1,"A":1}, Duration = 2) { return fnprepatch_448.call(this, WorldContextObject, InString, bPrintToScreen, bPrintToLog, TextColor, Duration) }; } catch (e) {};
try { let fnprepatch_449 = KismetSystemLibrary.prototype.LineTraceSingleForObjects;KismetSystemLibrary.prototype.LineTraceSingleForObjects = function (WorldContextObject, Start, End, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_449.call(this, WorldContextObject, Start, End, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_450 = KismetSystemLibrary.prototype.LineTraceSingleByProfile;KismetSystemLibrary.prototype.LineTraceSingleByProfile = function (WorldContextObject, Start, End, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_450.call(this, WorldContextObject, Start, End, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_451 = KismetSystemLibrary.prototype.LineTraceSingle;KismetSystemLibrary.prototype.LineTraceSingle = function (WorldContextObject, Start, End, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_451.call(this, WorldContextObject, Start, End, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_452 = KismetSystemLibrary.prototype.LineTraceMultiForObjects;KismetSystemLibrary.prototype.LineTraceMultiForObjects = function (WorldContextObject, Start, End, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_452.call(this, WorldContextObject, Start, End, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_453 = KismetSystemLibrary.prototype.LineTraceMultiByProfile;KismetSystemLibrary.prototype.LineTraceMultiByProfile = function (WorldContextObject, Start, End, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_453.call(this, WorldContextObject, Start, End, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_454 = KismetSystemLibrary.prototype.LineTraceMulti;KismetSystemLibrary.prototype.LineTraceMulti = function (WorldContextObject, Start, End, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_454.call(this, WorldContextObject, Start, End, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_455 = KismetSystemLibrary.prototype.ExecuteConsoleCommand;KismetSystemLibrary.prototype.ExecuteConsoleCommand = function (WorldContextObject, Command, SpecificPlayer = undefined) { return fnprepatch_455.call(this, WorldContextObject, Command, SpecificPlayer) }; } catch (e) {};
try { let fnprepatch_456 = KismetSystemLibrary.prototype.DrawDebugString;KismetSystemLibrary.prototype.DrawDebugString = function (WorldContextObject, TextLocation, Text, TestBaseActor = undefined, TextColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0) { return fnprepatch_456.call(this, WorldContextObject, TextLocation, Text, TestBaseActor, TextColor, Duration) }; } catch (e) {};
try { let fnprepatch_457 = KismetSystemLibrary.prototype.DrawDebugSphere;KismetSystemLibrary.prototype.DrawDebugSphere = function (WorldContextObject, Center, Radius = 100, Segments = 12, LineColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0) { return fnprepatch_457.call(this, WorldContextObject, Center, Radius, Segments, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_458 = KismetSystemLibrary.prototype.DrawDebugPoint;KismetSystemLibrary.prototype.DrawDebugPoint = function (WorldContextObject, Position, Size, PointColor, Duration = 0) { return fnprepatch_458.call(this, WorldContextObject, Position, Size, PointColor, Duration) }; } catch (e) {};
try { let fnprepatch_459 = KismetSystemLibrary.prototype.DrawDebugPlane;KismetSystemLibrary.prototype.DrawDebugPlane = function (WorldContextObject, PlaneCoordinates, Location, Size, PlaneColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0) { return fnprepatch_459.call(this, WorldContextObject, PlaneCoordinates, Location, Size, PlaneColor, Duration) }; } catch (e) {};
try { let fnprepatch_460 = KismetSystemLibrary.prototype.DrawDebugLine;KismetSystemLibrary.prototype.DrawDebugLine = function (WorldContextObject, LineStart, LineEnd, LineColor, Duration = 0, Thickness = 0) { return fnprepatch_460.call(this, WorldContextObject, LineStart, LineEnd, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_461 = KismetSystemLibrary.prototype.DrawDebugFrustum;KismetSystemLibrary.prototype.DrawDebugFrustum = function (WorldContextObject, FrustumTransform, FrustumColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0) { return fnprepatch_461.call(this, WorldContextObject, FrustumTransform, FrustumColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_462 = KismetSystemLibrary.prototype.DrawDebugFloatHistoryTransform;KismetSystemLibrary.prototype.DrawDebugFloatHistoryTransform = function (WorldContextObject, FloatHistory, DrawTransform, DrawSize, DrawColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0) { return fnprepatch_462.call(this, WorldContextObject, FloatHistory, DrawTransform, DrawSize, DrawColor, Duration) }; } catch (e) {};
try { let fnprepatch_463 = KismetSystemLibrary.prototype.DrawDebugFloatHistoryLocation;KismetSystemLibrary.prototype.DrawDebugFloatHistoryLocation = function (WorldContextObject, FloatHistory, DrawLocation, DrawSize, DrawColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0) { return fnprepatch_463.call(this, WorldContextObject, FloatHistory, DrawLocation, DrawSize, DrawColor, Duration) }; } catch (e) {};
try { let fnprepatch_464 = KismetSystemLibrary.prototype.DrawDebugCylinder;KismetSystemLibrary.prototype.DrawDebugCylinder = function (WorldContextObject, Start, End, Radius = 100, Segments = 12, LineColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0) { return fnprepatch_464.call(this, WorldContextObject, Start, End, Radius, Segments, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_465 = KismetSystemLibrary.prototype.DrawDebugCoordinateSystem;KismetSystemLibrary.prototype.DrawDebugCoordinateSystem = function (WorldContextObject, AxisLoc, AxisRot, Scale = 1, Duration = 0, Thickness = 0) { return fnprepatch_465.call(this, WorldContextObject, AxisLoc, AxisRot, Scale, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_466 = KismetSystemLibrary.prototype.DrawDebugConeInDegrees;KismetSystemLibrary.prototype.DrawDebugConeInDegrees = function (WorldContextObject, Origin, Direction, Length = 100, AngleWidth = 45, AngleHeight = 45, NumSides = 12, LineColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0) { return fnprepatch_466.call(this, WorldContextObject, Origin, Direction, Length, AngleWidth, AngleHeight, NumSides, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_467 = KismetSystemLibrary.prototype.DrawDebugCone;KismetSystemLibrary.prototype.DrawDebugCone = function (WorldContextObject, Origin, Direction, Length, AngleWidth, AngleHeight, NumSides, LineColor, Duration = 0, Thickness = 0) { return fnprepatch_467.call(this, WorldContextObject, Origin, Direction, Length, AngleWidth, AngleHeight, NumSides, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_468 = KismetSystemLibrary.prototype.DrawDebugCircle;KismetSystemLibrary.prototype.DrawDebugCircle = function (WorldContextObject, Center, Radius, NumSegments = 12, LineColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0, YAxis, ZAxis, bDrawAxis = false) { return fnprepatch_468.call(this, WorldContextObject, Center, Radius, NumSegments, LineColor, Duration, Thickness, YAxis, ZAxis, bDrawAxis) }; } catch (e) {};
try { let fnprepatch_469 = KismetSystemLibrary.prototype.DrawDebugCapsule;KismetSystemLibrary.prototype.DrawDebugCapsule = function (WorldContextObject, Center, HalfHeight, Radius, Rotation, LineColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0, Thickness = 0) { return fnprepatch_469.call(this, WorldContextObject, Center, HalfHeight, Radius, Rotation, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_470 = KismetSystemLibrary.prototype.DrawDebugCamera;KismetSystemLibrary.prototype.DrawDebugCamera = function (CameraActor, CameraColor = {"R":1,"G":1,"B":1,"A":1}, Duration = 0) { return fnprepatch_470.call(this, CameraActor, CameraColor, Duration) }; } catch (e) {};
try { let fnprepatch_471 = KismetSystemLibrary.prototype.DrawDebugBox;KismetSystemLibrary.prototype.DrawDebugBox = function (WorldContextObject, Center, Extent, LineColor, Rotation, Duration = 0, Thickness = 0) { return fnprepatch_471.call(this, WorldContextObject, Center, Extent, LineColor, Rotation, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_472 = KismetSystemLibrary.prototype.DrawDebugArrow;KismetSystemLibrary.prototype.DrawDebugArrow = function (WorldContextObject, LineStart, LineEnd, ArrowSize, LineColor, Duration = 0, Thickness = 0) { return fnprepatch_472.call(this, WorldContextObject, LineStart, LineEnd, ArrowSize, LineColor, Duration, Thickness) }; } catch (e) {};
try { let fnprepatch_473 = KismetSystemLibrary.prototype.CapsuleTraceSingleForObjects;KismetSystemLibrary.prototype.CapsuleTraceSingleForObjects = function (WorldContextObject, Start, End, Radius, HalfHeight, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_473.call(this, WorldContextObject, Start, End, Radius, HalfHeight, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_474 = KismetSystemLibrary.prototype.CapsuleTraceSingleByProfile;KismetSystemLibrary.prototype.CapsuleTraceSingleByProfile = function (WorldContextObject, Start, End, Radius, HalfHeight, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_474.call(this, WorldContextObject, Start, End, Radius, HalfHeight, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_475 = KismetSystemLibrary.prototype.CapsuleTraceSingle;KismetSystemLibrary.prototype.CapsuleTraceSingle = function (WorldContextObject, Start, End, Radius, HalfHeight, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_475.call(this, WorldContextObject, Start, End, Radius, HalfHeight, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_476 = KismetSystemLibrary.prototype.CapsuleTraceMultiForObjects;KismetSystemLibrary.prototype.CapsuleTraceMultiForObjects = function (WorldContextObject, Start, End, Radius, HalfHeight, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_476.call(this, WorldContextObject, Start, End, Radius, HalfHeight, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_477 = KismetSystemLibrary.prototype.CapsuleTraceMultiByProfile;KismetSystemLibrary.prototype.CapsuleTraceMultiByProfile = function (WorldContextObject, Start, End, Radius, HalfHeight, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_477.call(this, WorldContextObject, Start, End, Radius, HalfHeight, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_478 = KismetSystemLibrary.prototype.CapsuleTraceMulti;KismetSystemLibrary.prototype.CapsuleTraceMulti = function (WorldContextObject, Start, End, Radius, HalfHeight, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_478.call(this, WorldContextObject, Start, End, Radius, HalfHeight, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_479 = KismetSystemLibrary.prototype.BoxTraceSingleForObjects;KismetSystemLibrary.prototype.BoxTraceSingleForObjects = function (WorldContextObject, Start, End, HalfSize, Orientation, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_479.call(this, WorldContextObject, Start, End, HalfSize, Orientation, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_480 = KismetSystemLibrary.prototype.BoxTraceSingleByProfile;KismetSystemLibrary.prototype.BoxTraceSingleByProfile = function (WorldContextObject, Start, End, HalfSize, Orientation, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_480.call(this, WorldContextObject, Start, End, HalfSize, Orientation, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_481 = KismetSystemLibrary.prototype.BoxTraceSingle;KismetSystemLibrary.prototype.BoxTraceSingle = function (WorldContextObject, Start, End, HalfSize, Orientation, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_481.call(this, WorldContextObject, Start, End, HalfSize, Orientation, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHit, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_482 = KismetSystemLibrary.prototype.BoxTraceMultiForObjects;KismetSystemLibrary.prototype.BoxTraceMultiForObjects = function (WorldContextObject, Start, End, HalfSize, Orientation, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_482.call(this, WorldContextObject, Start, End, HalfSize, Orientation, ObjectTypes, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_483 = KismetSystemLibrary.prototype.BoxTraceMultiByProfile;KismetSystemLibrary.prototype.BoxTraceMultiByProfile = function (WorldContextObject, Start, End, HalfSize, Orientation, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_483.call(this, WorldContextObject, Start, End, HalfSize, Orientation, ProfileName, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_484 = KismetSystemLibrary.prototype.BoxTraceMulti;KismetSystemLibrary.prototype.BoxTraceMulti = function (WorldContextObject, Start, End, HalfSize, Orientation, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_484.call(this, WorldContextObject, Start, End, HalfSize, Orientation, TraceChannel, bTraceComplex, ActorsToIgnore, DrawDebugType, OutHits, bIgnoreSelf, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { KismetSystemLibrary.prototype.SphereTraceForObjects = KismetSystemLibrary.prototype.SphereTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.SphereTraceForObjects = KismetSystemLibrary.SphereTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.SphereTraceByProfile = KismetSystemLibrary.prototype.SphereTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.SphereTraceByProfile = KismetSystemLibrary.SphereTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.SphereTraceByChannel = KismetSystemLibrary.prototype.SphereTraceSingle; } catch (e) {};
try { KismetSystemLibrary.SphereTraceByChannel = KismetSystemLibrary.SphereTraceSingle; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiSphereTraceForObjects = KismetSystemLibrary.prototype.SphereTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.MultiSphereTraceForObjects = KismetSystemLibrary.SphereTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiSphereTraceByProfile = KismetSystemLibrary.prototype.SphereTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.MultiSphereTraceByProfile = KismetSystemLibrary.SphereTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiSphereTraceByChannel = KismetSystemLibrary.prototype.SphereTraceMulti; } catch (e) {};
try { KismetSystemLibrary.MultiSphereTraceByChannel = KismetSystemLibrary.SphereTraceMulti; } catch (e) {};
try { KismetSystemLibrary.prototype.NotEqual = KismetSystemLibrary.prototype.NotEqual_SoftObjectReference; } catch (e) {};
try { KismetSystemLibrary.NotEqual = KismetSystemLibrary.NotEqual_SoftObjectReference; } catch (e) {};
try { KismetSystemLibrary.prototype.NotEqual = KismetSystemLibrary.prototype.NotEqual_SoftClassReference; } catch (e) {};
try { KismetSystemLibrary.NotEqual = KismetSystemLibrary.NotEqual_SoftClassReference; } catch (e) {};
try { KismetSystemLibrary.prototype.NotEqual = KismetSystemLibrary.prototype.NotEqual_PrimaryAssetType; } catch (e) {};
try { KismetSystemLibrary.NotEqual = KismetSystemLibrary.NotEqual_PrimaryAssetType; } catch (e) {};
try { KismetSystemLibrary.prototype.NotEqual = KismetSystemLibrary.prototype.NotEqual_PrimaryAssetId; } catch (e) {};
try { KismetSystemLibrary.NotEqual = KismetSystemLibrary.NotEqual_PrimaryAssetId; } catch (e) {};
try { KismetSystemLibrary.prototype.LineTraceForObjects = KismetSystemLibrary.prototype.LineTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.LineTraceForObjects = KismetSystemLibrary.LineTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.LineTraceByProfile = KismetSystemLibrary.prototype.LineTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.LineTraceByProfile = KismetSystemLibrary.LineTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.LineTraceByChannel = KismetSystemLibrary.prototype.LineTraceSingle; } catch (e) {};
try { KismetSystemLibrary.LineTraceByChannel = KismetSystemLibrary.LineTraceSingle; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiLineTraceForObjects = KismetSystemLibrary.prototype.LineTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.MultiLineTraceForObjects = KismetSystemLibrary.LineTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiLineTraceByProfile = KismetSystemLibrary.prototype.LineTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.MultiLineTraceByProfile = KismetSystemLibrary.LineTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiLineTraceByChannel = KismetSystemLibrary.prototype.LineTraceMulti; } catch (e) {};
try { KismetSystemLibrary.MultiLineTraceByChannel = KismetSystemLibrary.LineTraceMulti; } catch (e) {};
try { KismetSystemLibrary.prototype.UnpauseTimerbyHandle = KismetSystemLibrary.prototype.K2_UnPauseTimerHandle; } catch (e) {};
try { KismetSystemLibrary.UnpauseTimerbyHandle = KismetSystemLibrary.K2_UnPauseTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.UnpauseTimerbyFunctionName = KismetSystemLibrary.prototype.K2_UnPauseTimer; } catch (e) {};
try { KismetSystemLibrary.UnpauseTimerbyFunctionName = KismetSystemLibrary.K2_UnPauseTimer; } catch (e) {};
try { KismetSystemLibrary.prototype.DoesTimerExistbyHandle = KismetSystemLibrary.prototype.K2_TimerExistsHandle; } catch (e) {};
try { KismetSystemLibrary.DoesTimerExistbyHandle = KismetSystemLibrary.K2_TimerExistsHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.DoesTimerExistbyFunctionName = KismetSystemLibrary.prototype.K2_TimerExists; } catch (e) {};
try { KismetSystemLibrary.DoesTimerExistbyFunctionName = KismetSystemLibrary.K2_TimerExists; } catch (e) {};
try { KismetSystemLibrary.prototype.SetTimerbyFunctionName = KismetSystemLibrary.prototype.K2_SetTimer; } catch (e) {};
try { KismetSystemLibrary.SetTimerbyFunctionName = KismetSystemLibrary.K2_SetTimer; } catch (e) {};
try { KismetSystemLibrary.prototype.PauseTimerbyHandle = KismetSystemLibrary.prototype.K2_PauseTimerHandle; } catch (e) {};
try { KismetSystemLibrary.PauseTimerbyHandle = KismetSystemLibrary.K2_PauseTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.PauseTimerbyFunctionName = KismetSystemLibrary.prototype.K2_PauseTimer; } catch (e) {};
try { KismetSystemLibrary.PauseTimerbyFunctionName = KismetSystemLibrary.K2_PauseTimer; } catch (e) {};
try { KismetSystemLibrary.prototype.IsValid = KismetSystemLibrary.prototype.K2_IsValidTimerHandle; } catch (e) {};
try { KismetSystemLibrary.IsValid = KismetSystemLibrary.K2_IsValidTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.IsTimerPausedbyHandle = KismetSystemLibrary.prototype.K2_IsTimerPausedHandle; } catch (e) {};
try { KismetSystemLibrary.IsTimerPausedbyHandle = KismetSystemLibrary.K2_IsTimerPausedHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.IsTimerPausedbyFunctionName = KismetSystemLibrary.prototype.K2_IsTimerPaused; } catch (e) {};
try { KismetSystemLibrary.IsTimerPausedbyFunctionName = KismetSystemLibrary.K2_IsTimerPaused; } catch (e) {};
try { KismetSystemLibrary.prototype.IsTimerActivebyHandle = KismetSystemLibrary.prototype.K2_IsTimerActiveHandle; } catch (e) {};
try { KismetSystemLibrary.IsTimerActivebyHandle = KismetSystemLibrary.K2_IsTimerActiveHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.IsTimerActivebyFunctionName = KismetSystemLibrary.prototype.K2_IsTimerActive; } catch (e) {};
try { KismetSystemLibrary.IsTimerActivebyFunctionName = KismetSystemLibrary.K2_IsTimerActive; } catch (e) {};
try { KismetSystemLibrary.prototype.Invalidate = KismetSystemLibrary.prototype.K2_InvalidateTimerHandle; } catch (e) {};
try { KismetSystemLibrary.Invalidate = KismetSystemLibrary.K2_InvalidateTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.GetTimerRemainingTimebyHandle = KismetSystemLibrary.prototype.K2_GetTimerRemainingTimeHandle; } catch (e) {};
try { KismetSystemLibrary.GetTimerRemainingTimebyHandle = KismetSystemLibrary.K2_GetTimerRemainingTimeHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.GetTimerRemainingTimebyFunctionName = KismetSystemLibrary.prototype.K2_GetTimerRemainingTime; } catch (e) {};
try { KismetSystemLibrary.GetTimerRemainingTimebyFunctionName = KismetSystemLibrary.K2_GetTimerRemainingTime; } catch (e) {};
try { KismetSystemLibrary.prototype.GetTimerElapsedTimebyHandle = KismetSystemLibrary.prototype.K2_GetTimerElapsedTimeHandle; } catch (e) {};
try { KismetSystemLibrary.GetTimerElapsedTimebyHandle = KismetSystemLibrary.K2_GetTimerElapsedTimeHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.GetTimerElapsedTimebyFunctionName = KismetSystemLibrary.prototype.K2_GetTimerElapsedTime; } catch (e) {};
try { KismetSystemLibrary.GetTimerElapsedTimebyFunctionName = KismetSystemLibrary.K2_GetTimerElapsedTime; } catch (e) {};
try { KismetSystemLibrary.prototype.ClearTimerbyHandle = KismetSystemLibrary.prototype.K2_ClearTimerHandle; } catch (e) {};
try { KismetSystemLibrary.ClearTimerbyHandle = KismetSystemLibrary.K2_ClearTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.ClearTimerbyFunctionName = KismetSystemLibrary.prototype.K2_ClearTimer; } catch (e) {};
try { KismetSystemLibrary.ClearTimerbyFunctionName = KismetSystemLibrary.K2_ClearTimer; } catch (e) {};
try { KismetSystemLibrary.prototype.ClearandInvalidateTimerbyHandle = KismetSystemLibrary.prototype.K2_ClearAndInvalidateTimerHandle; } catch (e) {};
try { KismetSystemLibrary.ClearandInvalidateTimerbyHandle = KismetSystemLibrary.K2_ClearAndInvalidateTimerHandle; } catch (e) {};
try { KismetSystemLibrary.prototype.GetDisplayName = KismetSystemLibrary.prototype.GetClassDisplayName; } catch (e) {};
try { KismetSystemLibrary.GetDisplayName = KismetSystemLibrary.GetClassDisplayName; } catch (e) {};
try { KismetSystemLibrary.prototype.Equal = KismetSystemLibrary.prototype.EqualEqual_SoftObjectReference; } catch (e) {};
try { KismetSystemLibrary.Equal = KismetSystemLibrary.EqualEqual_SoftObjectReference; } catch (e) {};
try { KismetSystemLibrary.prototype.Equal = KismetSystemLibrary.prototype.EqualEqual_SoftClassReference; } catch (e) {};
try { KismetSystemLibrary.Equal = KismetSystemLibrary.EqualEqual_SoftClassReference; } catch (e) {};
try { KismetSystemLibrary.prototype.Equal = KismetSystemLibrary.prototype.EqualEqual_PrimaryAssetType; } catch (e) {};
try { KismetSystemLibrary.Equal = KismetSystemLibrary.EqualEqual_PrimaryAssetType; } catch (e) {};
try { KismetSystemLibrary.prototype.Equal = KismetSystemLibrary.prototype.EqualEqual_PrimaryAssetId; } catch (e) {};
try { KismetSystemLibrary.Equal = KismetSystemLibrary.EqualEqual_PrimaryAssetId; } catch (e) {};
try { KismetSystemLibrary.prototype.DrawDebugCone = KismetSystemLibrary.prototype.DrawDebugConeInDegrees; } catch (e) {};
try { KismetSystemLibrary.DrawDebugCone = KismetSystemLibrary.DrawDebugConeInDegrees; } catch (e) {};
try { KismetSystemLibrary.prototype.ToSoftObjectReference = KismetSystemLibrary.prototype.Conv_SoftObjPathToSoftObjRef; } catch (e) {};
try { KismetSystemLibrary.ToSoftObjectReference = KismetSystemLibrary.Conv_SoftObjPathToSoftObjRef; } catch (e) {};
try { KismetSystemLibrary.prototype.ToString = KismetSystemLibrary.prototype.Conv_SoftObjectReferenceToString; } catch (e) {};
try { KismetSystemLibrary.ToString = KismetSystemLibrary.Conv_SoftObjectReferenceToString; } catch (e) {};
try { KismetSystemLibrary.prototype.ToString = KismetSystemLibrary.prototype.Conv_SoftClassReferenceToString; } catch (e) {};
try { KismetSystemLibrary.ToString = KismetSystemLibrary.Conv_SoftClassReferenceToString; } catch (e) {};
try { KismetSystemLibrary.prototype.ToString = KismetSystemLibrary.prototype.Conv_PrimaryAssetTypeToString; } catch (e) {};
try { KismetSystemLibrary.ToString = KismetSystemLibrary.Conv_PrimaryAssetTypeToString; } catch (e) {};
try { KismetSystemLibrary.prototype.ToString = KismetSystemLibrary.prototype.Conv_PrimaryAssetIdToString; } catch (e) {};
try { KismetSystemLibrary.ToString = KismetSystemLibrary.Conv_PrimaryAssetIdToString; } catch (e) {};
try { KismetSystemLibrary.prototype.CapsuleTraceForObjects = KismetSystemLibrary.prototype.CapsuleTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.CapsuleTraceForObjects = KismetSystemLibrary.CapsuleTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.CapsuleTraceByProfile = KismetSystemLibrary.prototype.CapsuleTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.CapsuleTraceByProfile = KismetSystemLibrary.CapsuleTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.CapsuleTraceByChannel = KismetSystemLibrary.prototype.CapsuleTraceSingle; } catch (e) {};
try { KismetSystemLibrary.CapsuleTraceByChannel = KismetSystemLibrary.CapsuleTraceSingle; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiCapsuleTraceForObjects = KismetSystemLibrary.prototype.CapsuleTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.MultiCapsuleTraceForObjects = KismetSystemLibrary.CapsuleTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiCapsuleTraceByProfile = KismetSystemLibrary.prototype.CapsuleTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.MultiCapsuleTraceByProfile = KismetSystemLibrary.CapsuleTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiCapsuleTraceByChannel = KismetSystemLibrary.prototype.CapsuleTraceMulti; } catch (e) {};
try { KismetSystemLibrary.MultiCapsuleTraceByChannel = KismetSystemLibrary.CapsuleTraceMulti; } catch (e) {};
try { KismetSystemLibrary.prototype.BoxTraceForObjects = KismetSystemLibrary.prototype.BoxTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.BoxTraceForObjects = KismetSystemLibrary.BoxTraceSingleForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.BoxTraceByProfile = KismetSystemLibrary.prototype.BoxTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.BoxTraceByProfile = KismetSystemLibrary.BoxTraceSingleByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.BoxTraceByChannel = KismetSystemLibrary.prototype.BoxTraceSingle; } catch (e) {};
try { KismetSystemLibrary.BoxTraceByChannel = KismetSystemLibrary.BoxTraceSingle; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiBoxTraceForObjects = KismetSystemLibrary.prototype.BoxTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.MultiBoxTraceForObjects = KismetSystemLibrary.BoxTraceMultiForObjects; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiBoxTraceByProfile = KismetSystemLibrary.prototype.BoxTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.MultiBoxTraceByProfile = KismetSystemLibrary.BoxTraceMultiByProfile; } catch (e) {};
try { KismetSystemLibrary.prototype.MultiBoxTraceByChannel = KismetSystemLibrary.prototype.BoxTraceMulti; } catch (e) {};
try { KismetSystemLibrary.MultiBoxTraceByChannel = KismetSystemLibrary.BoxTraceMulti; } catch (e) {};
try { let fnprepatch_485 = KismetTextLibrary.prototype.Conv_IntToText;KismetTextLibrary.prototype.Conv_IntToText = function (Value, bAlwaysSign = false, bUseGrouping = true, MinimumIntegralDigits = 1, MaximumIntegralDigits = 324) { return fnprepatch_485.call(this, Value, bAlwaysSign, bUseGrouping, MinimumIntegralDigits, MaximumIntegralDigits) }; } catch (e) {};
try { let fnprepatch_486 = KismetTextLibrary.prototype.Conv_FloatToText;KismetTextLibrary.prototype.Conv_FloatToText = function (Value, RoundingMode, bAlwaysSign = false, bUseGrouping = true, MinimumIntegralDigits = 1, MaximumIntegralDigits = 324, MinimumFractionalDigits = 0, MaximumFractionalDigits = 3) { return fnprepatch_486.call(this, Value, RoundingMode, bAlwaysSign, bUseGrouping, MinimumIntegralDigits, MaximumIntegralDigits, MinimumFractionalDigits, MaximumFractionalDigits) }; } catch (e) {};
try { let fnprepatch_487 = KismetTextLibrary.prototype.AsPercent_Float;KismetTextLibrary.prototype.AsPercent_Float = function (Value, RoundingMode, bAlwaysSign = false, bUseGrouping = true, MinimumIntegralDigits = 1, MaximumIntegralDigits = 324, MinimumFractionalDigits = 0, MaximumFractionalDigits = 3) { return fnprepatch_487.call(this, Value, RoundingMode, bAlwaysSign, bUseGrouping, MinimumIntegralDigits, MaximumIntegralDigits, MinimumFractionalDigits, MaximumFractionalDigits) }; } catch (e) {};
try { let fnprepatch_488 = KismetTextLibrary.prototype.AsCurrency_Integer;KismetTextLibrary.prototype.AsCurrency_Integer = function (Value, RoundingMode, bAlwaysSign = false, bUseGrouping = true, MinimumIntegralDigits = 1, MaximumIntegralDigits = 324, MinimumFractionalDigits = 0, MaximumFractionalDigits = 3, CurrencyCode) { return fnprepatch_488.call(this, Value, RoundingMode, bAlwaysSign, bUseGrouping, MinimumIntegralDigits, MaximumIntegralDigits, MinimumFractionalDigits, MaximumFractionalDigits, CurrencyCode) }; } catch (e) {};
try { let fnprepatch_489 = KismetTextLibrary.prototype.AsCurrency_Float;KismetTextLibrary.prototype.AsCurrency_Float = function (Value, RoundingMode, bAlwaysSign = false, bUseGrouping = true, MinimumIntegralDigits = 1, MaximumIntegralDigits = 324, MinimumFractionalDigits = 0, MaximumFractionalDigits = 3, CurrencyCode) { return fnprepatch_489.call(this, Value, RoundingMode, bAlwaysSign, bUseGrouping, MinimumIntegralDigits, MaximumIntegralDigits, MinimumFractionalDigits, MaximumFractionalDigits, CurrencyCode) }; } catch (e) {};
try { KismetTextLibrary.prototype.IsTextfromStringTable = KismetTextLibrary.prototype.TextIsFromStringTable; } catch (e) {};
try { KismetTextLibrary.IsTextfromStringTable = KismetTextLibrary.TextIsFromStringTable; } catch (e) {};
try { KismetTextLibrary.prototype.MakeTextfromStringTable = KismetTextLibrary.prototype.TextFromStringTable; } catch (e) {};
try { KismetTextLibrary.MakeTextfromStringTable = KismetTextLibrary.TextFromStringTable; } catch (e) {};
try { KismetTextLibrary.prototype.FindStringTableIDandKeyfromText = KismetTextLibrary.prototype.StringTableIdAndKeyFromText; } catch (e) {};
try { KismetTextLibrary.FindStringTableIDandKeyfromText = KismetTextLibrary.StringTableIdAndKeyFromText; } catch (e) {};
try { KismetTextLibrary.prototype.NotEqual = KismetTextLibrary.prototype.NotEqual_TextText; } catch (e) {};
try { KismetTextLibrary.NotEqual = KismetTextLibrary.NotEqual_TextText; } catch (e) {};
try { KismetTextLibrary.prototype.Equal = KismetTextLibrary.prototype.EqualEqual_TextText; } catch (e) {};
try { KismetTextLibrary.Equal = KismetTextLibrary.EqualEqual_TextText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_VectorToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_VectorToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_Vector2dToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_Vector2dToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_TransformToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_TransformToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToString = KismetTextLibrary.prototype.Conv_TextToString; } catch (e) {};
try { KismetTextLibrary.ToString = KismetTextLibrary.Conv_TextToString; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_StringToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_StringToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_RotatorToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_RotatorToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_ObjectToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_ObjectToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_NameToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_NameToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_IntToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_IntToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_FloatToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_FloatToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_ColorToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_ColorToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_ByteToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_ByteToText; } catch (e) {};
try { KismetTextLibrary.prototype.ToText = KismetTextLibrary.prototype.Conv_BoolToText; } catch (e) {};
try { KismetTextLibrary.ToText = KismetTextLibrary.Conv_BoolToText; } catch (e) {};
try { KismetTextLibrary.prototype.AsTime = KismetTextLibrary.prototype.AsTimeZoneTime_DateTime; } catch (e) {};
try { KismetTextLibrary.AsTime = KismetTextLibrary.AsTimeZoneTime_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsDateTime = KismetTextLibrary.prototype.AsTimeZoneDateTime_DateTime; } catch (e) {};
try { KismetTextLibrary.AsDateTime = KismetTextLibrary.AsTimeZoneDateTime_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsDate = KismetTextLibrary.prototype.AsTimeZoneDate_DateTime; } catch (e) {};
try { KismetTextLibrary.AsDate = KismetTextLibrary.AsTimeZoneDate_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsTimespan = KismetTextLibrary.prototype.AsTimespan_Timespan; } catch (e) {};
try { KismetTextLibrary.AsTimespan = KismetTextLibrary.AsTimespan_Timespan; } catch (e) {};
try { KismetTextLibrary.prototype.AsTime = KismetTextLibrary.prototype.AsTime_DateTime; } catch (e) {};
try { KismetTextLibrary.AsTime = KismetTextLibrary.AsTime_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsPercent = KismetTextLibrary.prototype.AsPercent_Float; } catch (e) {};
try { KismetTextLibrary.AsPercent = KismetTextLibrary.AsPercent_Float; } catch (e) {};
try { KismetTextLibrary.prototype.AsDateTime = KismetTextLibrary.prototype.AsDateTime_DateTime; } catch (e) {};
try { KismetTextLibrary.AsDateTime = KismetTextLibrary.AsDateTime_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsDate = KismetTextLibrary.prototype.AsDate_DateTime; } catch (e) {};
try { KismetTextLibrary.AsDate = KismetTextLibrary.AsDate_DateTime; } catch (e) {};
try { KismetTextLibrary.prototype.AsCurrency = KismetTextLibrary.prototype.AsCurrencyBase; } catch (e) {};
try { KismetTextLibrary.AsCurrency = KismetTextLibrary.AsCurrencyBase; } catch (e) {};
try { KismetTextLibrary.prototype.AsCurrency = KismetTextLibrary.prototype.AsCurrency_Integer; } catch (e) {};
try { KismetTextLibrary.AsCurrency = KismetTextLibrary.AsCurrency_Integer; } catch (e) {};
try { KismetTextLibrary.prototype.AsCurrency = KismetTextLibrary.prototype.AsCurrency_Float; } catch (e) {};
try { KismetTextLibrary.AsCurrency = KismetTextLibrary.AsCurrency_Float; } catch (e) {};
try { let fnprepatch_490 = LevelScriptActor.prototype.SetCinematicMode;LevelScriptActor.prototype.SetCinematicMode = function (bCinematicMode, bHidePlayer = true, bAffectsHUD = true, bAffectsMovement = false, bAffectsTurning = false) { return fnprepatch_490.call(this, bCinematicMode, bHidePlayer, bAffectsHUD, bAffectsMovement, bAffectsTurning) }; } catch (e) {};
try { LevelStreamingDynamic.prototype.LoadLevelInstance = LevelStreamingDynamic.prototype.LoadLevelInstanceBySoftObjectPtr; } catch (e) {};
try { LevelStreamingDynamic.LoadLevelInstance = LevelStreamingDynamic.LoadLevelInstanceBySoftObjectPtr; } catch (e) {};
try { let fnprepatch_491 = LocalLightComponent.prototype.GetUnitsConversionFactor;LocalLightComponent.prototype.GetUnitsConversionFactor = function (SrcUnits, TargetUnits, CosHalfConeAngle = -1) { return fnprepatch_491.call(this, SrcUnits, TargetUnits, CosHalfConeAngle) }; } catch (e) {};
try { let fnprepatch_492 = MaterialInstanceDynamic.prototype.K2_CopyMaterialInstanceParameters;MaterialInstanceDynamic.prototype.K2_CopyMaterialInstanceParameters = function (Source, bQuickParametersOnly = false) { return fnprepatch_492.call(this, Source, bQuickParametersOnly) }; } catch (e) {};
try { MaterialInstanceDynamic.prototype.InterpolateMaterialInstanceParameters = MaterialInstanceDynamic.prototype.K2_InterpolateMaterialInstanceParams; } catch (e) {};
try { MaterialInstanceDynamic.prototype.GetVectorParameterValue = MaterialInstanceDynamic.prototype.K2_GetVectorParameterValue; } catch (e) {};
try { MaterialInstanceDynamic.prototype.GetTextureParameterValue = MaterialInstanceDynamic.prototype.K2_GetTextureParameterValue; } catch (e) {};
try { MaterialInstanceDynamic.prototype.GetScalarParameterValue = MaterialInstanceDynamic.prototype.K2_GetScalarParameterValue; } catch (e) {};
try { MaterialInstanceDynamic.prototype.CopyMaterialInstanceParameters = MaterialInstanceDynamic.prototype.K2_CopyMaterialInstanceParameters; } catch (e) {};
try { let fnprepatch_493 = MatineeActor.prototype.SetPosition;MatineeActor.prototype.SetPosition = function (NewPosition, bJump = false) { return fnprepatch_493.call(this, NewPosition, bJump) }; } catch (e) {};
try { let fnprepatch_494 = MeshVertexPainterKismetLibrary.prototype.PaintVerticesSingleColor;MeshVertexPainterKismetLibrary.prototype.PaintVerticesSingleColor = function (StaticMeshComponent, FillColor, bConvertToSRGB = true) { return fnprepatch_494.call(this, StaticMeshComponent, FillColor, bConvertToSRGB) }; } catch (e) {};
try { let fnprepatch_495 = MeshVertexPainterKismetLibrary.prototype.PaintVerticesLerpAlongAxis;MeshVertexPainterKismetLibrary.prototype.PaintVerticesLerpAlongAxis = function (StaticMeshComponent, StartColor, EndColor, Axis, bConvertToSRGB = true) { return fnprepatch_495.call(this, StaticMeshComponent, StartColor, EndColor, Axis, bConvertToSRGB) }; } catch (e) {};
try { NavigationSystem.prototype.SimpleMoveToLocation_DEPRECATED = NavigationSystem.prototype.SimpleMoveToLocation; } catch (e) {};
try { NavigationSystem.SimpleMoveToLocation_DEPRECATED = NavigationSystem.SimpleMoveToLocation; } catch (e) {};
try { NavigationSystem.prototype.SimpleMoveToActor_DEPRECATED = NavigationSystem.prototype.SimpleMoveToActor; } catch (e) {};
try { NavigationSystem.SimpleMoveToActor_DEPRECATED = NavigationSystem.SimpleMoveToActor; } catch (e) {};
try { let fnprepatch_496 = ParticleSystemComponent.prototype.SetAutoAttachParams;ParticleSystemComponent.prototype.SetAutoAttachParams = function (Parent, SocketName = "None", LocationType = "KeepRelativeOffset") { return fnprepatch_496.call(this, Parent, SocketName, LocationType) }; } catch (e) {};
try { let fnprepatch_497 = ParticleSystemComponent.prototype.CreateNamedDynamicMaterialInstance;ParticleSystemComponent.prototype.CreateNamedDynamicMaterialInstance = function (InName, SourceMaterial = undefined) { return fnprepatch_497.call(this, InName, SourceMaterial) }; } catch (e) {};
try { let fnprepatch_498 = PhysicalAnimationComponent.prototype.ApplyPhysicalAnimationSettingsBelow;PhysicalAnimationComponent.prototype.ApplyPhysicalAnimationSettingsBelow = function (BodyName, PhysicalAnimationData, bIncludeSelf = true) { return fnprepatch_498.call(this, BodyName, PhysicalAnimationData, bIncludeSelf) }; } catch (e) {};
try { let fnprepatch_499 = PhysicalAnimationComponent.prototype.ApplyPhysicalAnimationProfileBelow;PhysicalAnimationComponent.prototype.ApplyPhysicalAnimationProfileBelow = function (BodyName, ProfileName, bIncludeSelf = true, bClearNotFound = false) { return fnprepatch_499.call(this, BodyName, ProfileName, bIncludeSelf, bClearNotFound) }; } catch (e) {};
try { let fnprepatch_500 = PlayerCameraManager.prototype.StopCameraShake;PlayerCameraManager.prototype.StopCameraShake = function (ShakeInstance, bImmediately = true) { return fnprepatch_500.call(this, ShakeInstance, bImmediately) }; } catch (e) {};
try { let fnprepatch_501 = PlayerCameraManager.prototype.StopCameraAnimInst;PlayerCameraManager.prototype.StopCameraAnimInst = function (AnimInst, bImmediate = false) { return fnprepatch_501.call(this, AnimInst, bImmediate) }; } catch (e) {};
try { let fnprepatch_502 = PlayerCameraManager.prototype.StopAllInstancesOfCameraShake;PlayerCameraManager.prototype.StopAllInstancesOfCameraShake = function (Shake, bImmediately = true) { return fnprepatch_502.call(this, Shake, bImmediately) }; } catch (e) {};
try { let fnprepatch_503 = PlayerCameraManager.prototype.StopAllInstancesOfCameraAnim;PlayerCameraManager.prototype.StopAllInstancesOfCameraAnim = function (Anim, bImmediate = false) { return fnprepatch_503.call(this, Anim, bImmediate) }; } catch (e) {};
try { let fnprepatch_504 = PlayerCameraManager.prototype.StopAllCameraShakes;PlayerCameraManager.prototype.StopAllCameraShakes = function (bImmediately = true) { return fnprepatch_504.call(this, bImmediately) }; } catch (e) {};
try { let fnprepatch_505 = PlayerCameraManager.prototype.StopAllCameraAnims;PlayerCameraManager.prototype.StopAllCameraAnims = function (bImmediate = false) { return fnprepatch_505.call(this, bImmediate) }; } catch (e) {};
try { let fnprepatch_506 = PlayerCameraManager.prototype.StartCameraFade;PlayerCameraManager.prototype.StartCameraFade = function (FromAlpha, ToAlpha, Duration, Color, bShouldFadeAudio = false, bHoldWhenFinished = false) { return fnprepatch_506.call(this, FromAlpha, ToAlpha, Duration, Color, bShouldFadeAudio, bHoldWhenFinished) }; } catch (e) {};
try { let fnprepatch_507 = PlayerCameraManager.prototype.PlayCameraShake;PlayerCameraManager.prototype.PlayCameraShake = function (ShakeClass, Scale = 1, PlaySpace = "CameraLocal", UserPlaySpaceRot) { return fnprepatch_507.call(this, ShakeClass, Scale, PlaySpace, UserPlaySpaceRot) }; } catch (e) {};
try { let fnprepatch_508 = PlayerCameraManager.prototype.PlayCameraAnim;PlayerCameraManager.prototype.PlayCameraAnim = function (Anim, Rate = 1, Scale = 1, BlendInTime = 0, BlendOutTime = 0, bLoop = false, bRandomStartTime = false, Duration = 0, PlaySpace = "CameraLocal", UserPlaySpaceRot) { return fnprepatch_508.call(this, Anim, Rate, Scale, BlendInTime, BlendOutTime, bLoop, bRandomStartTime, Duration, PlaySpace, UserPlaySpaceRot) }; } catch (e) {};
try { PlayerState.prototype.OverrideWith = PlayerState.prototype.ReceiveOverrideWith; } catch (e) {};
try { PlayerState.prototype.CopyProperties = PlayerState.prototype.ReceiveCopyProperties; } catch (e) {};
try { let fnprepatch_509 = PostProcessComponent.prototype.AddOrUpdateBlendable;PostProcessComponent.prototype.AddOrUpdateBlendable = function (InBlendableObject, InWeight = 1) { return fnprepatch_509.call(this, InBlendableObject, InWeight) }; } catch (e) {};
try { let fnprepatch_510 = PostProcessVolume.prototype.AddOrUpdateBlendable;PostProcessVolume.prototype.AddOrUpdateBlendable = function (InBlendableObject, InWeight = 1) { return fnprepatch_510.call(this, InBlendableObject, InWeight) }; } catch (e) {};
try { let fnprepatch_511 = SceneCaptureComponent2D.prototype.AddOrUpdateBlendable;SceneCaptureComponent2D.prototype.AddOrUpdateBlendable = function (InBlendableObject, InWeight = 1) { return fnprepatch_511.call(this, InBlendableObject, InWeight) }; } catch (e) {};
try { let fnprepatch_512 = SkeletalMesh.prototype.IsSectionUsingCloth;SkeletalMesh.prototype.IsSectionUsingCloth = function (InSectionIndex, bCheckCorrespondingSections = true) { return fnprepatch_512.call(this, InSectionIndex, bCheckCorrespondingSections) }; } catch (e) {};
try { let fnprepatch_513 = SoundSubmix.prototype.StopRecordingOutput;SoundSubmix.prototype.StopRecordingOutput = function (WorldContextObject, ExportType, Name, Path, ExistingSoundWaveToOverwrite = undefined) { return fnprepatch_513.call(this, WorldContextObject, ExportType, Name, Path, ExistingSoundWaveToOverwrite) }; } catch (e) {};
try { SoundSubmix.prototype.FinishRecordingSubmixOutput = SoundSubmix.prototype.StopRecordingOutput; } catch (e) {};
try { SoundSubmix.prototype.StartRecordingSubmixOutput = SoundSubmix.prototype.StartRecordingOutput; } catch (e) {};
try { let fnprepatch_514 = SplineComponent.prototype.SetUpVectorAtSplinePoint;SplineComponent.prototype.SetUpVectorAtSplinePoint = function (PointIndex, InUpVector, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_514.call(this, PointIndex, InUpVector, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_515 = SplineComponent.prototype.SetTangentsAtSplinePoint;SplineComponent.prototype.SetTangentsAtSplinePoint = function (PointIndex, InArriveTangent, InLeaveTangent, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_515.call(this, PointIndex, InArriveTangent, InLeaveTangent, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_516 = SplineComponent.prototype.SetTangentAtSplinePoint;SplineComponent.prototype.SetTangentAtSplinePoint = function (PointIndex, InTangent, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_516.call(this, PointIndex, InTangent, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_517 = SplineComponent.prototype.SetSplinePointType;SplineComponent.prototype.SetSplinePointType = function (PointIndex, Type, bUpdateSpline = true) { return fnprepatch_517.call(this, PointIndex, Type, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_518 = SplineComponent.prototype.SetSplinePoints;SplineComponent.prototype.SetSplinePoints = function (Points, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_518.call(this, Points, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_519 = SplineComponent.prototype.SetLocationAtSplinePoint;SplineComponent.prototype.SetLocationAtSplinePoint = function (PointIndex, InLocation, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_519.call(this, PointIndex, InLocation, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_520 = SplineComponent.prototype.SetClosedLoopAtPosition;SplineComponent.prototype.SetClosedLoopAtPosition = function (bInClosedLoop, Key, bUpdateSpline = true) { return fnprepatch_520.call(this, bInClosedLoop, Key, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_521 = SplineComponent.prototype.SetClosedLoop;SplineComponent.prototype.SetClosedLoop = function (bInClosedLoop, bUpdateSpline = true) { return fnprepatch_521.call(this, bInClosedLoop, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_522 = SplineComponent.prototype.RemoveSplinePoint;SplineComponent.prototype.RemoveSplinePoint = function (Index, bUpdateSpline = true) { return fnprepatch_522.call(this, Index, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_523 = SplineComponent.prototype.GetWorldRotationAtTime;SplineComponent.prototype.GetWorldRotationAtTime = function (Time, bUseConstantVelocity = false) { return fnprepatch_523.call(this, Time, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_524 = SplineComponent.prototype.GetWorldLocationAtTime;SplineComponent.prototype.GetWorldLocationAtTime = function (Time, bUseConstantVelocity = false) { return fnprepatch_524.call(this, Time, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_525 = SplineComponent.prototype.GetWorldDirectionAtTime;SplineComponent.prototype.GetWorldDirectionAtTime = function (Time, bUseConstantVelocity = false) { return fnprepatch_525.call(this, Time, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_526 = SplineComponent.prototype.GetUpVectorAtTime;SplineComponent.prototype.GetUpVectorAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_526.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_527 = SplineComponent.prototype.GetTransformAtTime;SplineComponent.prototype.GetTransformAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false, bUseScale = false) { return fnprepatch_527.call(this, Time, CoordinateSpace, bUseConstantVelocity, bUseScale) }; } catch (e) {};
try { let fnprepatch_528 = SplineComponent.prototype.GetTransformAtSplinePoint;SplineComponent.prototype.GetTransformAtSplinePoint = function (PointIndex, CoordinateSpace, bUseScale = false) { return fnprepatch_528.call(this, PointIndex, CoordinateSpace, bUseScale) }; } catch (e) {};
try { let fnprepatch_529 = SplineComponent.prototype.GetTransformAtDistanceAlongSpline;SplineComponent.prototype.GetTransformAtDistanceAlongSpline = function (Distance, CoordinateSpace, bUseScale = false) { return fnprepatch_529.call(this, Distance, CoordinateSpace, bUseScale) }; } catch (e) {};
try { let fnprepatch_530 = SplineComponent.prototype.GetTangentAtTime;SplineComponent.prototype.GetTangentAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_530.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_531 = SplineComponent.prototype.GetScaleAtTime;SplineComponent.prototype.GetScaleAtTime = function (Time, bUseConstantVelocity = false) { return fnprepatch_531.call(this, Time, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_532 = SplineComponent.prototype.GetRotationAtTime;SplineComponent.prototype.GetRotationAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_532.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_533 = SplineComponent.prototype.GetRollAtTime;SplineComponent.prototype.GetRollAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_533.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_534 = SplineComponent.prototype.GetRightVectorAtTime;SplineComponent.prototype.GetRightVectorAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_534.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_535 = SplineComponent.prototype.GetLocationAtTime;SplineComponent.prototype.GetLocationAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_535.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_536 = SplineComponent.prototype.GetDirectionAtTime;SplineComponent.prototype.GetDirectionAtTime = function (Time, CoordinateSpace, bUseConstantVelocity = false) { return fnprepatch_536.call(this, Time, CoordinateSpace, bUseConstantVelocity) }; } catch (e) {};
try { let fnprepatch_537 = SplineComponent.prototype.FindTransformClosestToWorldLocation;SplineComponent.prototype.FindTransformClosestToWorldLocation = function (WorldLocation, CoordinateSpace, bUseScale = false) { return fnprepatch_537.call(this, WorldLocation, CoordinateSpace, bUseScale) }; } catch (e) {};
try { let fnprepatch_538 = SplineComponent.prototype.ClearSplinePoints;SplineComponent.prototype.ClearSplinePoints = function (bUpdateSpline = true) { return fnprepatch_538.call(this, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_539 = SplineComponent.prototype.AddSplinePointAtIndex;SplineComponent.prototype.AddSplinePointAtIndex = function (Position, Index, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_539.call(this, Position, Index, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_540 = SplineComponent.prototype.AddSplinePoint;SplineComponent.prototype.AddSplinePoint = function (Position, CoordinateSpace, bUpdateSpline = true) { return fnprepatch_540.call(this, Position, CoordinateSpace, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_541 = SplineComponent.prototype.AddPoints;SplineComponent.prototype.AddPoints = function (Points, bUpdateSpline = true) { return fnprepatch_541.call(this, Points, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_542 = SplineComponent.prototype.AddPoint;SplineComponent.prototype.AddPoint = function (Point, bUpdateSpline = true) { return fnprepatch_542.call(this, Point, bUpdateSpline) }; } catch (e) {};
try { let fnprepatch_543 = SplineMeshComponent.prototype.SetStartTangent;SplineMeshComponent.prototype.SetStartTangent = function (StartTangent, bUpdateMesh = true) { return fnprepatch_543.call(this, StartTangent, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_544 = SplineMeshComponent.prototype.SetStartScale;SplineMeshComponent.prototype.SetStartScale = function (StartScale = {"X":1,"Y":1}, bUpdateMesh = true) { return fnprepatch_544.call(this, StartScale, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_545 = SplineMeshComponent.prototype.SetStartRoll;SplineMeshComponent.prototype.SetStartRoll = function (StartRoll, bUpdateMesh = true) { return fnprepatch_545.call(this, StartRoll, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_546 = SplineMeshComponent.prototype.SetStartPosition;SplineMeshComponent.prototype.SetStartPosition = function (StartPos, bUpdateMesh = true) { return fnprepatch_546.call(this, StartPos, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_547 = SplineMeshComponent.prototype.SetStartOffset;SplineMeshComponent.prototype.SetStartOffset = function (StartOffset, bUpdateMesh = true) { return fnprepatch_547.call(this, StartOffset, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_548 = SplineMeshComponent.prototype.SetStartAndEnd;SplineMeshComponent.prototype.SetStartAndEnd = function (StartPos, StartTangent, EndPos, EndTangent, bUpdateMesh = true) { return fnprepatch_548.call(this, StartPos, StartTangent, EndPos, EndTangent, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_549 = SplineMeshComponent.prototype.SetSplineUpDir;SplineMeshComponent.prototype.SetSplineUpDir = function (InSplineUpDir, bUpdateMesh = true) { return fnprepatch_549.call(this, InSplineUpDir, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_550 = SplineMeshComponent.prototype.SetForwardAxis;SplineMeshComponent.prototype.SetForwardAxis = function (InForwardAxis, bUpdateMesh = true) { return fnprepatch_550.call(this, InForwardAxis, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_551 = SplineMeshComponent.prototype.SetEndTangent;SplineMeshComponent.prototype.SetEndTangent = function (EndTangent, bUpdateMesh = true) { return fnprepatch_551.call(this, EndTangent, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_552 = SplineMeshComponent.prototype.SetEndScale;SplineMeshComponent.prototype.SetEndScale = function (EndScale = {"X":1,"Y":1}, bUpdateMesh = true) { return fnprepatch_552.call(this, EndScale, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_553 = SplineMeshComponent.prototype.SetEndRoll;SplineMeshComponent.prototype.SetEndRoll = function (EndRoll, bUpdateMesh = true) { return fnprepatch_553.call(this, EndRoll, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_554 = SplineMeshComponent.prototype.SetEndPosition;SplineMeshComponent.prototype.SetEndPosition = function (EndPos, bUpdateMesh = true) { return fnprepatch_554.call(this, EndPos, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_555 = SplineMeshComponent.prototype.SetEndOffset;SplineMeshComponent.prototype.SetEndOffset = function (EndOffset, bUpdateMesh = true) { return fnprepatch_555.call(this, EndOffset, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_556 = SplineMeshComponent.prototype.SetBoundaryMin;SplineMeshComponent.prototype.SetBoundaryMin = function (InBoundaryMin, bUpdateMesh = true) { return fnprepatch_556.call(this, InBoundaryMin, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_557 = SplineMeshComponent.prototype.SetBoundaryMax;SplineMeshComponent.prototype.SetBoundaryMax = function (InBoundaryMax, bUpdateMesh = true) { return fnprepatch_557.call(this, InBoundaryMax, bUpdateMesh) }; } catch (e) {};
try { let fnprepatch_558 = StereoLayerFunctionLibrary.prototype.SetSplashScreen;StereoLayerFunctionLibrary.prototype.SetSplashScreen = function (Texture, Scale = {"X":1,"Y":1}, Offset, bShowLoadingMovie = false, bShowOnSet = false) { return fnprepatch_558.call(this, Texture, Scale, Offset, bShowLoadingMovie, bShowOnSet) }; } catch (e) {};
try { TextRenderComponent.prototype.SetText = TextRenderComponent.prototype.K2_SetText; } catch (e) {};
try { let fnprepatch_559 = TimelineComponent.prototype.SetPlaybackPosition;TimelineComponent.prototype.SetPlaybackPosition = function (NewPosition, bFireEvents, bFireUpdate = true) { return fnprepatch_559.call(this, NewPosition, bFireEvents, bFireUpdate) }; } catch (e) {};
try { let fnprepatch_560 = VisualLoggerKismetLibrary.prototype.LogText;VisualLoggerKismetLibrary.prototype.LogText = function (WorldContextObject, Text, LogCategory = "VisLogBP", bAddToMessageLog = false) { return fnprepatch_560.call(this, WorldContextObject, Text, LogCategory, bAddToMessageLog) }; } catch (e) {};
try { let fnprepatch_561 = VisualLoggerKismetLibrary.prototype.LogSegment;VisualLoggerKismetLibrary.prototype.LogSegment = function (WorldContextObject, SegmentStart, SegmentEnd, Text, ObjectColor = {"R":0,"G":0,"B":1,"A":1}, Thickness = 0, CategoryName = "VisLogBP", bAddToMessageLog = false) { return fnprepatch_561.call(this, WorldContextObject, SegmentStart, SegmentEnd, Text, ObjectColor, Thickness, CategoryName, bAddToMessageLog) }; } catch (e) {};
try { let fnprepatch_562 = VisualLoggerKismetLibrary.prototype.LogLocation;VisualLoggerKismetLibrary.prototype.LogLocation = function (WorldContextObject, Location, Text, ObjectColor = {"R":0,"G":0,"B":1,"A":1}, Radius = 10, LogCategory = "VisLogBP", bAddToMessageLog = false) { return fnprepatch_562.call(this, WorldContextObject, Location, Text, ObjectColor, Radius, LogCategory, bAddToMessageLog) }; } catch (e) {};
try { let fnprepatch_563 = VisualLoggerKismetLibrary.prototype.LogBox;VisualLoggerKismetLibrary.prototype.LogBox = function (WorldContextObject, BoxShape, Text, ObjectColor = {"R":0,"G":0,"B":1,"A":1}, LogCategory = "VisLogBP", bAddToMessageLog = false) { return fnprepatch_563.call(this, WorldContextObject, BoxShape, Text, ObjectColor, LogCategory, bAddToMessageLog) }; } catch (e) {};
try { VisualLoggerKismetLibrary.prototype.VisLogText = VisualLoggerKismetLibrary.prototype.LogText; } catch (e) {};
try { VisualLoggerKismetLibrary.VisLogText = VisualLoggerKismetLibrary.LogText; } catch (e) {};
try { VisualLoggerKismetLibrary.prototype.VisLogSegment = VisualLoggerKismetLibrary.prototype.LogSegment; } catch (e) {};
try { VisualLoggerKismetLibrary.VisLogSegment = VisualLoggerKismetLibrary.LogSegment; } catch (e) {};
try { VisualLoggerKismetLibrary.prototype.VisLogLocation = VisualLoggerKismetLibrary.prototype.LogLocation; } catch (e) {};
try { VisualLoggerKismetLibrary.VisLogLocation = VisualLoggerKismetLibrary.LogLocation; } catch (e) {};
try { VisualLoggerKismetLibrary.prototype.VisLogBoxShape = VisualLoggerKismetLibrary.prototype.LogBox; } catch (e) {};
try { VisualLoggerKismetLibrary.VisLogBoxShape = VisualLoggerKismetLibrary.LogBox; } catch (e) {};
try { VisualLoggerKismetLibrary.prototype.EnableVisLogRecording = VisualLoggerKismetLibrary.prototype.EnableRecording; } catch (e) {};
try { VisualLoggerKismetLibrary.EnableVisLogRecording = VisualLoggerKismetLibrary.EnableRecording; } catch (e) {};
try { VOIPTalker.prototype.EndTalking = VOIPTalker.prototype.BPOnTalkingEnd; } catch (e) {};
try { VOIPTalker.prototype.BeginTalking = VOIPTalker.prototype.BPOnTalkingBegin; } catch (e) {};
try { let fnprepatch_564 = AnimationBlueprintLibrary.prototype.RemoveCurve;AnimationBlueprintLibrary.prototype.RemoveCurve = function (AnimationSequence, CurveName, bRemoveNameFromSkeleton = false) { return fnprepatch_564.call(this, AnimationSequence, CurveName, bRemoveNameFromSkeleton) }; } catch (e) {};
try { let fnprepatch_565 = AnimationBlueprintLibrary.prototype.RemoveBoneAnimation;AnimationBlueprintLibrary.prototype.RemoveBoneAnimation = function (AnimationSequence, BoneName, bIncludeChildren = true, bFinalize = true) { return fnprepatch_565.call(this, AnimationSequence, BoneName, bIncludeChildren, bFinalize) }; } catch (e) {};
try { let fnprepatch_566 = AnimationBlueprintLibrary.prototype.GetBonePosesForTime;AnimationBlueprintLibrary.prototype.GetBonePosesForTime = function (AnimationSequence, BoneNames, Time, bExtractRootMotion, Poses, PreviewMesh = undefined) { return fnprepatch_566.call(this, AnimationSequence, BoneNames, Time, bExtractRootMotion, Poses, PreviewMesh) }; } catch (e) {};
try { let fnprepatch_567 = AnimationBlueprintLibrary.prototype.GetBonePosesForFrame;AnimationBlueprintLibrary.prototype.GetBonePosesForFrame = function (AnimationSequence, BoneNames, Frame, bExtractRootMotion, Poses, PreviewMesh = undefined) { return fnprepatch_567.call(this, AnimationSequence, BoneNames, Frame, bExtractRootMotion, Poses, PreviewMesh) }; } catch (e) {};
try { let fnprepatch_568 = AnimationBlueprintLibrary.prototype.AddCurve;AnimationBlueprintLibrary.prototype.AddCurve = function (AnimationSequence, CurveName, CurveType = "RCT_Float", bMetaDataCurve = false) { return fnprepatch_568.call(this, AnimationSequence, CurveName, CurveType, bMetaDataCurve) }; } catch (e) {};
try { let fnprepatch_569 = AnimationBlueprintLibrary.prototype.AddAnimationNotifyTrack;AnimationBlueprintLibrary.prototype.AddAnimationNotifyTrack = function (AnimationSequence, NotifyTrackName, TrackColor = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_569.call(this, AnimationSequence, NotifyTrackName, TrackColor) }; } catch (e) {};
try { let fnprepatch_570 = AchievementWriteCallbackProxy.prototype.WriteAchievementProgress;AchievementWriteCallbackProxy.prototype.WriteAchievementProgress = function (WorldContextObject, PlayerController, AchievementName, Progress = 100, UserTag = 0) { return fnprepatch_570.call(this, WorldContextObject, PlayerController, AchievementName, Progress, UserTag) }; } catch (e) {};
try { InAppPurchaseQueryCallbackProxy.prototype.ReadInAppPurchaseInformation = InAppPurchaseQueryCallbackProxy.prototype.CreateProxyObjectForInAppPurchaseQuery; } catch (e) {};
try { InAppPurchaseQueryCallbackProxy.ReadInAppPurchaseInformation = InAppPurchaseQueryCallbackProxy.CreateProxyObjectForInAppPurchaseQuery; } catch (e) {};
try { LeaderboardQueryCallbackProxy.prototype.ReadLeaderboardInteger = LeaderboardQueryCallbackProxy.prototype.CreateProxyObjectForIntQuery; } catch (e) {};
try { LeaderboardQueryCallbackProxy.ReadLeaderboardInteger = LeaderboardQueryCallbackProxy.CreateProxyObjectForIntQuery; } catch (e) {};
try { let fnprepatch_571 = OculusFunctionLibrary.prototype.SetColorScaleAndOffset;OculusFunctionLibrary.prototype.SetColorScaleAndOffset = function (ColorScale, ColorOffset, bApplyToAllLayers = false) { return fnprepatch_571.call(this, ColorScale, ColorOffset, bApplyToAllLayers) }; } catch (e) {};
try { let fnprepatch_572 = OculusFunctionLibrary.prototype.HideLoadingSplashScreen;OculusFunctionLibrary.prototype.HideLoadingSplashScreen = function (bClear = false) { return fnprepatch_572.call(this, bClear) }; } catch (e) {};
try { let fnprepatch_573 = OculusFunctionLibrary.prototype.GetRawSensorData;OculusFunctionLibrary.prototype.GetRawSensorData = function (AngularAcceleration, LinearAcceleration, AngularVelocity, LinearVelocity, TimeInSeconds, DeviceType = "None") { return fnprepatch_573.call(this, AngularAcceleration, LinearAcceleration, AngularVelocity, LinearVelocity, TimeInSeconds, DeviceType) }; } catch (e) {};
try { let fnprepatch_574 = OculusFunctionLibrary.prototype.GetPose;OculusFunctionLibrary.prototype.GetPose = function (DeviceRotation, DevicePosition, NeckPosition, bUseOrienationForPlayerCamera = false, bUsePositionForPlayerCamera = false, PositionScale) { return fnprepatch_574.call(this, DeviceRotation, DevicePosition, NeckPosition, bUseOrienationForPlayerCamera, bUsePositionForPlayerCamera, PositionScale) }; } catch (e) {};
try { let fnprepatch_575 = OculusFunctionLibrary.prototype.GetGuardianPoints;OculusFunctionLibrary.prototype.GetGuardianPoints = function (BoundaryType, UsePawnSpace = false) { return fnprepatch_575.call(this, BoundaryType, UsePawnSpace) }; } catch (e) {};
try { let fnprepatch_576 = OculusFunctionLibrary.prototype.AddLoadingSplashScreen;OculusFunctionLibrary.prototype.AddLoadingSplashScreen = function (Texture, TranslationInMeters, Rotation, SizeInMeters = {"X":1,"Y":1}, DeltaRotation, bClearBeforeAdd = false) { return fnprepatch_576.call(this, Texture, TranslationInMeters, Rotation, SizeInMeters, DeltaRotation, bClearBeforeAdd) }; } catch (e) {};
try { let fnprepatch_577 = KismetProceduralMeshLibrary.prototype.CreateGridMeshWelded;KismetProceduralMeshLibrary.prototype.CreateGridMeshWelded = function (NumX, NumY, Triangles, Vertices, UVs, GridSpacing = 16) { return fnprepatch_577.call(this, NumX, NumY, Triangles, Vertices, UVs, GridSpacing) }; } catch (e) {};
try { let fnprepatch_578 = KismetProceduralMeshLibrary.prototype.CreateGridMeshSplit;KismetProceduralMeshLibrary.prototype.CreateGridMeshSplit = function (NumX, NumY, Triangles, Vertices, UVs, UV1s, GridSpacing = 16) { return fnprepatch_578.call(this, NumX, NumY, Triangles, Vertices, UVs, UV1s, GridSpacing) }; } catch (e) {};
try { ProceduralMeshComponent.prototype.UpdateMeshSection = ProceduralMeshComponent.prototype.UpdateMeshSection_LinearColor; } catch (e) {};
try { ProceduralMeshComponent.prototype.UpdateMeshSectionFColor = ProceduralMeshComponent.prototype.UpdateMeshSection; } catch (e) {};
try { ProceduralMeshComponent.prototype.CreateMeshSection = ProceduralMeshComponent.prototype.CreateMeshSection_LinearColor; } catch (e) {};
try { ProceduralMeshComponent.prototype.CreateMeshSectionFColor = ProceduralMeshComponent.prototype.CreateMeshSection; } catch (e) {};
try { let fnprepatch_579 = AssetTools.prototype.RenameAssetsWithDialog;AssetTools.prototype.RenameAssetsWithDialog = function (AssetsAndNames, bAutoCheckout = false) { return fnprepatch_579.call(this, AssetsAndNames, bAutoCheckout) }; } catch (e) {};
try { let fnprepatch_580 = AssetTools.prototype.CreateAssetWithDialog;AssetTools.prototype.CreateAssetWithDialog = function (AssetName, PackagePath, AssetClass, Factory, CallingContext = "None") { return fnprepatch_580.call(this, AssetName, PackagePath, AssetClass, Factory, CallingContext) }; } catch (e) {};
try { let fnprepatch_581 = AssetTools.prototype.CreateAsset;AssetTools.prototype.CreateAsset = function (AssetName, PackagePath, AssetClass, Factory, CallingContext = "None") { return fnprepatch_581.call(this, AssetName, PackagePath, AssetClass, Factory, CallingContext) }; } catch (e) {};
try { let fnprepatch_582 = AutomationBlueprintFunctionLibrary.prototype.TakeHighResScreenshot;AutomationBlueprintFunctionLibrary.prototype.TakeHighResScreenshot = function (ResX, ResY, Filename, Camera = undefined, bMaskEnabled = false, bCaptureHDR = false) { return fnprepatch_582.call(this, ResX, ResY, Filename, Camera, bMaskEnabled, bCaptureHDR) }; } catch (e) {};
try { let fnprepatch_583 = AutomationBlueprintFunctionLibrary.prototype.SetScalabilityQualityLevelRelativeToMax;AutomationBlueprintFunctionLibrary.prototype.SetScalabilityQualityLevelRelativeToMax = function (WorldContextObject, Value = 1) { return fnprepatch_583.call(this, WorldContextObject, Value) }; } catch (e) {};
try { let fnprepatch_584 = AutomationBlueprintFunctionLibrary.prototype.GetDefaultScreenshotOptionsForRendering;AutomationBlueprintFunctionLibrary.prototype.GetDefaultScreenshotOptionsForRendering = function (Tolerance = "Low", Delay = 0.20000000298023224) { return fnprepatch_584.call(this, Tolerance, Delay) }; } catch (e) {};
try { let fnprepatch_585 = AutomationBlueprintFunctionLibrary.prototype.GetDefaultScreenshotOptionsForGameplay;AutomationBlueprintFunctionLibrary.prototype.GetDefaultScreenshotOptionsForGameplay = function (Tolerance = "Low", Delay = 0.20000000298023224) { return fnprepatch_585.call(this, Tolerance, Delay) }; } catch (e) {};
try { let fnprepatch_586 = FunctionalTest.prototype.AssertValue_Int;FunctionalTest.prototype.AssertValue_Int = function (Actual, ShouldBe, Expected, What, ContextObject = undefined) { return fnprepatch_586.call(this, Actual, ShouldBe, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_587 = FunctionalTest.prototype.AssertValue_Float;FunctionalTest.prototype.AssertValue_Float = function (Actual, ShouldBe, Expected, What, ContextObject = undefined) { return fnprepatch_587.call(this, Actual, ShouldBe, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_588 = FunctionalTest.prototype.AssertValue_DateTime;FunctionalTest.prototype.AssertValue_DateTime = function (Actual, ShouldBe, Expected, What, ContextObject = undefined) { return fnprepatch_588.call(this, Actual, ShouldBe, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_589 = FunctionalTest.prototype.AssertTrue;FunctionalTest.prototype.AssertTrue = function (Condition, Message, ContextObject = undefined) { return fnprepatch_589.call(this, Condition, Message, ContextObject) }; } catch (e) {};
try { let fnprepatch_590 = FunctionalTest.prototype.AssertNotEqual_Vector;FunctionalTest.prototype.AssertNotEqual_Vector = function (Actual, NotExpected, What, ContextObject = undefined) { return fnprepatch_590.call(this, Actual, NotExpected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_591 = FunctionalTest.prototype.AssertNotEqual_Transform;FunctionalTest.prototype.AssertNotEqual_Transform = function (Actual, NotExpected, What, ContextObject = undefined) { return fnprepatch_591.call(this, Actual, NotExpected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_592 = FunctionalTest.prototype.AssertNotEqual_String;FunctionalTest.prototype.AssertNotEqual_String = function (Actual, NotExpected, What, ContextObject = undefined) { return fnprepatch_592.call(this, Actual, NotExpected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_593 = FunctionalTest.prototype.AssertNotEqual_Rotator;FunctionalTest.prototype.AssertNotEqual_Rotator = function (Actual, NotExpected, What, ContextObject = undefined) { return fnprepatch_593.call(this, Actual, NotExpected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_594 = FunctionalTest.prototype.AssertIsValid;FunctionalTest.prototype.AssertIsValid = function (Object, Message, ContextObject = undefined) { return fnprepatch_594.call(this, Object, Message, ContextObject) }; } catch (e) {};
try { let fnprepatch_595 = FunctionalTest.prototype.AssertFalse;FunctionalTest.prototype.AssertFalse = function (Condition, Message, ContextObject = undefined) { return fnprepatch_595.call(this, Condition, Message, ContextObject) }; } catch (e) {};
try { let fnprepatch_596 = FunctionalTest.prototype.AssertEqual_Vector;FunctionalTest.prototype.AssertEqual_Vector = function (Actual, Expected, What, Tolerance = 0.00009999999747378752, ContextObject = undefined) { return fnprepatch_596.call(this, Actual, Expected, What, Tolerance, ContextObject) }; } catch (e) {};
try { let fnprepatch_597 = FunctionalTest.prototype.AssertEqual_Transform;FunctionalTest.prototype.AssertEqual_Transform = function (Actual, Expected, What, Tolerance = 0.00009999999747378752, ContextObject = undefined) { return fnprepatch_597.call(this, Actual, Expected, What, Tolerance, ContextObject) }; } catch (e) {};
try { let fnprepatch_598 = FunctionalTest.prototype.AssertEqual_TraceQueryResults;FunctionalTest.prototype.AssertEqual_TraceQueryResults = function (Actual, Expected, What, ContextObject = undefined) { return fnprepatch_598.call(this, Actual, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_599 = FunctionalTest.prototype.AssertEqual_String;FunctionalTest.prototype.AssertEqual_String = function (Actual, Expected, What, ContextObject = undefined) { return fnprepatch_599.call(this, Actual, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_600 = FunctionalTest.prototype.AssertEqual_Rotator;FunctionalTest.prototype.AssertEqual_Rotator = function (Actual, Expected, What, Tolerance = 0.00009999999747378752, ContextObject = undefined) { return fnprepatch_600.call(this, Actual, Expected, What, Tolerance, ContextObject) }; } catch (e) {};
try { let fnprepatch_601 = FunctionalTest.prototype.AssertEqual_Name;FunctionalTest.prototype.AssertEqual_Name = function (Actual, Expected, What, ContextObject = undefined) { return fnprepatch_601.call(this, Actual, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_602 = FunctionalTest.prototype.AssertEqual_Int;FunctionalTest.prototype.AssertEqual_Int = function (Actual, Expected, What, ContextObject = undefined) { return fnprepatch_602.call(this, Actual, Expected, What, ContextObject) }; } catch (e) {};
try { let fnprepatch_603 = FunctionalTest.prototype.AssertEqual_Float;FunctionalTest.prototype.AssertEqual_Float = function (Actual, Expected, What, Tolerance = 0.00009999999747378752, ContextObject = undefined) { return fnprepatch_603.call(this, Actual, Expected, What, Tolerance, ContextObject) }; } catch (e) {};
try { let fnprepatch_604 = FunctionalTest.prototype.AssertEqual_Bool;FunctionalTest.prototype.AssertEqual_Bool = function (Actual, Expected, What, ContextObject = undefined) { return fnprepatch_604.call(this, Actual, Expected, What, ContextObject) }; } catch (e) {};
try { FunctionalTest.prototype.StartTest = FunctionalTest.prototype.ReceiveStartTest; } catch (e) {};
try { FunctionalTest.prototype.PrepareTest = FunctionalTest.prototype.ReceivePrepareTest; } catch (e) {};
try { FunctionalTest.prototype.AssertValue = FunctionalTest.prototype.AssertValue_Int; } catch (e) {};
try { FunctionalTest.prototype.AssertValue = FunctionalTest.prototype.AssertValue_Float; } catch (e) {};
try { FunctionalTest.prototype.AssertValue = FunctionalTest.prototype.AssertValue_DateTime; } catch (e) {};
try { FunctionalTest.prototype.AssertNotEqual = FunctionalTest.prototype.AssertNotEqual_Vector; } catch (e) {};
try { FunctionalTest.prototype.AssertNotEqual = FunctionalTest.prototype.AssertNotEqual_Transform; } catch (e) {};
try { FunctionalTest.prototype.AssertNotEqual = FunctionalTest.prototype.AssertNotEqual_String; } catch (e) {};
try { FunctionalTest.prototype.AssertNotEqual = FunctionalTest.prototype.AssertNotEqual_Rotator; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Vector; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Transform; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_TraceQueryResults; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_String; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Rotator; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Name; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Int; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Float; } catch (e) {};
try { FunctionalTest.prototype.AssertEqual = FunctionalTest.prototype.AssertEqual_Bool; } catch (e) {};
try { let fnprepatch_605 = FunctionalTestingManager.prototype.RunAllFunctionalTests;FunctionalTestingManager.prototype.RunAllFunctionalTests = function (WorldContextObject, bNewLog = true, bRunLooped = false, FailedTestsReproString) { return fnprepatch_605.call(this, WorldContextObject, bNewLog, bRunLooped, FailedTestsReproString) }; } catch (e) {};
try { let fnprepatch_606 = FunctionalTestUtilityLibrary.prototype.TraceChannelTestUtil;FunctionalTestUtilityLibrary.prototype.TraceChannelTestUtil = function (WorldContextObject, BatchOptions, Start, End, SphereCapsuleRadius, CapsuleHalfHeight, BoxHalfSize, Orientation, TraceChannel, ObjectTypes, ProfileName, bTraceComplex, ActorsToIgnore, bIgnoreSelf, DrawDebugType, TraceColor = {"R":1,"G":0,"B":0,"A":1}, TraceHitColor = {"R":0,"G":1,"B":0,"A":1}, DrawTime = 5) { return fnprepatch_606.call(this, WorldContextObject, BatchOptions, Start, End, SphereCapsuleRadius, CapsuleHalfHeight, BoxHalfSize, Orientation, TraceChannel, ObjectTypes, ProfileName, bTraceComplex, ActorsToIgnore, bIgnoreSelf, DrawDebugType, TraceColor, TraceHitColor, DrawTime) }; } catch (e) {};
try { let fnprepatch_607 = MediaBlueprintFunctionLibrary.prototype.EnumerateWebcamCaptureDevices;MediaBlueprintFunctionLibrary.prototype.EnumerateWebcamCaptureDevices = function (OutDevices, Filter = -1) { return fnprepatch_607.call(this, OutDevices, Filter) }; } catch (e) {};
try { let fnprepatch_608 = MediaBlueprintFunctionLibrary.prototype.EnumerateVideoCaptureDevices;MediaBlueprintFunctionLibrary.prototype.EnumerateVideoCaptureDevices = function (OutDevices, Filter = -1) { return fnprepatch_608.call(this, OutDevices, Filter) }; } catch (e) {};
try { let fnprepatch_609 = MediaBlueprintFunctionLibrary.prototype.EnumerateAudioCaptureDevices;MediaBlueprintFunctionLibrary.prototype.EnumerateAudioCaptureDevices = function (OutDevices, Filter = -1) { return fnprepatch_609.call(this, OutDevices, Filter) }; } catch (e) {};
try { let fnprepatch_610 = MediaSoundComponent.prototype.SetSpectralAnalysisSettings;MediaSoundComponent.prototype.SetSpectralAnalysisSettings = function (InFrequenciesToAnalyze, InFFTSize = "Min_64") { return fnprepatch_610.call(this, InFrequenciesToAnalyze, InFFTSize) }; } catch (e) {};
try { MediaSoundComponent.prototype.GetAttenuationSettingsToApply = MediaSoundComponent.prototype.BP_GetAttenuationSettingsToApply; } catch (e) {};
try { let fnprepatch_611 = PaperFlipbook.prototype.GetSpriteAtTime;PaperFlipbook.prototype.GetSpriteAtTime = function (Time, bClampToEnds = false) { return fnprepatch_611.call(this, Time, bClampToEnds) }; } catch (e) {};
try { let fnprepatch_612 = PaperFlipbook.prototype.GetKeyFrameIndexAtTime;PaperFlipbook.prototype.GetKeyFrameIndexAtTime = function (Time, bClampToEnds = false) { return fnprepatch_612.call(this, Time, bClampToEnds) }; } catch (e) {};
try { let fnprepatch_613 = PaperGroupedSpriteComponent.prototype.UpdateInstanceTransform;PaperGroupedSpriteComponent.prototype.UpdateInstanceTransform = function (InstanceIndex, NewInstanceTransform, bWorldSpace = false, bMarkRenderStateDirty = true, bTeleport = false) { return fnprepatch_613.call(this, InstanceIndex, NewInstanceTransform, bWorldSpace, bMarkRenderStateDirty, bTeleport) }; } catch (e) {};
try { let fnprepatch_614 = PaperGroupedSpriteComponent.prototype.UpdateInstanceColor;PaperGroupedSpriteComponent.prototype.UpdateInstanceColor = function (InstanceIndex, NewInstanceColor, bMarkRenderStateDirty = true) { return fnprepatch_614.call(this, InstanceIndex, NewInstanceColor, bMarkRenderStateDirty) }; } catch (e) {};
try { let fnprepatch_615 = PaperGroupedSpriteComponent.prototype.GetInstanceTransform;PaperGroupedSpriteComponent.prototype.GetInstanceTransform = function (InstanceIndex, OutInstanceTransform, bWorldSpace = false) { return fnprepatch_615.call(this, InstanceIndex, OutInstanceTransform, bWorldSpace) }; } catch (e) {};
try { let fnprepatch_616 = PaperGroupedSpriteComponent.prototype.AddInstance;PaperGroupedSpriteComponent.prototype.AddInstance = function (Transform, Sprite, bWorldSpace = false, Color = {"R":1,"G":1,"B":1,"A":1}) { return fnprepatch_616.call(this, Transform, Sprite, bWorldSpace, Color) }; } catch (e) {};
try { let fnprepatch_617 = PaperTileMapComponent.prototype.SetLayerColor;PaperTileMapComponent.prototype.SetLayerColor = function (NewColor, Layer = 0) { return fnprepatch_617.call(this, NewColor, Layer) }; } catch (e) {};
try { let fnprepatch_618 = PaperTileMapComponent.prototype.SetLayerCollision;PaperTileMapComponent.prototype.SetLayerCollision = function (Layer = 0, bHasCollision = true, bOverrideThickness = true, CustomThickness = 50, bOverrideOffset = false, CustomOffset = 0, bRebuildCollision = true) { return fnprepatch_618.call(this, Layer, bHasCollision, bOverrideThickness, CustomThickness, bOverrideOffset, CustomOffset, bRebuildCollision) }; } catch (e) {};
try { let fnprepatch_619 = PaperTileMapComponent.prototype.SetDefaultCollisionThickness;PaperTileMapComponent.prototype.SetDefaultCollisionThickness = function (Thickness, bRebuildCollision = true) { return fnprepatch_619.call(this, Thickness, bRebuildCollision) }; } catch (e) {};
try { let fnprepatch_620 = PaperTileMapComponent.prototype.GetTilePolygon;PaperTileMapComponent.prototype.GetTilePolygon = function (TileX, TileY, Points, LayerIndex = 0, bWorldSpace = false) { return fnprepatch_620.call(this, TileX, TileY, Points, LayerIndex, bWorldSpace) }; } catch (e) {};
try { let fnprepatch_621 = PaperTileMapComponent.prototype.GetTileCornerPosition;PaperTileMapComponent.prototype.GetTileCornerPosition = function (TileX, TileY, LayerIndex = 0, bWorldSpace = false) { return fnprepatch_621.call(this, TileX, TileY, LayerIndex, bWorldSpace) }; } catch (e) {};
try { let fnprepatch_622 = PaperTileMapComponent.prototype.GetTileCenterPosition;PaperTileMapComponent.prototype.GetTileCenterPosition = function (TileX, TileY, LayerIndex = 0, bWorldSpace = false) { return fnprepatch_622.call(this, TileX, TileY, LayerIndex, bWorldSpace) }; } catch (e) {};
try { let fnprepatch_623 = PaperTileMapComponent.prototype.GetLayerColor;PaperTileMapComponent.prototype.GetLayerColor = function (Layer = 0) { return fnprepatch_623.call(this, Layer) }; } catch (e) {};
try { let fnprepatch_624 = PaperTileMapComponent.prototype.CreateNewTileMap;PaperTileMapComponent.prototype.CreateNewTileMap = function (MapWidth = 4, MapHeight = 4, TileWidth = 32, TileHeight = 32, PixelsPerUnrealUnit = 1, bCreateLayer = true) { return fnprepatch_624.call(this, MapWidth, MapHeight, TileWidth, TileHeight, PixelsPerUnrealUnit, bCreateLayer) }; } catch (e) {};
try { AnimationSharingManager.prototype.RegisterActor = AnimationSharingManager.prototype.RegisterActorWithSkeletonBP; } catch (e) {};
try { let fnprepatch_625 = MagicLeapHandTrackingFunctionLibrary.prototype.SetConfiguration;MagicLeapHandTrackingFunctionLibrary.prototype.SetConfiguration = function (StaticGesturesToActivate, KeypointsFilterLevel = "NoFilter", GestureFilterLevel = "NoFilter", HandSwitchingFilterLevel = "NoFilter", bTrackingEnabled = true) { return fnprepatch_625.call(this, StaticGesturesToActivate, KeypointsFilterLevel, GestureFilterLevel, HandSwitchingFilterLevel, bTrackingEnabled) }; } catch (e) {};
try { let fnprepatch_626 = JavascriptComponent.prototype.ResolveAsset;JavascriptComponent.prototype.ResolveAsset = function (Name, bTryLoad = true) { return fnprepatch_626.call(this, Name, bTryLoad) }; } catch (e) {};
try { let fnprepatch_627 = JavascriptContext.prototype.RunScript;JavascriptContext.prototype.RunScript = function (Script, bOutput = true) { return fnprepatch_627.call(this, Script, bOutput) }; } catch (e) {};
try { let fnprepatch_628 = JavascriptContext.prototype.CreateInspector;JavascriptContext.prototype.CreateInspector = function (Port = 9229) { return fnprepatch_628.call(this, Port) }; } catch (e) {};
try { let fnprepatch_629 = JavascriptLibrary.prototype.DeleteFile;JavascriptLibrary.prototype.DeleteFile = function (Filename, ReadOnly = false) { return fnprepatch_629.call(this, Filename, ReadOnly) }; } catch (e) {};
try { let fnprepatch_630 = JavascriptLibrary.prototype.CreateSocket;JavascriptLibrary.prototype.CreateSocket = function (SocketType, Description, bForceUDP = false) { return fnprepatch_630.call(this, SocketType, Description, bForceUDP) }; } catch (e) {};
try { let fnprepatch_631 = JavascriptProcess.prototype.Terminate;JavascriptProcess.prototype.Terminate = function (KillTree = false) { return fnprepatch_631.call(this, KillTree) }; } catch (e) {};
try { let fnprepatch_632 = JavascriptUMGLibrary.prototype.AddWindow;JavascriptUMGLibrary.prototype.AddWindow = function (NewWindow, bShowImmediately = true) { return fnprepatch_632.call(this, NewWindow, bShowImmediately) }; } catch (e) {};
try { let fnprepatch_633 = LevelVariantSetsActor.prototype.GetLevelVariantSets;LevelVariantSetsActor.prototype.GetLevelVariantSets = function (bLoad = false) { return fnprepatch_633.call(this, bLoad) }; } catch (e) {};
try { let fnprepatch_634 = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToTIFF;AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToTIFF = function (SourceImage, bWantColor = true, bUseGpu = true, Scale = 1, Rotate = "None") { return fnprepatch_634.call(this, SourceImage, bWantColor, bUseGpu, Scale, Rotate) }; } catch (e) {};
try { let fnprepatch_635 = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToPNG;AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToPNG = function (SourceImage, bWantColor = true, bUseGpu = true, Scale = 1, Rotate = "None") { return fnprepatch_635.call(this, SourceImage, bWantColor, bUseGpu, Scale, Rotate) }; } catch (e) {};
try { let fnprepatch_636 = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToJPEG;AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToJPEG = function (SourceImage, Quality = 85, bWantColor = true, bUseGpu = true, Scale = 1, Rotate = "None") { return fnprepatch_636.call(this, SourceImage, Quality, bWantColor, bUseGpu, Scale, Rotate) }; } catch (e) {};
try { let fnprepatch_637 = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToHEIF;AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToHEIF = function (SourceImage, Quality = 85, bWantColor = true, bUseGpu = true, Scale = 1, Rotate = "None") { return fnprepatch_637.call(this, SourceImage, Quality, bWantColor, bUseGpu, Scale, Rotate) }; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.ConvertToTIFF = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToTIFF; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.ConvertToTIFF = AppleImageUtilsBaseAsyncTaskBlueprintProxy.CreateProxyObjectForConvertToTIFF; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.ConvertToPNG = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToPNG; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.ConvertToPNG = AppleImageUtilsBaseAsyncTaskBlueprintProxy.CreateProxyObjectForConvertToPNG; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.ConvertToJPEG = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToJPEG; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.ConvertToJPEG = AppleImageUtilsBaseAsyncTaskBlueprintProxy.CreateProxyObjectForConvertToJPEG; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.ConvertToHEIF = AppleImageUtilsBaseAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForConvertToHEIF; } catch (e) {};
try { AppleImageUtilsBaseAsyncTaskBlueprintProxy.ConvertToHEIF = AppleImageUtilsBaseAsyncTaskBlueprintProxy.CreateProxyObjectForConvertToHEIF; } catch (e) {};
try { AppleVisionDetectFacesAsyncTaskBlueprintProxy.prototype.DetectFaces = AppleVisionDetectFacesAsyncTaskBlueprintProxy.prototype.CreateProxyObjectForDetectFaces; } catch (e) {};
try { AppleVisionDetectFacesAsyncTaskBlueprintProxy.DetectFaces = AppleVisionDetectFacesAsyncTaskBlueprintProxy.CreateProxyObjectForDetectFaces; } catch (e) {};
try { DropTimecodeToStringConversion.prototype.ToString = DropTimecodeToStringConversion.prototype.Conv_DropTimecodeToString; } catch (e) {};
try { DropTimecodeToStringConversion.ToString = DropTimecodeToStringConversion.Conv_DropTimecodeToString; } catch (e) {};
try { let fnprepatch_638 = NUTActor.prototype.UnitTravel;NUTActor.prototype.UnitTravel = function (Dest = " ") { return fnprepatch_638.call(this, Dest) }; } catch (e) {};
try { let fnprepatch_639 = NUTActor.prototype.UnitSeamlessTravel;NUTActor.prototype.UnitSeamlessTravel = function (Dest = " ") { return fnprepatch_639.call(this, Dest) }; } catch (e) {};
try { AndroidPermissionFunctionLibrary.prototype.CheckAndroidPermission = AndroidPermissionFunctionLibrary.prototype.CheckPermission; } catch (e) {};
try { AndroidPermissionFunctionLibrary.CheckAndroidPermission = AndroidPermissionFunctionLibrary.CheckPermission; } catch (e) {};
try { AndroidPermissionFunctionLibrary.prototype.RequestAndroidPermissions = AndroidPermissionFunctionLibrary.prototype.AcquirePermissions; } catch (e) {};
try { AndroidPermissionFunctionLibrary.RequestAndroidPermissions = AndroidPermissionFunctionLibrary.AcquirePermissions; } catch (e) {};
try { let fnprepatch_640 = CableComponent.prototype.SetAttachEndToComponent;CableComponent.prototype.SetAttachEndToComponent = function (Component, SocketName = "None") { return fnprepatch_640.call(this, Component, SocketName) }; } catch (e) {};
try { let fnprepatch_641 = CableComponent.prototype.SetAttachEndTo;CableComponent.prototype.SetAttachEndTo = function (Actor, ComponentProperty, SocketName = "None") { return fnprepatch_641.call(this, Actor, ComponentProperty, SocketName) }; } catch (e) {};
try { let fnprepatch_642 = EditableMesh.prototype.EndModification;EditableMesh.prototype.EndModification = function (bFromUndo = false) { return fnprepatch_642.call(this, bFromUndo) }; } catch (e) {};
try { let fnprepatch_643 = SteamVRControllerLibrary.prototype.SetTouchDPadMapping;SteamVRControllerLibrary.prototype.SetTouchDPadMapping = function (NewMapping = "FaceButtons") { return fnprepatch_643.call(this, NewMapping) }; } catch (e) {};
try { let fnprepatch_644 = JavascriptGraphEditorLibrary.prototype.NodeCreator;JavascriptGraphEditorLibrary.prototype.NodeCreator = function (Graph, bSelectNewNode = true) { return fnprepatch_644.call(this, Graph, bSelectNewNode) }; } catch (e) {};
try { let fnprepatch_645 = JavascriptGraphEditorWidget.prototype.JumpToNode;JavascriptGraphEditorWidget.prototype.JumpToNode = function (JumpToMe, bRequestRename = false, bSelectNode = true) { return fnprepatch_645.call(this, JumpToMe, bRequestRename, bSelectNode) }; } catch (e) {};
try { let fnprepatch_646 = JavascriptGraphEdNode.prototype.GetNumOfPins;JavascriptGraphEdNode.prototype.GetNumOfPins = function (Direction = "EGPD_MAX") { return fnprepatch_646.call(this, Direction) }; } catch (e) {};
try { let fnprepatch_647 = JavascriptEditorEngineLibrary.prototype.SelectNone;JavascriptEditorEngineLibrary.prototype.SelectNone = function (Engine, bNoteSelectionChange, bDeselectBSPSurfs, WarnAboutManyActors = true) { return fnprepatch_647.call(this, Engine, bNoteSelectionChange, bDeselectBSPSurfs, WarnAboutManyActors) }; } catch (e) {};
try { let fnprepatch_648 = JavascriptEditorEngineLibrary.prototype.SelectGroup;JavascriptEditorEngineLibrary.prototype.SelectGroup = function (Engine, InGroupActor, bForceSelection = false, bInSelected = true, bNotify = true) { return fnprepatch_648.call(this, Engine, InGroupActor, bForceSelection, bInSelected, bNotify) }; } catch (e) {};
try { let fnprepatch_649 = JavascriptEditorEngineLibrary.prototype.SelectComponent;JavascriptEditorEngineLibrary.prototype.SelectComponent = function (Engine, Component, bInSelected, bNotify, bSelectEvenIfHidden = false) { return fnprepatch_649.call(this, Engine, Component, bInSelected, bNotify, bSelectEvenIfHidden) }; } catch (e) {};
try { let fnprepatch_650 = JavascriptEditorEngineLibrary.prototype.SelectActor;JavascriptEditorEngineLibrary.prototype.SelectActor = function (Engine, Actor, bInSelected, bNotify, bSelectEvenIfHidden = false, bForceRefresh = false) { return fnprepatch_650.call(this, Engine, Actor, bInSelected, bNotify, bSelectEvenIfHidden, bForceRefresh) }; } catch (e) {};
try { let fnprepatch_651 = JavascriptEditorEngineLibrary.prototype.CanSelectActor;JavascriptEditorEngineLibrary.prototype.CanSelectActor = function (Engine, Actor, bInSelected, bSelectEvenIfHidden = false, bWarnIfLevelLocked = false) { return fnprepatch_651.call(this, Engine, Actor, bInSelected, bSelectEvenIfHidden, bWarnIfLevelLocked) }; } catch (e) {};
try { let fnprepatch_652 = JavascriptEditorEngineLibrary.prototype.bspBrushCSG;JavascriptEditorEngineLibrary.prototype.bspBrushCSG = function (Engine, Actor, Model, PolyFlags, BrushType, CSGOper, bBuildBounds, bMergePolys, bReplaceNULLMaterialRefs, bShowProgressBar = true) { return fnprepatch_652.call(this, Engine, Actor, Model, PolyFlags, BrushType, CSGOper, bBuildBounds, bMergePolys, bReplaceNULLMaterialRefs, bShowProgressBar) }; } catch (e) {};
try { let fnprepatch_653 = JavascriptEditorLibrary.prototype.SetAlphamapDataFromMemory;JavascriptEditorLibrary.prototype.SetAlphamapDataFromMemory = function (LandscapeInfo, LayerInfo, MinX, MinY, MaxX, MaxY, PaintingRestriction = "None") { return fnprepatch_653.call(this, LandscapeInfo, LayerInfo, MinX, MinY, MaxX, MaxY, PaintingRestriction) }; } catch (e) {};
try { let fnprepatch_654 = JavascriptEditorLibrary.prototype.RemoveComponentFromBlueprint;JavascriptEditorLibrary.prototype.RemoveComponentFromBlueprint = function (Blueprint, RemoveComponent, bPromoteChildren = false) { return fnprepatch_654.call(this, Blueprint, RemoveComponent, bPromoteChildren) }; } catch (e) {};
try { let fnprepatch_655 = JavascriptEditorLibrary.prototype.ModifyObject;JavascriptEditorLibrary.prototype.ModifyObject = function (Object, bAlwaysMarkDirty = false) { return fnprepatch_655.call(this, Object, bAlwaysMarkDirty) }; } catch (e) {};
try { let fnprepatch_656 = JavascriptEditorLibrary.prototype.GetLayerInfoByName;JavascriptEditorLibrary.prototype.GetLayerInfoByName = function (LandscapeInfo, LayerName, Owner = undefined) { return fnprepatch_656.call(this, LandscapeInfo, LayerName, Owner) }; } catch (e) {};
try { let fnprepatch_657 = JavascriptEditorLibrary.prototype.GetDataTableAsJSON;JavascriptEditorLibrary.prototype.GetDataTableAsJSON = function (InDataTable, InDTExportFlags = 0) { return fnprepatch_657.call(this, InDataTable, InDTExportFlags) }; } catch (e) {};
try { let fnprepatch_658 = JavascriptEditorLibrary.prototype.GetAssetsByType;JavascriptEditorLibrary.prototype.GetAssetsByType = function (Types, bRecursiveClasses = true) { return fnprepatch_658.call(this, Types, bRecursiveClasses) }; } catch (e) {};
try { let fnprepatch_659 = JavascriptEditorLibrary.prototype.DeselectAll;JavascriptEditorLibrary.prototype.DeselectAll = function (Selection, InClass = null) { return fnprepatch_659.call(this, Selection, InClass) }; } catch (e) {};
try { let fnprepatch_660 = JavascriptEditorLibrary.prototype.Build;JavascriptEditorLibrary.prototype.Build = function (Builder, InWorld, InBrush = undefined) { return fnprepatch_660.call(this, Builder, InWorld, InBrush) }; } catch (e) {};
try { let fnprepatch_661 = JavascriptEditorLibrary.prototype.AddComponentsToBlueprint;JavascriptEditorLibrary.prototype.AddComponentsToBlueprint = function (Blueprint, Components, bHarvesting = false, OptionalNewRootComponent = undefined, bKeepMobility = false) { return fnprepatch_661.call(this, Blueprint, Components, bHarvesting, OptionalNewRootComponent, bKeepMobility) }; } catch (e) {};
try { let fnprepatch_662 = JavascriptPropertyCustomizationLibrary.prototype.AddExternalObjects;JavascriptPropertyCustomizationLibrary.prototype.AddExternalObjects = function (ChildBuilder, Objects, UniqueIdName = "None") { return fnprepatch_662.call(this, ChildBuilder, Objects, UniqueIdName) }; } catch (e) {};
try { let fnprepatch_663 = JavascriptPropertyCustomizationLibrary.prototype.AddExternalObjectProperty;JavascriptPropertyCustomizationLibrary.prototype.AddExternalObjectProperty = function (ChildBuilder, Objects, PropertyName, UniqueIdName = "None", bAllowChildrenOverride = false, bCreateCategoryNodesOverride = false) { return fnprepatch_663.call(this, ChildBuilder, Objects, PropertyName, UniqueIdName, bAllowChildrenOverride, bCreateCategoryNodesOverride) }; } catch (e) {};
try { Guid.prototype.ToString = Guid.prototype.Conv_GuidToString; } catch (e) {};
try { Guid.prototype.Equal = Guid.prototype.EqualEqual_GuidGuid; } catch (e) {};
try { Guid.prototype.IsValid = Guid.prototype.IsValid_Guid; } catch (e) {};
try { Guid.prototype.NotEqual = Guid.prototype.NotEqual_GuidGuid; } catch (e) {};
try { Vector.prototype.ToText = Vector.prototype.Conv_VectorToText; } catch (e) {};
try { Vector.prototype.ToString = Vector.prototype.Conv_VectorToString; } catch (e) {};
try { Vector.prototype.ToLinearColor = Vector.prototype.Conv_VectorToLinearColor; } catch (e) {};
try { Vector.prototype.ToQuaterion = Vector.prototype.Conv_VectorToQuaterion; } catch (e) {};
try { Vector.prototype.RotationFromXVector = Vector.prototype.Conv_VectorToRotator; } catch (e) {};
try { Vector.prototype.ToTransform = Vector.prototype.Conv_VectorToTransform; } catch (e) {};
try { Vector.prototype.ToVector2D = Vector.prototype.Conv_VectorToVector2D; } catch (e) {};
try { Vector.prototype.CrossProduct = Vector.prototype.Cross_VectorVector; } catch (e) {};
try { Vector.prototype.DotProduct = Vector.prototype.Dot_VectorVector; } catch (e) {};
try { Vector.prototype.Equal = Vector.prototype.EqualEqual_VectorVector; } catch (e) {};
try { Vector.prototype.EqualExactly = Vector.prototype.EqualExactly_VectorVector; } catch (e) {};
try { Vector.prototype.Truncate = Vector.prototype.FTruncVector; } catch (e) {};
try { Vector.prototype.GetUnitDirection = Vector.prototype.GetDirectionUnitVector; } catch (e) {};
try { Vector.prototype.RotateVector = Vector.prototype.GreaterGreater_VectorRotator; } catch (e) {};
try { Vector.prototype.UnrotateVector = Vector.prototype.LessLess_VectorRotator; } catch (e) {};
try { Vector.prototype.LinePlaneIntersection = Vector.prototype.LinePlaneIntersection_OriginNormal; } catch (e) {};
try { Vector.prototype.Normalize = Vector.prototype.Normal; } catch (e) {};
try { Vector.prototype.NotEqual = Vector.prototype.NotEqual_VectorVector; } catch (e) {};
try { Vector.prototype.NotEqualExactly = Vector.prototype.NotEqualExactly_VectorVector; } catch (e) {};
try { Vector.prototype.MakefromEuler = Vector.prototype.Quat_MakeFromEuler; } catch (e) {};
try { Vector.prototype.RotateVectorAroundAxis = Vector.prototype.RotateAngleAxis; } catch (e) {};
try { Vector.prototype.Ease = Vector.prototype.VEase; } catch (e) {};
try { Vector.prototype.Distance = Vector.prototype.Vector_Distance; } catch (e) {};
try { Vector.prototype.Distance2D = Vector.prototype.Vector_Distance2D; } catch (e) {};
try { Vector.prototype.Distance2DSquared = Vector.prototype.Vector_Distance2DSquared; } catch (e) {};
try { Vector.prototype.DistanceSquared = Vector.prototype.Vector_DistanceSquared; } catch (e) {};
try { Vector.prototype.IsNormal = Vector.prototype.Vector_IsNormal; } catch (e) {};
try { Vector.prototype.IsUniform = Vector.prototype.Vector_IsUniform; } catch (e) {};
try { Vector.prototype.IsUnit = Vector.prototype.Vector_IsUnit; } catch (e) {};
try { Vector.prototype.Normalize2D = Vector.prototype.Vector_Normal2D; } catch (e) {};
try { Vector.prototype.NormalizeInPlace = Vector.prototype.Vector_Normalize; } catch (e) {};
try { Vector.prototype.Normalunsafe = Vector.prototype.Vector_NormalUnsafe; } catch (e) {};
try { Vector.prototype.Reciprocal = Vector.prototype.Vector_Reciprocal; } catch (e) {};
try { Vector.prototype.Lerp = Vector.prototype.VLerp; } catch (e) {};
try { Vector.prototype.VectorLength = Vector.prototype.VSize; } catch (e) {};
try { Vector.prototype.VectorLengthSquared = Vector.prototype.VSizeSquared; } catch (e) {};
try { Vector.prototype.VectorLengthXY = Vector.prototype.VSizeXY; } catch (e) {};
try { Vector.prototype.VectorLengthXYSquared = Vector.prototype.VSizeXYSquared; } catch (e) {};
try { Vector.prototype.TwoBoneIKFunction = Vector.prototype.K2_TwoBoneIK; } catch (e) {};
try { Vector.prototype.AddAREnvironmentProbe = Vector.prototype.AddManualEnvironmentCaptureProbe; } catch (e) {};
try { Vector4.prototype.ToQuaterion = Vector4.prototype.Conv_Vector4ToQuaterion; } catch (e) {};
try { Vector4.prototype.ToRotation = Vector4.prototype.Conv_Vector4ToRotator; } catch (e) {};
try { Vector4.prototype.ToVector = Vector4.prototype.Conv_Vector4ToVector; } catch (e) {};
try { Vector4.prototype.Equal = Vector4.prototype.EqualEqual_Vector4Vector4; } catch (e) {};
try { Vector4.prototype.EqualExactly = Vector4.prototype.EqualExactly_Vector4Vector4; } catch (e) {};
try { Vector4.prototype.NotEqual = Vector4.prototype.NotEqual_Vector4Vector4; } catch (e) {};
try { Vector4.prototype.NotEqualExactly = Vector4.prototype.NotEqualExactly_Vector4Vector4; } catch (e) {};
try { Vector4.prototype.CrossProductXYZ = Vector4.prototype.Vector4_CrossProduct3; } catch (e) {};
try { Vector4.prototype.DotProduct = Vector4.prototype.Vector4_DotProduct; } catch (e) {};
try { Vector4.prototype.DotProductXYZ = Vector4.prototype.Vector4_DotProduct3; } catch (e) {};
try { Vector4.prototype.IsNormalXYZ = Vector4.prototype.Vector4_IsNormal3; } catch (e) {};
try { Vector4.prototype.IsUnitXYZ = Vector4.prototype.Vector4_IsUnit3; } catch (e) {};
try { Vector4.prototype.Negated = Vector4.prototype.Vector4_Negated; } catch (e) {};
try { Vector4.prototype.NormalizeXYZ = Vector4.prototype.Vector4_Normal3; } catch (e) {};
try { Vector4.prototype.NormalizeInPlaceXYZ = Vector4.prototype.Vector4_Normalize3; } catch (e) {};
try { Vector4.prototype.NormalunsafeXYZ = Vector4.prototype.Vector4_NormalUnsafe3; } catch (e) {};
try { Vector4.prototype.Length = Vector4.prototype.Vector4_Size; } catch (e) {};
try { Vector4.prototype.LengthXYZ = Vector4.prototype.Vector4_Size3; } catch (e) {};
try { Vector4.prototype.LengthSquared = Vector4.prototype.Vector4_SizeSquared; } catch (e) {};
try { Vector4.prototype.LengthXYZSquared = Vector4.prototype.Vector4_SizeSquared3; } catch (e) {};
try { Vector2D.prototype.ToText = Vector2D.prototype.Conv_Vector2dToText; } catch (e) {};
try { Vector2D.prototype.ToString = Vector2D.prototype.Conv_Vector2dToString; } catch (e) {};
try { Vector2D.prototype.ToIntPoint = Vector2D.prototype.Conv_Vector2DToIntPoint; } catch (e) {};
try { Vector2D.prototype.ToVector = Vector2D.prototype.Conv_Vector2DToVector; } catch (e) {};
try { Vector2D.prototype.CrossProduct = Vector2D.prototype.CrossProduct2D; } catch (e) {};
try { Vector2D.prototype.DotProduct = Vector2D.prototype.DotProduct2D; } catch (e) {};
try { Vector2D.prototype.Equal = Vector2D.prototype.EqualEqual_Vector2DVector2D; } catch (e) {};
try { Vector2D.prototype.EqualExactly = Vector2D.prototype.EqualExactly_Vector2DVector2D; } catch (e) {};
try { Vector2D.prototype.Normalize2D = Vector2D.prototype.Normal2D; } catch (e) {};
try { Vector2D.prototype.NormalizeInPlace = Vector2D.prototype.Normalize2D; } catch (e) {};
try { Vector2D.prototype.NormalSafe = Vector2D.prototype.NormalSafe2D; } catch (e) {};
try { Vector2D.prototype.NotEqual = Vector2D.prototype.NotEqual_Vector2DVector2D; } catch (e) {};
try { Vector2D.prototype.NotEqualExactly = Vector2D.prototype.NotEqualExactly_Vector2DVector2D; } catch (e) {};
try { Vector2D.prototype.ToDirectionAndLength = Vector2D.prototype.ToDirectionAndLength2D; } catch (e) {};
try { Vector2D.prototype.ToRounded = Vector2D.prototype.ToRounded2D; } catch (e) {};
try { Vector2D.prototype.Tosign = Vector2D.prototype.ToSign2D; } catch (e) {};
try { Vector2D.prototype.Vector2dLength = Vector2D.prototype.VSize2D; } catch (e) {};
try { Vector2D.prototype.Vector2dLengthSquared = Vector2D.prototype.VSize2DSquared; } catch (e) {};
try { Rotator.prototype.ToText = Rotator.prototype.Conv_RotatorToText; } catch (e) {};
try { Rotator.prototype.ToString = Rotator.prototype.Conv_RotatorToString; } catch (e) {};
try { Rotator.prototype.CombineRotators = Rotator.prototype.ComposeRotators; } catch (e) {};
try { Rotator.prototype.ToTransform = Rotator.prototype.Conv_RotatorToTransform; } catch (e) {};
try { Rotator.prototype.GetRotationXVector = Rotator.prototype.Conv_RotatorToVector; } catch (e) {};
try { Rotator.prototype.Equal = Rotator.prototype.EqualEqual_RotatorRotator; } catch (e) {};
try { Rotator.prototype.ScaleRotator = Rotator.prototype.Multiply_RotatorFloat; } catch (e) {};
try { Rotator.prototype.ScaleRotator = Rotator.prototype.Multiply_RotatorInt; } catch (e) {};
try { Rotator.prototype.InvertRotator = Rotator.prototype.NegateRotator; } catch (e) {};
try { Rotator.prototype.Delta = Rotator.prototype.NormalizedDeltaRotator; } catch (e) {};
try { Rotator.prototype.NotEqual = Rotator.prototype.NotEqual_RotatorRotator; } catch (e) {};
try { Rotator.prototype.Ease = Rotator.prototype.REase; } catch (e) {};
try { Rotator.prototype.Lerp = Rotator.prototype.RLerp; } catch (e) {};
try { Quat.prototype.Equal = Quat.prototype.EqualEqual_QuatQuat; } catch (e) {};
try { Quat.prototype.NotEqual = Quat.prototype.NotEqual_QuatQuat; } catch (e) {};
try { Quat.prototype.AngularDistance = Quat.prototype.Quat_AngularDistance; } catch (e) {};
try { Quat.prototype.Ensureshortestarcto = Quat.prototype.Quat_EnforceShortestArcWith; } catch (e) {};
try { Quat.prototype.Euler = Quat.prototype.Quat_Euler; } catch (e) {};
try { Quat.prototype.Exp = Quat.prototype.Quat_Exp; } catch (e) {};
try { Quat.prototype.Angle = Quat.prototype.Quat_GetAngle; } catch (e) {};
try { Quat.prototype.AxisX = Quat.prototype.Quat_GetAxisX; } catch (e) {};
try { Quat.prototype.AxisY = Quat.prototype.Quat_GetAxisY; } catch (e) {};
try { Quat.prototype.AxisZ = Quat.prototype.Quat_GetAxisZ; } catch (e) {};
try { Quat.prototype.RotationAxis = Quat.prototype.Quat_GetRotationAxis; } catch (e) {};
try { Quat.prototype.Inversed = Quat.prototype.Quat_Inversed; } catch (e) {};
try { Quat.prototype.IsFinite = Quat.prototype.Quat_IsFinite; } catch (e) {};
try { Quat.prototype.IsIdentity = Quat.prototype.Quat_IsIdentity; } catch (e) {};
try { Quat.prototype.IsNormalized = Quat.prototype.Quat_IsNormalized; } catch (e) {};
try { Quat.prototype.Log = Quat.prototype.Quat_Log; } catch (e) {};
try { Quat.prototype.Normalize = Quat.prototype.Quat_Normalize; } catch (e) {};
try { Quat.prototype.Normalized = Quat.prototype.Quat_Normalized; } catch (e) {};
try { Quat.prototype.RotateVector = Quat.prototype.Quat_RotateVector; } catch (e) {};
try { Quat.prototype.ToRotator = Quat.prototype.Quat_Rotator; } catch (e) {};
try { Quat.prototype.SetComponents = Quat.prototype.Quat_SetComponents; } catch (e) {};
try { Quat.prototype.SetfromEuler = Quat.prototype.Quat_SetFromEuler; } catch (e) {};
try { Quat.prototype.Size = Quat.prototype.Quat_Size; } catch (e) {};
try { Quat.prototype.SizeSquared = Quat.prototype.Quat_SizeSquared; } catch (e) {};
try { Quat.prototype.UnrotateVector = Quat.prototype.Quat_UnrotateVector; } catch (e) {};
try { Quat.prototype.VectorForward = Quat.prototype.Quat_VectorForward; } catch (e) {};
try { Quat.prototype.VectorRight = Quat.prototype.Quat_VectorRight; } catch (e) {};
try { Quat.prototype.VectorUp = Quat.prototype.Quat_VectorUp; } catch (e) {};
try { IntVector.prototype.ToString = IntVector.prototype.Conv_IntVectorToString; } catch (e) {};
try { IntVector.prototype.ToVector = IntVector.prototype.Conv_IntVectorToVector; } catch (e) {};
try { Color.prototype.ToLinearColor = Color.prototype.Conv_ColorToLinearColor; } catch (e) {};
try { LinearColor.prototype.ToText = LinearColor.prototype.Conv_ColorToText; } catch (e) {};
try { LinearColor.prototype.ToString = LinearColor.prototype.Conv_ColorToString; } catch (e) {};
try { LinearColor.prototype.Interpolate = LinearColor.prototype.CInterpTo; } catch (e) {};
try { LinearColor.prototype.ToColor = LinearColor.prototype.Conv_LinearColorToColor; } catch (e) {};
try { LinearColor.prototype.ToVector = LinearColor.prototype.Conv_LinearColorToVector; } catch (e) {};
try { LinearColor.prototype.Equal = LinearColor.prototype.EqualEqual_LinearColorLinearColor; } catch (e) {};
try { LinearColor.prototype.HSVtoRGB = LinearColor.prototype.HSVToRGB_Vector; } catch (e) {};
try { LinearColor.prototype.HSVtoRGBlinearcolor = LinearColor.prototype.HSVToRGBLinear; } catch (e) {};
try { LinearColor.prototype.Desaturate = LinearColor.prototype.LinearColor_Desaturated; } catch (e) {};
try { LinearColor.prototype.Distance = LinearColor.prototype.LinearColor_Distance; } catch (e) {};
try { LinearColor.prototype.Luminance = LinearColor.prototype.LinearColor_GetLuminance; } catch (e) {};
try { LinearColor.prototype.Max = LinearColor.prototype.LinearColor_GetMax; } catch (e) {};
try { LinearColor.prototype.Min = LinearColor.prototype.LinearColor_GetMin; } catch (e) {};
try { LinearColor.prototype.NearEqual = LinearColor.prototype.LinearColor_IsNearEqual; } catch (e) {};
try { LinearColor.prototype.NewOpacity = LinearColor.prototype.LinearColor_ToNewOpacity; } catch (e) {};
try { LinearColor.prototype.ToRGBE = LinearColor.prototype.LinearColor_ToRGBE; } catch (e) {};
try { LinearColor.prototype.Lerp = LinearColor.prototype.LinearColorLerp; } catch (e) {};
try { LinearColor.prototype.LerpUsingHSV = LinearColor.prototype.LinearColorLerpUsingHSV; } catch (e) {};
try { LinearColor.prototype.NotEqual = LinearColor.prototype.NotEqual_LinearColorLinearColor; } catch (e) {};
try { LinearColor.prototype.RGBtoHSVlinearcolor = LinearColor.prototype.RGBLinearToHSV; } catch (e) {};
try { LinearColor.prototype.RGBtoHSV = LinearColor.prototype.RGBToHSV_Vector; } catch (e) {};
try { Matrix.prototype.ToRotator = Matrix.prototype.Conv_MatrixToRotator; } catch (e) {};
try { Matrix.prototype.ToTransform = Matrix.prototype.Conv_MatrixToTransform; } catch (e) {};
try { Matrix.prototype.GetOrigin = Matrix.prototype.Matrix_GetOrigin; } catch (e) {};
try { Transform.prototype.ToText = Transform.prototype.Conv_TransformToText; } catch (e) {};
try { Transform.prototype.ToString = Transform.prototype.Conv_TransformToString; } catch (e) {};
try { Transform.prototype.EqualTransform = Transform.prototype.EqualEqual_TransformTransform; } catch (e) {};
try { Transform.prototype.NearlyEqual = Transform.prototype.NearlyEqual_TransformTransform; } catch (e) {};
try { Transform.prototype.Ease = Transform.prototype.TEase; } catch (e) {};
try { Transform.prototype.Lerp = Transform.prototype.TLerp; } catch (e) {};
try { Transform.prototype.Determinant = Transform.prototype.Transform_Determinant; } catch (e) {};
try { Transform.prototype.LookAtFunction = Transform.prototype.K2_LookAt; } catch (e) {};
try { Transform.prototype.SetARAlignmentTransform = Transform.prototype.SetAlignmentTransform; } catch (e) {};
try { DateTime.prototype.AsDate = DateTime.prototype.AsDate_DateTime; } catch (e) {};
try { DateTime.prototype.AsDateTime = DateTime.prototype.AsDateTime_DateTime; } catch (e) {};
try { DateTime.prototype.AsTime = DateTime.prototype.AsTime_DateTime; } catch (e) {};
try { DateTime.prototype.AsDate = DateTime.prototype.AsTimeZoneDate_DateTime; } catch (e) {};
try { DateTime.prototype.AsDateTime = DateTime.prototype.AsTimeZoneDateTime_DateTime; } catch (e) {};
try { DateTime.prototype.AsTime = DateTime.prototype.AsTimeZoneTime_DateTime; } catch (e) {};
try { DateTime.prototype.Equal = DateTime.prototype.EqualEqual_DateTimeDateTime; } catch (e) {};
try { DateTime.prototype.NotEqual = DateTime.prototype.NotEqual_DateTimeDateTime; } catch (e) {};
try { FrameNumber.prototype.FrameNumbertoInteger = FrameNumber.prototype.Conv_FrameNumberToInteger; } catch (e) {};
try { FrameRate.prototype.FrameRatetoSeconds = FrameRate.prototype.Conv_FrameRateToSeconds; } catch (e) {};
try { FrameRate.prototype.IsValid = FrameRate.prototype.IsValid_Framerate; } catch (e) {};
try { FrameRate.prototype.IsMultipleOf = FrameRate.prototype.IsValid_MultipleOf; } catch (e) {};
try { FrameTime.prototype.SnapFrameTime = FrameTime.prototype.SnapFrameTimeToRate; } catch (e) {};
try { FrameTime.prototype.TransformFrameTime = FrameTime.prototype.TransformTime; } catch (e) {};
try { QualifiedFrameTime.prototype.QualifiedFrameTimetoSeconds = QualifiedFrameTime.prototype.Conv_QualifiedFrameTimeToSeconds; } catch (e) {};
try { Timecode.prototype.TimecodetoString = Timecode.prototype.Conv_TimecodeToString; } catch (e) {};
try { Timespan.prototype.AsTimespan = Timespan.prototype.AsTimespan_Timespan; } catch (e) {};
try { Timespan.prototype.Equal = Timespan.prototype.EqualEqual_TimespanTimespan; } catch (e) {};
try { Timespan.prototype.NotEqual = Timespan.prototype.NotEqual_TimespanTimespan; } catch (e) {};
try { SoftObjectPath.prototype.ToSoftObjectReference = SoftObjectPath.prototype.Conv_SoftObjPathToSoftObjRef; } catch (e) {};
try { PrimaryAssetType.prototype.ToString = PrimaryAssetType.prototype.Conv_PrimaryAssetTypeToString; } catch (e) {};
try { PrimaryAssetType.prototype.Equal = PrimaryAssetType.prototype.EqualEqual_PrimaryAssetType; } catch (e) {};
try { PrimaryAssetType.prototype.NotEqual = PrimaryAssetType.prototype.NotEqual_PrimaryAssetType; } catch (e) {};
try { PrimaryAssetId.prototype.ToString = PrimaryAssetId.prototype.Conv_PrimaryAssetIdToString; } catch (e) {};
try { PrimaryAssetId.prototype.Equal = PrimaryAssetId.prototype.EqualEqual_PrimaryAssetId; } catch (e) {};
try { PrimaryAssetId.prototype.NotEqual = PrimaryAssetId.prototype.NotEqual_PrimaryAssetId; } catch (e) {};
try { Key.prototype.Equal = Key.prototype.EqualEqual_KeyKey; } catch (e) {};
try { Key.prototype.GetKeyDisplayName = Key.prototype.Key_GetDisplayName; } catch (e) {};
try { Key.prototype.IsFloatAxis = Key.prototype.Key_IsFloatAxis; } catch (e) {};
try { Key.prototype.IsGamepadKey = Key.prototype.Key_IsGamepadKey; } catch (e) {};
try { Key.prototype.IsKeyboardKey = Key.prototype.Key_IsKeyboardKey; } catch (e) {};
try { Key.prototype.IsModifierKey = Key.prototype.Key_IsModifierKey; } catch (e) {};
try { Key.prototype.IsMouseButton = Key.prototype.Key_IsMouseButton; } catch (e) {};
try { Key.prototype.IsValid = Key.prototype.Key_IsValid; } catch (e) {};
try { Key.prototype.IsVectorAxis = Key.prototype.Key_IsVectorAxis; } catch (e) {};
try { TimerHandle.prototype.Invalidate = TimerHandle.prototype.K2_InvalidateTimerHandle; } catch (e) {};
try { TimerHandle.prototype.IsValid = TimerHandle.prototype.K2_IsValidTimerHandle; } catch (e) {};
try { SlateBrush.prototype.Equal = SlateBrush.prototype.EqualEqual_SlateBrush; } catch (e) {};
try { InputEvent.prototype.IsAltDown = InputEvent.prototype.InputEvent_IsAltDown; } catch (e) {};
try { InputEvent.prototype.IsCommandDown = InputEvent.prototype.InputEvent_IsCommandDown; } catch (e) {};
try { InputEvent.prototype.IsControlDown = InputEvent.prototype.InputEvent_IsControlDown; } catch (e) {};
try { InputEvent.prototype.IsLeftAltDown = InputEvent.prototype.InputEvent_IsLeftAltDown; } catch (e) {};
try { InputEvent.prototype.IsLeftCommandDown = InputEvent.prototype.InputEvent_IsLeftCommandDown; } catch (e) {};
try { InputEvent.prototype.IsLeftControlDown = InputEvent.prototype.InputEvent_IsLeftControlDown; } catch (e) {};
try { InputEvent.prototype.IsLeftShiftDown = InputEvent.prototype.InputEvent_IsLeftShiftDown; } catch (e) {};
try { InputEvent.prototype.IsRepeat = InputEvent.prototype.InputEvent_IsRepeat; } catch (e) {};
try { InputEvent.prototype.IsRightAltDown = InputEvent.prototype.InputEvent_IsRightAltDown; } catch (e) {};
try { InputEvent.prototype.IsRightCommandDown = InputEvent.prototype.InputEvent_IsRightCommandDown; } catch (e) {};
try { InputEvent.prototype.IsRightControlDown = InputEvent.prototype.InputEvent_IsRightControlDown; } catch (e) {};
try { InputEvent.prototype.IsRightShiftDown = InputEvent.prototype.InputEvent_IsRightShiftDown; } catch (e) {};
try { InputEvent.prototype.IsShiftDown = InputEvent.prototype.InputEvent_IsShiftDown; } catch (e) {};
try { UPointerEvent.prototype.GetCursorDelta = UPointerEvent.prototype.PointerEvent_GetCursorDelta; } catch (e) {};
try { UPointerEvent.prototype.GetEffectingButton = UPointerEvent.prototype.PointerEvent_GetEffectingButton; } catch (e) {};
try { UPointerEvent.prototype.GetGestureDelta = UPointerEvent.prototype.PointerEvent_GetGestureDelta; } catch (e) {};
try { UPointerEvent.prototype.GetLastScreenSpacePosition = UPointerEvent.prototype.PointerEvent_GetLastScreenSpacePosition; } catch (e) {};
try { UPointerEvent.prototype.GetPointerIndex = UPointerEvent.prototype.PointerEvent_GetPointerIndex; } catch (e) {};
try { UPointerEvent.prototype.GetScreenSpacePosition = UPointerEvent.prototype.PointerEvent_GetScreenSpacePosition; } catch (e) {};
try { UPointerEvent.prototype.GetTouchpadIndex = UPointerEvent.prototype.PointerEvent_GetTouchpadIndex; } catch (e) {};
try { UPointerEvent.prototype.GetUserIndex = UPointerEvent.prototype.PointerEvent_GetUserIndex; } catch (e) {};
try { UPointerEvent.prototype.GetWheelDelta = UPointerEvent.prototype.PointerEvent_GetWheelDelta; } catch (e) {};
try { UPointerEvent.prototype.IsMouseButtonDown = UPointerEvent.prototype.PointerEvent_IsMouseButtonDown; } catch (e) {};
try { UPointerEvent.prototype.IsTouchEvent = UPointerEvent.prototype.PointerEvent_IsTouchEvent; } catch (e) {};
try { PaintContext.prototype.DrawString = PaintContext.prototype.DrawText; } catch (e) {};
try { PaintContext.prototype.DrawText = PaintContext.prototype.DrawTextFormatted; } catch (e) {};
try { InputChord.prototype.Equal = InputChord.prototype.EqualEqual_InputChordInputChord; } catch (e) {};
try { GameplayTag.prototype.Equal = GameplayTag.prototype.EqualEqual_GameplayTag; } catch (e) {};
try { GameplayTag.prototype.NotEqual = GameplayTag.prototype.NotEqual_GameplayTag; } catch (e) {};
try { GameplayTagContainer.prototype.Equal = GameplayTagContainer.prototype.EqualEqual_GameplayTagContainer; } catch (e) {};
try { GameplayTagContainer.prototype.NotEqual = GameplayTagContainer.prototype.NotEqual_GameplayTagContainer; } catch (e) {};
try { DropTimecode.prototype.ToString = DropTimecode.prototype.Conv_DropTimecodeToString; } catch (e) {};