//PUBGM(0.13.5)32位SDK
//作者:清华
//Telegram:@qinghuanb666
//生成时间:Fri Apr 18 20:44:42 2025

#include "../SDK.hpp"

namespace SDK
{
//---------------------------------------------------------------------------
//Functions
//---------------------------------------------------------------------------

// Function bp_lobby.bp_lobby_C.EventClickQQAround_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickQQAround_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickQQAround_NoFetch");

	Abp_lobby_C_EventClickQQAround_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickQQAround
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickQQAround()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickQQAround");

	Abp_lobby_C_EventClickQQAround_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveFriend_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveFriend_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveFriend_NoFetch");

	Abp_lobby_C_EventLobbyLeaveFriend_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveFriend
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveFriend()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveFriend");

	Abp_lobby_C_EventLobbyLeaveFriend_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenActivityGroupUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenActivityGroupUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenActivityGroupUI_NoFetch");

	Abp_lobby_C_EventOpenActivityGroupUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenActivityGroupUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenActivityGroupUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenActivityGroupUI");

	Abp_lobby_C_EventOpenActivityGroupUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterTeamUp_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterTeamUp_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterTeamUp_NoFetch");

	Abp_lobby_C_EventEnterTeamUp_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterTeamUp
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterTeamUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterTeamUp");

	Abp_lobby_C_EventEnterTeamUp_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestScrollMsg_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestScrollMsg_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestScrollMsg_NoFetch");

	Abp_lobby_C_EventTestScrollMsg_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestScrollMsg
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestScrollMsg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestScrollMsg");

	Abp_lobby_C_EventTestScrollMsg_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionShow_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionShow_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionShow_NoFetch");

	Abp_lobby_C_EventLobbyExpressionShow_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionShow
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionShow()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionShow");

	Abp_lobby_C_EventLobbyExpressionShow_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyEnterAlliance_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyEnterAlliance_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyEnterAlliance_NoFetch");

	Abp_lobby_C_EventLobbyEnterAlliance_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyEnterAlliance
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyEnterAlliance()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyEnterAlliance");

	Abp_lobby_C_EventLobbyEnterAlliance_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestUnEquipWeapon_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestUnEquipWeapon_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestUnEquipWeapon_NoFetch");

	Abp_lobby_C_EventLobbyTestUnEquipWeapon_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestUnEquipWeapon
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestUnEquipWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestUnEquipWeapon");

	Abp_lobby_C_EventLobbyTestUnEquipWeapon_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterWarzone_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterWarzone_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterWarzone_NoFetch");

	Abp_lobby_C_EventEnterWarzone_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterWarzone
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterWarzone()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterWarzone");

	Abp_lobby_C_EventEnterWarzone_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenChatUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenChatUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenChatUI_NoFetch");

	Abp_lobby_C_EventOpenChatUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenChatUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenChatUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenChatUI");

	Abp_lobby_C_EventOpenChatUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterConfig_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterConfig_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterConfig_NoFetch");

	Abp_lobby_C_EventEnterConfig_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterConfig
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterConfig()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterConfig");

	Abp_lobby_C_EventEnterConfig_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventCanOpenUrl_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventCanOpenUrl_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventCanOpenUrl_NoFetch");

	Abp_lobby_C_EventCanOpenUrl_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventCanOpenUrl
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventCanOpenUrl()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventCanOpenUrl");

	Abp_lobby_C_EventCanOpenUrl_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRoom_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRoom_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRoom_NoFetch");

	Abp_lobby_C_EventEnterRoom_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRoom
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRoom()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRoom");

	Abp_lobby_C_EventEnterRoom_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLeaveWardrobe_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLeaveWardrobe_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLeaveWardrobe_NoFetch");

	Abp_lobby_C_EventLeaveWardrobe_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLeaveWardrobe
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLeaveWardrobe()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLeaveWardrobe");

	Abp_lobby_C_EventLeaveWardrobe_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveRankList_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveRankList_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveRankList_NoFetch");

	Abp_lobby_C_EventLobbyLeaveRankList_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveRankList
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveRankList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveRankList");

	Abp_lobby_C_EventLobbyLeaveRankList_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveTask_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveTask_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveTask_NoFetch");

	Abp_lobby_C_EventLobbyLeaveTask_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveTask
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveTask");

	Abp_lobby_C_EventLobbyLeaveTask_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionHide_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionHide_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionHide_NoFetch");

	Abp_lobby_C_EventLobbyExpressionHide_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionHide
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionHide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionHide");

	Abp_lobby_C_EventLobbyExpressionHide_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMarket_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMarket_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMarket_NoFetch");

	Abp_lobby_C_EventEnterMarket_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMarket
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMarket()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMarket");

	Abp_lobby_C_EventEnterMarket_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeason_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeason_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeason_NoFetch");

	Abp_lobby_C_EventLobbyLeaveSeason_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeason
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeason()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeason");

	Abp_lobby_C_EventLobbyLeaveSeason_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickDailyShareBtn_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickDailyShareBtn_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickDailyShareBtn_NoFetch");

	Abp_lobby_C_EventClickDailyShareBtn_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickDailyShareBtn
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickDailyShareBtn()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickDailyShareBtn");

	Abp_lobby_C_EventClickDailyShareBtn_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventInitActivityListComplete_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventInitActivityListComplete_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventInitActivityListComplete_NoFetch");

	Abp_lobby_C_EventInitActivityListComplete_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventInitActivityListComplete
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventInitActivityListComplete()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventInitActivityListComplete");

	Abp_lobby_C_EventInitActivityListComplete_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveUpdateNoticeInGame_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveUpdateNoticeInGame_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveUpdateNoticeInGame_NoFetch");

	Abp_lobby_C_EventLobbyLeaveUpdateNoticeInGame_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveUpdateNoticeInGame
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveUpdateNoticeInGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveUpdateNoticeInGame");

	Abp_lobby_C_EventLobbyLeaveUpdateNoticeInGame_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetFriendProfile_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetFriendProfile_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetFriendProfile_NoFetch");

	Abp_lobby_C_EventGetFriendProfile_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetFriendProfile
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetFriendProfile()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetFriendProfile");

	Abp_lobby_C_EventGetFriendProfile_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenPassUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenPassUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenPassUI_NoFetch");

	Abp_lobby_C_EventOpenPassUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenPassUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenPassUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenPassUI");

	Abp_lobby_C_EventOpenPassUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSetting_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSetting_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSetting_NoFetch");

	Abp_lobby_C_EventLobbyLeaveSetting_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSetting
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSetting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSetting");

	Abp_lobby_C_EventLobbyLeaveSetting_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSetInfo_Push_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSetInfo_Push_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSetInfo_Push_NoFetch");

	Abp_lobby_C_EventSetInfo_Push_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSetInfo_Push
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSetInfo_Push()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSetInfo_Push");

	Abp_lobby_C_EventSetInfo_Push_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventHideScrollMsg_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventHideScrollMsg_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventHideScrollMsg_NoFetch");

	Abp_lobby_C_EventHideScrollMsg_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventHideScrollMsg
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventHideScrollMsg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventHideScrollMsg");

	Abp_lobby_C_EventHideScrollMsg_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer3_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer3_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer3_NoFetch");

	Abp_lobby_C_EventTestSpawnPlayer3_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer3
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer3()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer3");

	Abp_lobby_C_EventTestSpawnPlayer3_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveItemGet_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveItemGet_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveItemGet_NoFetch");

	Abp_lobby_C_EventLobbyLeaveItemGet_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveItemGet
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveItemGet()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveItemGet");

	Abp_lobby_C_EventLobbyLeaveItemGet_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer_NoFetch");

	Abp_lobby_C_EventTestSpawnPlayer_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer");

	Abp_lobby_C_EventTestSpawnPlayer_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer_NoFetch");

	Abp_lobby_C_EventTestRemovePlayer_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer");

	Abp_lobby_C_EventTestRemovePlayer_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer3_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer3_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer3_NoFetch");

	Abp_lobby_C_EventTestRemovePlayer3_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer3
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer3()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer3");

	Abp_lobby_C_EventTestRemovePlayer3_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestShowEmote_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestShowEmote_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestShowEmote_NoFetch");

	Abp_lobby_C_EventLobbyTestShowEmote_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestShowEmote
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestShowEmote()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestShowEmote");

	Abp_lobby_C_EventLobbyTestShowEmote_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRedpoint_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRedpoint_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRedpoint_NoFetch");

	Abp_lobby_C_EventTestRedpoint_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRedpoint
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRedpoint()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRedpoint");

	Abp_lobby_C_EventTestRedpoint_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyOpenArmory_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyOpenArmory_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyOpenArmory_NoFetch");

	Abp_lobby_C_EventLobbyOpenArmory_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyOpenArmory
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyOpenArmory()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyOpenArmory");

	Abp_lobby_C_EventLobbyOpenArmory_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMailGift_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMailGift_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMailGift_NoFetch");

	Abp_lobby_C_EventEnterMailGift_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMailGift
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMailGift()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMailGift");

	Abp_lobby_C_EventEnterMailGift_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickWXAround_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickWXAround_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickWXAround_NoFetch");

	Abp_lobby_C_EventClickWXAround_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickWXAround
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickWXAround()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickWXAround");

	Abp_lobby_C_EventClickWXAround_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOnClickYearActivity_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOnClickYearActivity_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOnClickYearActivity_NoFetch");

	Abp_lobby_C_EventOnClickYearActivity_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOnClickYearActivity
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOnClickYearActivity()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOnClickYearActivity");

	Abp_lobby_C_EventOnClickYearActivity_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenShopLimitUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenShopLimitUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenShopLimitUI_NoFetch");

	Abp_lobby_C_EventOpenShopLimitUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenShopLimitUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenShopLimitUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenShopLimitUI");

	Abp_lobby_C_EventOpenShopLimitUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGMMenu_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGMMenu_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGMMenu_NoFetch");

	Abp_lobby_C_EventOpenGMMenu_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGMMenu
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGMMenu()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGMMenu");

	Abp_lobby_C_EventOpenGMMenu_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLeaveWeekSignUp_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLeaveWeekSignUp_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLeaveWeekSignUp_NoFetch");

	Abp_lobby_C_EventLeaveWeekSignUp_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLeaveWeekSignUp
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLeaveWeekSignUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLeaveWeekSignUp");

	Abp_lobby_C_EventLeaveWeekSignUp_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonChallengeTask_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeasonChallengeTask_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonChallengeTask_NoFetch");

	Abp_lobby_C_EventLobbyLeaveSeasonChallengeTask_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonChallengeTask
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeasonChallengeTask()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonChallengeTask");

	Abp_lobby_C_EventLobbyLeaveSeasonChallengeTask_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveWarzoneRank_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveWarzoneRank_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveWarzoneRank_NoFetch");

	Abp_lobby_C_EventLobbyLeaveWarzoneRank_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveWarzoneRank
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveWarzoneRank()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveWarzoneRank");

	Abp_lobby_C_EventLobbyLeaveWarzoneRank_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer2_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer2_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer2_NoFetch");

	Abp_lobby_C_EventTestSpawnPlayer2_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer2
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestSpawnPlayer2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestSpawnPlayer2");

	Abp_lobby_C_EventTestSpawnPlayer2_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMail_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMail_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMail_NoFetch");

	Abp_lobby_C_EventEnterMail_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterMail
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterMail()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterMail");

	Abp_lobby_C_EventEnterMail_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenWorldView_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenWorldView_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenWorldView_NoFetch");

	Abp_lobby_C_EventOpenWorldView_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenWorldView
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenWorldView()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenWorldView");

	Abp_lobby_C_EventOpenWorldView_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterFriendList_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterFriendList_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterFriendList_NoFetch");

	Abp_lobby_C_EventEnterFriendList_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterFriendList
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterFriendList()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterFriendList");

	Abp_lobby_C_EventEnterFriendList_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventInvitePlatformFriend_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventInvitePlatformFriend_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventInvitePlatformFriend_NoFetch");

	Abp_lobby_C_EventInvitePlatformFriend_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventInvitePlatformFriend
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventInvitePlatformFriend()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventInvitePlatformFriend");

	Abp_lobby_C_EventInvitePlatformFriend_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRank_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRank_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRank_NoFetch");

	Abp_lobby_C_EventEnterRank_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRank
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRank()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRank");

	Abp_lobby_C_EventEnterRank_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyHideShop_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyHideShop_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyHideShop_NoFetch");

	Abp_lobby_C_EventLobbyHideShop_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyHideShop
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyHideShop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyHideShop");

	Abp_lobby_C_EventLobbyHideShop_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOnClickCorps_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOnClickCorps_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOnClickCorps_NoFetch");

	Abp_lobby_C_EventOnClickCorps_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOnClickCorps
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOnClickCorps()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOnClickCorps");

	Abp_lobby_C_EventOnClickCorps_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventAvatarChange_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventAvatarChange_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventAvatarChange_NoFetch");

	Abp_lobby_C_EventAvatarChange_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventAvatarChange
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventAvatarChange()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventAvatarChange");

	Abp_lobby_C_EventAvatarChange_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenWatchingPanel_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenWatchingPanel_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenWatchingPanel_NoFetch");

	Abp_lobby_C_EventOpenWatchingPanel_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenWatchingPanel
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenWatchingPanel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenWatchingPanel");

	Abp_lobby_C_EventOpenWatchingPanel_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterShop_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterShop_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterShop_NoFetch");

	Abp_lobby_C_EventEnterShop_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterShop
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterShop()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterShop");

	Abp_lobby_C_EventEnterShop_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetCollectEquipOpenState_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetCollectEquipOpenState_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetCollectEquipOpenState_NoFetch");

	Abp_lobby_C_EventGetCollectEquipOpenState_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetCollectEquipOpenState
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetCollectEquipOpenState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetCollectEquipOpenState");

	Abp_lobby_C_EventGetCollectEquipOpenState_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGetExcitingPartyUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGetExcitingPartyUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGetExcitingPartyUI_NoFetch");

	Abp_lobby_C_EventOpenGetExcitingPartyUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGetExcitingPartyUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGetExcitingPartyUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGetExcitingPartyUI");

	Abp_lobby_C_EventOpenGetExcitingPartyUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenMissionUI_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenMissionUI_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenMissionUI_NoFetch");

	Abp_lobby_C_EventOpenMissionUI_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenMissionUI
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenMissionUI()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenMissionUI");

	Abp_lobby_C_EventOpenMissionUI_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickDesertCircleRun_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickDesertCircleRun_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickDesertCircleRun_NoFetch");

	Abp_lobby_C_EventClickDesertCircleRun_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickDesertCircleRun
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickDesertCircleRun()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickDesertCircleRun");

	Abp_lobby_C_EventClickDesertCircleRun_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetExcitingPartyOpenState_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetExcitingPartyOpenState_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetExcitingPartyOpenState_NoFetch");

	Abp_lobby_C_EventGetExcitingPartyOpenState_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetExcitingPartyOpenState
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetExcitingPartyOpenState()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetExcitingPartyOpenState");

	Abp_lobby_C_EventGetExcitingPartyOpenState_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenXinyue_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenXinyue_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenXinyue_NoFetch");

	Abp_lobby_C_EventOpenXinyue_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenXinyue
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenXinyue()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenXinyue");

	Abp_lobby_C_EventOpenXinyue_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenESportTV_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenESportTV_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenESportTV_NoFetch");

	Abp_lobby_C_EventOpenESportTV_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenESportTV
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenESportTV()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenESportTV");

	Abp_lobby_C_EventOpenESportTV_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenContestUrl_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenContestUrl_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenContestUrl_NoFetch");

	Abp_lobby_C_EventOpenContestUrl_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenContestUrl
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenContestUrl()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenContestUrl");

	Abp_lobby_C_EventOpenContestUrl_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenUpdateNoticeInGame_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenUpdateNoticeInGame_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenUpdateNoticeInGame_NoFetch");

	Abp_lobby_C_EventOpenUpdateNoticeInGame_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenUpdateNoticeInGame
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenUpdateNoticeInGame()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenUpdateNoticeInGame");

	Abp_lobby_C_EventOpenUpdateNoticeInGame_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGuardPopupPanel_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGuardPopupPanel_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGuardPopupPanel_NoFetch");

	Abp_lobby_C_EventOpenGuardPopupPanel_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGuardPopupPanel
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGuardPopupPanel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGuardPopupPanel");

	Abp_lobby_C_EventOpenGuardPopupPanel_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClearPlatformTagGuide_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClearPlatformTagGuide_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClearPlatformTagGuide_NoFetch");

	Abp_lobby_C_EventClearPlatformTagGuide_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClearPlatformTagGuide
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClearPlatformTagGuide()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClearPlatformTagGuide");

	Abp_lobby_C_EventClearPlatformTagGuide_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenFreeDataUrl_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenFreeDataUrl_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenFreeDataUrl_NoFetch");

	Abp_lobby_C_EventOpenFreeDataUrl_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenFreeDataUrl
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenFreeDataUrl()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenFreeDataUrl");

	Abp_lobby_C_EventOpenFreeDataUrl_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterFirstRecharge_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterFirstRecharge_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterFirstRecharge_NoFetch");

	Abp_lobby_C_EventEnterFirstRecharge_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterFirstRecharge
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterFirstRecharge()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterFirstRecharge");

	Abp_lobby_C_EventEnterFirstRecharge_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveWorldView_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveWorldView_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveWorldView_NoFetch");

	Abp_lobby_C_EventLobbyLeaveWorldView_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveWorldView
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveWorldView()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveWorldView");

	Abp_lobby_C_EventLobbyLeaveWorldView_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickRoom_Push_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickRoom_Push_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickRoom_Push_NoFetch");

	Abp_lobby_C_EventClickRoom_Push_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickRoom_Push
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickRoom_Push()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickRoom_Push");

	Abp_lobby_C_EventClickRoom_Push_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickTraining_Push_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickTraining_Push_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickTraining_Push_NoFetch");

	Abp_lobby_C_EventClickTraining_Push_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickTraining_Push
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickTraining_Push()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickTraining_Push");

	Abp_lobby_C_EventClickTraining_Push_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickTeach_Push_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickTeach_Push_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickTeach_Push_NoFetch");

	Abp_lobby_C_EventClickTeach_Push_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventClickTeach_Push
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventClickTeach_Push()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventClickTeach_Push");

	Abp_lobby_C_EventClickTeach_Push_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenQQVip_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenQQVip_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenQQVip_NoFetch");

	Abp_lobby_C_EventOpenQQVip_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenQQVip
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenQQVip()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenQQVip");

	Abp_lobby_C_EventOpenQQVip_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenCommunityInLobby_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenCommunityInLobby_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenCommunityInLobby_NoFetch");

	Abp_lobby_C_EventOpenCommunityInLobby_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenCommunityInLobby
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenCommunityInLobby()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenCommunityInLobby");

	Abp_lobby_C_EventOpenCommunityInLobby_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveCorps_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveCorps_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveCorps_NoFetch");

	Abp_lobby_C_EventLobbyLeaveCorps_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveCorps
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveCorps()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveCorps");

	Abp_lobby_C_EventLobbyLeaveCorps_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenHuati_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenHuati_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenHuati_NoFetch");

	Abp_lobby_C_EventOpenHuati_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenHuati
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenHuati()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenHuati");

	Abp_lobby_C_EventOpenHuati_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSwitchLobbyCameraByIndex_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSwitchLobbyCameraByIndex_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSwitchLobbyCameraByIndex_NoFetch");

	Abp_lobby_C_EventSwitchLobbyCameraByIndex_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSwitchLobbyCameraByIndex
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSwitchLobbyCameraByIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSwitchLobbyCameraByIndex");

	Abp_lobby_C_EventSwitchLobbyCameraByIndex_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyShowDoubleCard_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyShowDoubleCard_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyShowDoubleCard_NoFetch");

	Abp_lobby_C_EventLobbyShowDoubleCard_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyShowDoubleCard
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyShowDoubleCard()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyShowDoubleCard");

	Abp_lobby_C_EventLobbyShowDoubleCard_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRoleInfo_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRoleInfo_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRoleInfo_NoFetch");

	Abp_lobby_C_EventEnterRoleInfo_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterRoleInfo
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterRoleInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterRoleInfo");

	Abp_lobby_C_EventEnterRoleInfo_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterWardrobe_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterWardrobe_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterWardrobe_NoFetch");

	Abp_lobby_C_EventEnterWardrobe_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterWardrobe
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterWardrobe()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterWardrobe");

	Abp_lobby_C_EventEnterWardrobe_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenQQlibao_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenQQlibao_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenQQlibao_NoFetch");

	Abp_lobby_C_EventOpenQQlibao_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenQQlibao
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenQQlibao()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenQQlibao");

	Abp_lobby_C_EventOpenQQlibao_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestLevelUp_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestLevelUp_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestLevelUp_NoFetch");

	Abp_lobby_C_EventTestLevelUp_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestLevelUp
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestLevelUp()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestLevelUp");

	Abp_lobby_C_EventTestLevelUp_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenCollectEquipment_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenCollectEquipment_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenCollectEquipment_NoFetch");

	Abp_lobby_C_EventOpenCollectEquipment_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenCollectEquipment
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenCollectEquipment()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenCollectEquipment");

	Abp_lobby_C_EventOpenCollectEquipment_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventclickDecompose_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventclickDecompose_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventclickDecompose_NoFetch");

	Abp_lobby_C_EventclickDecompose_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventclickDecompose
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventclickDecompose()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventclickDecompose");

	Abp_lobby_C_EventclickDecompose_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyUpdateDoubleCardButton_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyUpdateDoubleCardButton_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyUpdateDoubleCardButton_NoFetch");

	Abp_lobby_C_EventLobbyUpdateDoubleCardButton_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyUpdateDoubleCardButton
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyUpdateDoubleCardButton()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyUpdateDoubleCardButton");

	Abp_lobby_C_EventLobbyUpdateDoubleCardButton_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterCorpsTotalRank_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterCorpsTotalRank_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterCorpsTotalRank_NoFetch");

	Abp_lobby_C_EventEnterCorpsTotalRank_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterCorpsTotalRank
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterCorpsTotalRank()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterCorpsTotalRank");

	Abp_lobby_C_EventEnterCorpsTotalRank_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyEnterSecurityFeedback_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyEnterSecurityFeedback_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyEnterSecurityFeedback_NoFetch");

	Abp_lobby_C_EventLobbyEnterSecurityFeedback_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyEnterSecurityFeedback
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyEnterSecurityFeedback()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyEnterSecurityFeedback");

	Abp_lobby_C_EventLobbyEnterSecurityFeedback_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenActivityPanel_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenActivityPanel_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenActivityPanel_NoFetch");

	Abp_lobby_C_EventOpenActivityPanel_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenActivityPanel
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenActivityPanel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenActivityPanel");

	Abp_lobby_C_EventOpenActivityPanel_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterLobbyNewRank_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterLobbyNewRank_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterLobbyNewRank_NoFetch");

	Abp_lobby_C_EventEnterLobbyNewRank_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterLobbyNewRank
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterLobbyNewRank()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterLobbyNewRank");

	Abp_lobby_C_EventEnterLobbyNewRank_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterSeason_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterSeason_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterSeason_NoFetch");

	Abp_lobby_C_EventEnterSeason_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterSeason
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterSeason()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterSeason");

	Abp_lobby_C_EventEnterSeason_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTeamUpRings_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTeamUpRings_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTeamUpRings_NoFetch");

	Abp_lobby_C_EventTeamUpRings_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTeamUpRings
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTeamUpRings()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTeamUpRings");

	Abp_lobby_C_EventTeamUpRings_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbySecondEntranceRedPointClick_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbySecondEntranceRedPointClick_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbySecondEntranceRedPointClick_NoFetch");

	Abp_lobby_C_EventLobbySecondEntranceRedPointClick_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbySecondEntranceRedPointClick
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbySecondEntranceRedPointClick()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbySecondEntranceRedPointClick");

	Abp_lobby_C_EventLobbySecondEntranceRedPointClick_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventFetchInfo_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventFetchInfo_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventFetchInfo_NoFetch");

	Abp_lobby_C_EventFetchInfo_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventFetchInfo
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventFetchInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventFetchInfo");

	Abp_lobby_C_EventFetchInfo_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterSigninSystem_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterSigninSystem_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterSigninSystem_NoFetch");

	Abp_lobby_C_EventEnterSigninSystem_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventEnterSigninSystem
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventEnterSigninSystem()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventEnterSigninSystem");

	Abp_lobby_C_EventEnterSigninSystem_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveRoleInfo_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveRoleInfo_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveRoleInfo_NoFetch");

	Abp_lobby_C_EventLobbyLeaveRoleInfo_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveRoleInfo
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveRoleInfo()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveRoleInfo");

	Abp_lobby_C_EventLobbyLeaveRoleInfo_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionLeave_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionLeave_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionLeave_NoFetch");

	Abp_lobby_C_EventLobbyExpressionLeave_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyExpressionLeave
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyExpressionLeave()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyExpressionLeave");

	Abp_lobby_C_EventLobbyExpressionLeave_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSwitchSystemCameraByIndex_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSwitchSystemCameraByIndex_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSwitchSystemCameraByIndex_NoFetch");

	Abp_lobby_C_EventSwitchSystemCameraByIndex_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventSwitchSystemCameraByIndex
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventSwitchSystemCameraByIndex()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventSwitchSystemCameraByIndex");

	Abp_lobby_C_EventSwitchSystemCameraByIndex_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGuidePanel_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGuidePanel_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGuidePanel_NoFetch");

	Abp_lobby_C_EventOpenGuidePanel_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenGuidePanel
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenGuidePanel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenGuidePanel");

	Abp_lobby_C_EventOpenGuidePanel_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyUIActivtiyYearMonster_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyUIActivtiyYearMonster_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyUIActivtiyYearMonster_NoFetch");

	Abp_lobby_C_EventLobbyUIActivtiyYearMonster_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyUIActivtiyYearMonster
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyUIActivtiyYearMonster()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyUIActivtiyYearMonster");

	Abp_lobby_C_EventLobbyUIActivtiyYearMonster_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventRerollAllScrollMsg_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventRerollAllScrollMsg_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventRerollAllScrollMsg_NoFetch");

	Abp_lobby_C_EventRerollAllScrollMsg_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventRerollAllScrollMsg
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventRerollAllScrollMsg()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventRerollAllScrollMsg");

	Abp_lobby_C_EventRerollAllScrollMsg_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonPass_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeasonPass_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonPass_NoFetch");

	Abp_lobby_C_EventLobbyLeaveSeasonPass_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonPass
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveSeasonPass()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveSeasonPass");

	Abp_lobby_C_EventLobbyLeaveSeasonPass_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveMail_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveMail_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveMail_NoFetch");

	Abp_lobby_C_EventLobbyLeaveMail_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveMail
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveMail()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveMail");

	Abp_lobby_C_EventLobbyLeaveMail_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer2_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer2_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer2_NoFetch");

	Abp_lobby_C_EventTestRemovePlayer2_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventTestRemovePlayer2
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventTestRemovePlayer2()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventTestRemovePlayer2");

	Abp_lobby_C_EventTestRemovePlayer2_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetShopLimitTitle_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetShopLimitTitle_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetShopLimitTitle_NoFetch");

	Abp_lobby_C_EventGetShopLimitTitle_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventGetShopLimitTitle
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventGetShopLimitTitle()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventGetShopLimitTitle");

	Abp_lobby_C_EventGetShopLimitTitle_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveChatWnd_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveChatWnd_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveChatWnd_NoFetch");

	Abp_lobby_C_EventLobbyLeaveChatWnd_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveChatWnd
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveChatWnd()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveChatWnd");

	Abp_lobby_C_EventLobbyLeaveChatWnd_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenTP_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenTP_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenTP_NoFetch");

	Abp_lobby_C_EventOpenTP_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventOpenTP
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventOpenTP()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventOpenTP");

	Abp_lobby_C_EventOpenTP_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventReportOpenedMomentSetting_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventReportOpenedMomentSetting_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventReportOpenedMomentSetting_NoFetch");

	Abp_lobby_C_EventReportOpenedMomentSetting_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventReportOpenedMomentSetting
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventReportOpenedMomentSetting()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventReportOpenedMomentSetting");

	Abp_lobby_C_EventReportOpenedMomentSetting_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveGuidePanel_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveGuidePanel_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveGuidePanel_NoFetch");

	Abp_lobby_C_EventLobbyLeaveGuidePanel_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyLeaveGuidePanel
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyLeaveGuidePanel()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyLeaveGuidePanel");

	Abp_lobby_C_EventLobbyLeaveGuidePanel_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestEquipWeapon_NoFetch
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestEquipWeapon_NoFetch()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestEquipWeapon_NoFetch");

	Abp_lobby_C_EventLobbyTestEquipWeapon_NoFetch_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.EventLobbyTestEquipWeapon
// (BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::EventLobbyTestEquipWeapon()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.EventLobbyTestEquipWeapon");

	Abp_lobby_C_EventLobbyTestEquipWeapon_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


// Function bp_lobby.bp_lobby_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)

void Abp_lobby_C::UserConstructionScript()
{
	static UFunction *pFunc = 0;
	if (!pFunc)
		pFunc  = UObject::FindObject<UFunction>("Function bp_lobby.bp_lobby_C.UserConstructionScript");

	Abp_lobby_C_UserConstructionScript_Params params;

	auto flags = pFunc->FunctionFlags;

	UObject *currentObj = (UObject *) this;
	currentObj->ProcessEvent(pFunc, &params);

	pFunc->FunctionFlags = flags;
}


}