StandardChallengeColumns = {
	Ref = 0,
	Name = 1,
	Desc = 2,
	Label = 3,
	Weight = 4,
	Filter = 5,
	UnlockLevel = 6,
	ChallengeUnlock = 7,
	PrestigeShotUnlock = 8,
	Target1 = 9,
	XP1 = 10,
	Target2 = 11,
	XP2 = 12,
	Target3 = 13,
	XP3 = 14,
	Target4 = 15,
	XP4 = 16,
	Target5 = 17,
	XP5 = 18,
	Target6 = 19,
	XP6 = 20,
	Target7 = 21,
	XP7 = 22,
	Target8 = 23,
	XP8 = 24,
	Target9 = 25,
	XP9 = 26,
	SP1 = 27,
	SP2 = 28,
	SP3 = 29,
	SP4 = 30,
	SP5 = 31,
	SP6 = 32,
	SP7 = 33,
	SP8 = 34,
	SP9 = 35
}
AllChallengesTable = {
	File = "mp/allChallengesTable.csv",
	Cols = StandardChallengeColumns
}
DailyChallengesTable = {
	File = "mp/dailyChallengesTable.csv",
	Cols = StandardChallengeColumns
}
WeekleyChallengesTable = {
	File = "mp/weekleyChallengesTable.csv",
	Cols = StandardChallengeColumns
}
OperationGroups = {
	File = "mp/OperationsTable.csv",
	Cols = {
		Idx = 0,
		Ref = 1,
		Name = 2,
		Desc = 3,
		File = 4,
		FormattedName = 5
	},
	MaxGroups = 6
}
AnynonOpsTable = {
	Cols = {
		Idx = 0,
		Ref = 1
	},
	MaxOps = 500,
	MaxAvailOps = 10
}
WeaponChallenge = {
	ChallengesPerClass = 12,
	ChallengeSuffixes = {
		weapon_assault = {
			"",
			"_crouch",
			"_assists",
			"_defender",
			"_noattach",
			"_longshot",
			"_consecutive",
			"_pointblank",
			"_reload",
			"_sliding",
			"_leaning",
			"_allcamo"
		},
		weapon_smg = {
			"",
			"_crouch",
			"_assists",
			"_defender",
			"_noattach",
			"_hipfire",
			"_consecutive",
			"_pointblank",
			"_reload",
			"_sliding",
			"_leaning",
			"_allcamo"
		},
		weapon_lmg = {
			"",
			"_crouch",
			"_assists",
			"_defender",
			"_noattach",
			"_hipfire",
			"_consecutive",
			"_pointblank",
			"_penetrate",
			"_sliding",
			"_leaning",
			"_allcamo"
		},
		weapon_dmr = {
			"",
			"_crouch",
			"_assists",
			"_defender",
			"_longshot",
			"_headshot",
			"_consecutive",
			"_noattach",
			"_reload",
			"_pointblank",
			"_leaning",
			"_allcamo"
		},
		weapon_sniper = {
			"",
			"_crouch",
			"_noattach",
			"_defender",
			"_prone",
			"_oneshotkill",
			"_consecutive",
			"_pointblank",
			"_reload",
			"_penetrate",
			"_leaning",
			"_allcamo"
		},
		weapon_shotgun = {
			"",
			"_crouch",
			"_assist",
			"_defender",
			"_noattach",
			"_hipfire",
			"_consecutive",
			"_pointblank",
			"_reload",
			"_sliding",
			"_headshot",
			"_allcamo"
		},
		weapon_riot = {
			"",
			"_crouch",
			"_assist",
			"_damage",
			"_throwingknife",
			"_c4",
			"_pistol",
			"_explosive",
			"_backsmasher",
			"_consecutive",
			"_noperks",
			"_allcamo"
		}
	}
}
WeaponChallengeTable = {
	File = "mp/challenges/challengeTable_WeaponOps.csv",
	Cols = AnynonOpsTable.Cols
}
OperationsTimeoutRewards = {
	{
		req = 5,
		reward = 5
	},
	{
		req = 10,
		reward = 10
	},
	{
		req = 15,
		reward = 15
	},
	{
		req = 20,
		reward = 20
	},
	{
		req = 25,
		reward = 25
	}
}
TierStrings = {
	"@LUA_MENU_ROMAN_ONE",
	"@LUA_MENU_ROMAN_TWO",
	"@LUA_MENU_ROMAN_THREE",
	"@LUA_MENU_ROMAN_FOUR",
	"@LUA_MENU_ROMAN_FIVE",
	"@LUA_MENU_ROMAN_SIX",
	"@LUA_MENU_ROMAN_SEVEN",
	"@LUA_MENU_ROMAN_EIGHT",
	"@LUA_MENU_ROMAN_NINE"
}
CostOfNewOperations = 1
OperationUtilsCache = {
	SortTypes = {
		"Alphabetical",
		"Progress"
	},
	SortTypeNames = {
		"LUA_MENU_MP_OP_SORT_TYPE_ALPHA",
		"LUA_MENU_MP_OP_SORT_TYPE_PROGRESS"
	},
	CurrentSortType = nil,
	Types = {
		Groups = "groups",
		OpData = "op_data",
		OpRows = "op_rows",
		WeaponOps = "weapon_ops"
	},
	CurrentSortType = 1
}
MaxTrackedOperations = 10
local f0_local0 = 528
function parseChallengeName( f1_arg0 )
	local f1_local0 = f1_arg0
	local f1_local1 = 1
	if f1_arg0 ~= "" then
		local f1_local2 = string.len( f1_arg0 )
		local f1_local3 = string.sub( f1_arg0, 1, f1_local2 - 2 )
		local f1_local4 = string.sub( f1_arg0, f1_local2 - 1, f1_local2 - 1 )
		local f1_local5 = tonumber( string.sub( f1_arg0, f1_local2 ) )
		if f1_local4 == "_" and TierStrings[f1_local5] ~= nil then
			f1_local1 = f1_local5
			f1_local0 = f1_local3
		else
			DebugPrint( "ref " .. f1_arg0 .. "does not contain valid tier, defaulting to tier 1" )
		end
	end
	return f1_local0, f1_local1
end

function getUnlockInfoStrings( f2_arg0, f2_arg1, f2_arg2, f2_arg3 )
	local f2_local0, f2_local1 = parseChallengeName( f2_arg0 )
	local f2_local2 = operationGetNameWithTierPostFix( f2_local0, f2_local1 )
	local f2_local3 = getGroupRefForOperation( f2_local0 )
	local f2_local4 = Engine.Localize( GetFieldForOperationsGroup( f2_local3, OperationGroups.Cols.FormattedName ), f2_local2 )
	local f2_local5 = nil
	local f2_local6 = f2_local3 and f2_local3 ~= ""
	local f2_local7 = false
	if f2_local6 then
		f2_local7 = f2_local1 < getOperationState( f2_arg1, f2_local0 )
	end
	if f2_local6 and not f2_local7 and f2_arg3 and not isOpActive( f2_arg1, f2_local0 ) then
		f2_local5 = Engine.Localize( "@LUA_MENU_OP_INACTIVE" )
	else
		local f2_local8 = operationGetTargetForTier( f2_local0, f2_local1, f2_arg2 )
		if f2_local0 == "ch_longersprint_pro" then
			f2_local8 = math.floor( f2_local8 / f0_local0 )
		end
		f2_local5 = operationGetDesc( f2_local0, f2_local8 )
	end
	return f2_local4, f2_local5
end

function getGroupRefForOperation( f3_arg0 )
	local f3_local0 = ""
	for f3_local1 = 1, OperationGroups.MaxGroups, 1 do
		local f3_local4 = Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Idx, tostring( f3_local1 - 1 ), OperationGroups.Cols.Ref )
		if isOperationInGroup( f3_arg0, f3_local4 ) then
			f3_local0 = f3_local4
			break
		end
	end
	return f3_local0
end

function isOperationInGroup( f4_arg0, f4_arg1 )
	local f4_local0 = AnynonOpsTable.MaxOps
	local f4_local1 = GetFieldForOperationsGroup( f4_arg1, OperationGroups.Cols.File )
	for f4_local2 = 1, f4_local0, 1 do
		if Engine.TableLookup( f4_local1, AnynonOpsTable.Cols.Idx, tostring( f4_local2 - 1 ), AnynonOpsTable.Cols.Ref ) == f4_arg0 then
			return true
		end
	end
	return false
end

function GetFieldForOperationsGroup( f5_arg0, f5_arg1 )
	local f5_local0 = assert
	local f5_local1
	if f5_arg1 < OperationGroups.Cols.Idx or f5_arg1 > OperationGroups.Cols.FormattedName then
		f5_local1 = false
	else
		f5_local1 = true
	end
	f5_local0( f5_local1, "Invalid column in GetFieldForOperationsGroup( groupRef, column )" )
	return Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Ref, f5_arg0, f5_arg1 )
end

function GetFieldForChallenge( f6_arg0, f6_arg1 )
	local f6_local0 = assert
	local f6_local1
	if f6_arg1 < AllChallengesTable.Cols.Ref or f6_arg1 > AllChallengesTable.Cols.SP9 then
		f6_local1 = false
	else
		f6_local1 = true
	end
	f6_local0( f6_local1, "Invalid column in GetFieldForChallenge( challenge_ref, column )" )
	if not CanAcessOperationCache() then
		return Engine.TableLookup( AllChallengesTable.File, AllChallengesTable.Cols.Ref, f6_arg0, f6_arg1 )
	else
		return Engine.TableLookupByRow( AllChallengesTable.File, GetCachedChallengeTableRowForOp( f6_arg0 ), f6_arg1 )
	end
end

function GetFieldForDailyChallenge( f7_arg0, f7_arg1 )
	local f7_local0 = assert
	local f7_local1
	if f7_arg1 < DailyChallengesTable.Cols.Ref or f7_arg1 > DailyChallengesTable.Cols.XP9 then
		f7_local1 = false
	else
		f7_local1 = true
	end
	f7_local0( f7_local1, "Invalid column in GetFieldForDailyChallenge( challenge_ref, column )" )
	return Engine.TableLookup( DailyChallengesTable.File, DailyChallengesTable.Cols.Ref, f7_arg0, f7_arg1 )
end

function GetFieldForWeekleyChallenge( f8_arg0, f8_arg1 )
	local f8_local0 = assert
	local f8_local1
	if f8_arg1 < WeekleyChallengesTable.Cols.Ref or f8_arg1 > WeekleyChallengesTable.Cols.XP9 then
		f8_local1 = false
	else
		f8_local1 = true
	end
	f8_local0( f8_local1, "Invalid column in GetFieldForWeekleyChallenge( challenge_ref, column )" )
	return Engine.TableLookup( WeekleyChallengesTable.File, WeekleyChallengesTable.Cols.Ref, f8_arg0, f8_arg1 )
end

function GetGroupIndex( f9_arg0 )
	return tonumber( GetFieldForOperationsGroup( f9_arg0, OperationGroups.Cols.Idx ) )
end

function GetTrackedOp( f10_arg0, f10_arg1 )
	return Engine.GetPlayerDataEx( f10_arg0, CoD.StatsGroup.Ranked, "currentChallenges", 0, f10_arg1 )
end

function GetOperationForWeapon( f11_arg0, f11_arg1, f11_arg2, f11_arg3 )
	local f11_local0 = assert
	local f11_local1
	if f11_arg3 < 0 or f11_arg3 >= WeaponChallenge.ChallengesPerClass then
		f11_local1 = false
	else
		f11_local1 = true
	end
	f11_local0( f11_local1 )
	return "ch_" .. f11_arg2 .. WeaponChallenge.ChallengeSuffixes[f11_arg1][f11_arg3 + 1]
end

function GetOperationForWeaponFromCache( f12_arg0, f12_arg1, f12_arg2, f12_arg3 )
	local f12_local0 = GetOperationCache( OperationUtilsCache.Types.WeaponOps )
	if not f12_local0[f12_arg2] then
		CacheWeaponOps( f12_arg0, f12_arg1, f12_arg2 )
	end
	assert( f12_local0[f12_arg2] ~= nil )
	local f12_local1 = f12_local0[f12_arg2].sortedRefLists
	local f12_local2 = OperationUtilsCache.SortTypes
	return f12_local1[OperationUtilsCache.SortTypes[OperationUtilsCache.CurrentSortType]][f12_arg3]
end

function GetOpForGroup( f13_arg0, f13_arg1, f13_arg2 )
	return GetOpForGroupIndex( f13_arg0, GetGroupIndex( f13_arg1 ), f13_arg2 )
end

function GetOpForGroupIndex( f14_arg0, f14_arg1, f14_arg2 )
	local f14_local0 = Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Idx, f14_arg1, OperationGroups.Cols.File )
	if f14_local0 == "" then
		return ""
	else
		return Engine.TableLookupByRow( f14_local0, f14_arg2, AnynonOpsTable.Cols.Ref )
	end
end

function GetCachedOpForGroup( f15_arg0, f15_arg1, f15_arg2 )
	return GetOperationFromCache( f15_arg0, GetGroupIndex( f15_arg1 ), f15_arg2 )
end

function SetTrackedOp( f16_arg0, f16_arg1, f16_arg2 )
	Engine.SetPlayerDataEx( f16_arg0, CoD.StatsGroup.Ranked, "currentChallenges", 0, f16_arg1, f16_arg2 )
end

function GetAllOpGroupRefs()
	local f17_local0 = {}
	for f17_local1 = 1, OperationGroups.MaxGroups, 1 do
		local f17_local4 = Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Idx, tostring( f17_local1 - 1 ), OperationGroups.Cols.Ref )
		if f17_local4 == "" then
			break
		end
		f17_local0[f17_local1] = f17_local4
	end
	return f17_local0
end

function GetOpsInGroup( f18_arg0, f18_arg1 )
	local f18_local0 = Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Idx, GetGroupIndex( f18_arg1 ), OperationGroups.Cols.File )
	if f18_local0 == "" then
		return {}
	end
	local f18_local1 = {}
	for f18_local2 = 1, AnynonOpsTable.MaxOps, 1 do
		local f18_local5 = Engine.TableLookupByRow( f18_local0, f18_local2, AnynonOpsTable.Cols.Ref )
		if f18_local5 ~= "" then
			f18_local1[f18_local2] = f18_local5
		end
	end
	return f18_local1
end

function GetCachedOpsInGroup( f19_arg0, f19_arg1 )
	return GetGroupOperationsFromCache( f19_arg0, GetGroupIndex( f19_arg1 ) )
end

function GetWeaponOpsForClass( f20_arg0 )
	return WeaponChallenge.ChallengeSuffixes[f20_arg0]
end

function isOpActive( f21_arg0, f21_arg1 )
	return true
end

function IsOpTracked( f22_arg0, f22_arg1 )
	for f22_local0 = 0, MaxTrackedOperations - 1, 1 do
		if f22_arg1 == GetTrackedOp( f22_arg0, f22_local0 ) then
			return true
		end
	end
	return false
end

function ClearProgressForOp( f23_arg0, f23_arg1 )
	Engine.SetPlayerDataEx( f23_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f23_arg1, 0 )
end

function GetNumOpsInGroupFile( f24_arg0 )
	local f24_local0 = 0
	for f24_local1 = 0, 500, 1 do
		if Engine.TableLookup( f24_arg0, AnynonOpsTable.Cols.Idx, tostring( f24_local1 ), AnynonOpsTable.Cols.Ref ) == "" then
			break
		end
		f24_local0 = f24_local0 + 1
	end
	return f24_local0
end

function InitOperationsData( f25_arg0 )
	for f25_local5, f25_local6 in ipairs( GetAllOpGroupRefs() ) do
		for f25_local4 = 0, AnynonOpsTable.MaxOps, 1 do
			local f25_local3 = GetOpForGroup( f25_arg0, f25_local6, f25_local4 )
			if f25_local3 and f25_local3 ~= "" then
				Engine.SetPlayerDataEx( f25_arg0, CoD.StatsGroup.Ranked, "challengeState", f25_local3, 1 )
			end
		end
	end
	for f25_local0 = 0, MaxTrackedOperations - 1, 1 do
		f25_local6 = nil
		if f25_local0 < 5 then
			f25_local6 = GetOpForGroupIndex( f25_arg0, f25_local0, 0 )
		else
			local f25_local4 = Cac.WeaponTypes.Primary[f25_local0 - 4]
			assert( #Cac.Weapons[f25_local4] >= 2 )
			f25_local6 = "ch_" .. Cac.Weapons[f25_local4][2]
		end
		assert( f25_local6 )
		Engine.SetPlayerDataEx( f25_arg0, CoD.StatsGroup.Ranked, "currentChallenges", 0, f25_local0, f25_local6 )
	end
end

function AwardSquadPoints( f26_arg0, f26_arg1 )
	if 0 < f26_arg1 then
		Engine.SetPlayerDataEx( f26_arg0, CoD.StatsGroup.Ranked, "unlockPoints", Engine.GetPlayerDataEx( f26_arg0, CoD.StatsGroup.Ranked, "unlockPoints" ) + f26_arg1 )
		Engine.SetPlayerDataEx( f26_arg0, CoD.StatsGroup.Ranked, "squadMembers", 0, "commendationsEarned", Engine.GetPlayerDataEx( f26_arg0, CoD.StatsGroup.Ranked, "squadMembers", 0, "commendationsEarned" ) + f26_arg1 )
	end
end

function GetOperationData( f27_arg0, f27_arg1 )
	local f27_local0 = isWeaponOperation( f27_arg1 )
	local f27_local1 = 3000
	local f27_local2 = {
		Ref = f27_arg1,
		Name = "",
		Desc = "",
		Label = "",
		Progress = 0,
		MaxProgress = 0,
		PercentProgress = 0,
		RewardXP = 0,
		RewardCurrency = 0,
		RewardImage = nil,
		RewardType = nil,
		ExtraRewardImages = nil,
		ExtraRewardTypes = nil,
		ProgressText = "",
		OpState = 0,
		NumTiers = 0,
		ActiveTier = 0,
		Completed = false,
		Name = operationGetName( f27_arg1 )
	}
	if f27_local2.Name == nil then
		DebugPrint( "its nil" )
	end
	if f27_local2.Name ~= "" then
		f27_local2.NumTiers = operationGetNumTiers( f27_arg1 )
		f27_local2.OpState = getOperationState( f27_arg0, f27_arg1 )
		f27_local2.ActiveTier = getTierForActiveOperation( f27_arg0, f27_arg1 )
		f27_local2.Completed = f27_local2.ActiveTier < f27_local2.OpState
		local f27_local3
		if f27_local0 then
			f27_local3 = weaponOperationGetNameWithTierPostFix( f27_arg1, f27_local2.ActiveTier )
			if not f27_local3 then
			
			else
				f27_local2.Name = f27_local3
				f27_local3 = operationGetTargetForTier( f27_arg1, f27_local2.ActiveTier )
				local f27_local4 = operationGetXPRewardForTier( f27_arg1, f27_local2.ActiveTier )
				f27_local2.RewardXP = f27_local4
				f27_local2.Progress = operationGetProgress( f27_arg0, f27_arg1 )
				f27_local2.MaxProgress = tonumber( f27_local3 )
				f27_local2.PercentProgress = f27_local2.Progress / f27_local2.MaxProgress
				if f27_arg1 == "ch_longersprint_pro" then
					local f27_local5 = math.floor( f27_local2.Progress / f0_local0 )
					local f27_local6 = math.floor( f27_local2.MaxProgress / f0_local0 )
					f27_local2.Desc = operationGetDesc( f27_arg1, f27_local6 )
					f27_local2.Progress = f27_local5
					f27_local2.MaxProgress = f27_local6
				elseif f27_local0 and string.find( f27_arg1, "_allcamo" ) then
					f27_local2.Progress, f27_local2.MaxProgress = Cac.CountCamosForGold( f27_arg0, getWeaponOperationWeaponName( f27_arg1 ) )
					f27_local2.Completed = f27_local7 <= f27_local6
					f27_local2.PercentProgress = f27_local2.Progress / f27_local2.MaxProgress
					f27_local2.Desc = operationGetDesc( f27_arg1, f27_local3 )
				else
					f27_local2.Desc = operationGetDesc( f27_arg1, f27_local3 )
				end
				if f27_local0 then
					f27_local2.Label = operationGetLabel( f27_arg1 )
				end
				f27_local2.ProgressText = tostring( f27_local2.Progress ) .. "/" .. tostring( f27_local2.MaxProgress )
				f27_local2.RewardCurrency = operationGetSPRewardForTier( f27_arg1, f27_local2.ActiveTier )
				local f27_local5 = math.floor( f27_local4 / f27_local1 )
				if f27_local2.RewardCurrency ~= "" then
					f27_local2.RewardCurrency = f27_local5 + tonumber( f27_local2.RewardCurrency )
				else
					f27_local2.RewardCurrency = f27_local5
				end
				local f27_local6 = getUnlocksByChallenge( f27_arg1, f27_local2.ActiveTier )
				if #f27_local6 > 0 then
					if isUnlockItem( f27_local6[1].type ) then
						f27_local2.RewardImage = RegisterMaterial( getMaterialForUnlockItem( f27_local6[1].type, f27_local6[1].item ) )
						f27_local2.RewardType = f27_local6[1].type
						table.remove( f27_local6, 1 )
					end
					for f27_local7 = 1, #f27_local6, 1 do
						if isUnlockItem( f27_local6[f27_local7].type ) then
							if not f27_local2.ExtraRewardImages then
								f27_local2.ExtraRewardImages = {}
								f27_local2.ExtraRewardTypes = {}
							end
							table.insert( f27_local2.ExtraRewardImages, RegisterMaterial( getMaterialForUnlockItem( f27_local6[f27_local7].type, f27_local6[f27_local7].item ) ) )
							table.insert( f27_local2.ExtraRewardTypes, f27_local6[f27_local7].type )
						end
					end
				end
			end
		end
		f27_local3 = operationGetNameWithTierPostFix( f27_arg1, f27_local2.ActiveTier )
	end
	return f27_local2
end

function GetCachedOperationData( f28_arg0, f28_arg1 )
	local f28_local0 = GetOperationCache( OperationUtilsCache.Types.OpData )
	if not f28_local0[f28_arg1] then
		f28_local0[f28_arg1] = GetOperationData( f28_arg0, f28_arg1 )
	end
	return f28_local0[f28_arg1]
end

function getUnlocksByChallenge( f29_arg0, f29_arg1 )
	if isWeaponOperation( f29_arg0 ) then
		return getUnlocksByWeaponChallenge( f29_arg0, f29_arg1 )
	end
	local f29_local0 = f29_arg0 .. "_" .. f29_arg1
	local f29_local1 = {}
	local f29_local2 = ""
	local f29_local3 = ""
	local f29_local4 = ""
	local f29_local5 = 0
	while true do
		f29_local3 = Engine.TableLookupByRow( UnlockTable.File, f29_local5, UnlockTable.Cols.ItemId )
		f29_local2 = Engine.TableLookupByRow( UnlockTable.File, f29_local5, UnlockTable.Cols.Challenge )
		if f29_local3 == "" then
			return f29_local1
		elseif f29_local2 == f29_local0 then
			f29_local4 = Engine.TableLookupByRow( UnlockTable.File, f29_local5, UnlockTable.Cols.Type )
			if f29_local4 == "Patch" then
				table.insert( f29_local1, 1, {
					row = f29_local5,
					item = f29_local3,
					type = f29_local4
				} )
			else
				table.insert( f29_local1, {
					row = f29_local5,
					item = f29_local3,
					type = f29_local4
				} )
			end
		end
		f29_local5 = f29_local5 + 1
	end
end

function getUnlocksByWeaponChallenge( f30_arg0, f30_arg1 )
	local f30_local0 = tostring( f30_arg1 )
	local f30_local1 = getWeaponOperationSuffix( f30_arg0 )
	local f30_local2 = getWeaponOperationWeaponClass( f30_arg0 )
	if not f30_local2 or f30_local2 == "" or not f30_local1 then
		return {}
	end
	local f30_local3 = string.len( f30_local2 )
	local f30_local4 = {}
	for f30_local5 = 0, CamoReticleUnlockTable.MaxRows, 1 do
		if Engine.TableLookupByRow( CamoReticleUnlockTable.File, f30_local5, CamoReticleUnlockTable.Cols.ChallengeRef ) == f30_local1 then
			local f30_local8 = Engine.TableLookupByRow( CamoReticleUnlockTable.File, f30_local5, CamoReticleUnlockTable.Cols.CamoReticleRef )
			if string.sub( f30_local8, 0, f30_local3 ) == f30_local2 then
				if Engine.TableLookupByRow( CamoReticleUnlockTable.File, f30_local5, CamoReticleUnlockTable.Cols.Tier ) == f30_local0 then
					table.insert( f30_local4, 1, {
						item = string.sub( f30_local8, f30_local3 + 2 ),
						type = "Camo"
					} )
					break
				end
			end
		end
	end
	return f30_local4
end

function operationIsComplete( f31_arg0 )
	return f31_arg0.MaxProgress <= f31_arg0.Progress
end

function operationGetNumTiers( f32_arg0 )
	local f32_local0 = 0
	local f32_local1 = 9
	for f32_local2 = 1, f32_local1, 1 do
		if GetFieldForChallenge( f32_arg0, AllChallengesTable.Cols["Target" .. f32_local2] ) == "" then
			break
		end
		f32_local0 = f32_local0 + 1
	end
	return f32_local0
end

function operationGetNameWithTierPostFix( f33_arg0, f33_arg1 )
	local f33_local0 = operationGetName( f33_arg0 )
	if operationGetNumTiers( f33_arg0 ) > 1 then
		f33_local0 = Engine.Localize( "@LUA_MENU_CHALLENGE_AND_TIER", f33_local0, Engine.Localize( TierStrings[f33_arg1] ) )
	end
	return f33_local0
end

function weaponOperationGetNameWithTierPostFix( f34_arg0, f34_arg1 )
	return Engine.Localize( "LUA_MENU_MP_WEAPON_OP_PREFIX", operationGetLabel( f34_arg0 ) .. (getWeaponOperationSuffix( f34_arg0 ) and "" or " ") .. Engine.Localize( TierStrings[f34_arg1] ), operationGetName( f34_arg0 ) )
end

function operationGetName( f35_arg0 )
	local f35_local0 = GetFieldForChallenge( f35_arg0, AllChallengesTable.Cols.Name )
	if f35_local0 == "" then
		DebugPrint( "Warning, challenge " .. f35_arg0 .. " not found in the challenges table" )
		return f35_local0
	else
		return Engine.Localize( f35_local0 )
	end
end

function operationGetDesc( f36_arg0, f36_arg1 )
	return Engine.Localize( GetFieldForChallenge( f36_arg0, AllChallengesTable.Cols.Desc ), f36_arg1, "" )
end

function operationGetLabel( f37_arg0 )
	return Engine.Localize( GetFieldForChallenge( f37_arg0, AllChallengesTable.Cols.Label ), "", "" )
end

function getTierForActiveOperation( f38_arg0, f38_arg1 )
	local f38_local0 = Engine.GetPlayerDataEx( f38_arg0, CoD.StatsGroup.Ranked, "challengeState", f38_arg1 )
	local f38_local1 = operationGetNumTiers( f38_arg1 )
	if not f38_local0 then
		f38_local0 = 0
	end
	if f38_local1 < f38_local0 then
		local f38_local2 = f38_local1
	end
	return f38_local2 or f38_local0
end

function getOperationState( f39_arg0, f39_arg1 )
	return Engine.GetPlayerDataEx( f39_arg0, CoD.StatsGroup.Ranked, "challengeState", f39_arg1 )
end

function operationGetTargetForTier( f40_arg0, f40_arg1, f40_arg2 )
	local f40_local0 = 0
	if f40_arg2 then
	
	else
		f40_local0 = GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
	end
	f40_local0 = f40_local0 + GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
	f40_arg1 = f40_arg1 - 1
	repeat
		f40_local0 = f40_local0 + GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
		f40_arg1 = f40_arg1 - 1
		repeat
			f40_local0 = f40_local0 + GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
			f40_arg1 = f40_arg1 - 1
			repeat
				f40_local0 = f40_local0 + GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
				f40_arg1 = f40_arg1 - 1
				repeat
					f40_local0 = f40_local0 + GetFieldForChallenge( f40_arg0, AllChallengesTable.Cols["Target" .. f40_arg1] )
					f40_arg1 = f40_arg1 - 1
					repeat
						-- ERROR: Infinite loop detected
					until f40_arg1 <= 0
				until f40_arg1 <= 0
			until f40_arg1 <= 0
		until f40_arg1 <= 0
	until f40_arg1 <= 0
end

function operationGetXPRewardForTier( f41_arg0, f41_arg1 )
	return GetFieldForChallenge( f41_arg0, AllChallengesTable.Cols["XP" .. f41_arg1] )
end

function operationGetSPRewardForTier( f42_arg0, f42_arg1 )
	return GetFieldForChallenge( f42_arg0, AllChallengesTable.Cols["SP" .. f42_arg1] )
end

function operationGetProgress( f43_arg0, f43_arg1 )
	return Engine.GetPlayerDataEx( f43_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f43_arg1 )
end

function OperationGetReqs( f44_arg0, f44_arg1 )
	local f44_local0 = ""
	local f44_local1 = ""
	local f44_local2 = ""
	local f44_local3 = ""
	local f44_local4 = ""
	local f44_local5 = 1500
	for f44_local6 = 0, f44_local5, 1 do
		f44_local3 = Engine.TableLookupByRow( UnlockTable.File, f44_local6, UnlockTable.Cols.ItemId )
		if f44_local3 == "" then
			break
		elseif f44_local3 == f44_arg0 and Engine.TableLookupByRow( UnlockTable.File, f44_local6, UnlockTable.Cols.Type ) == f44_arg1 then
			f44_local1 = Engine.TableLookupByRow( UnlockTable.File, f44_local6, UnlockTable.Cols.Rank )
			f44_local0 = Engine.TableLookupByRow( UnlockTable.File, f44_local6, UnlockTable.Cols.Challenge )
			f44_local2 = Engine.TableLookupByRow( UnlockTable.File, f44_local6, UnlockTable.Cols.ExtRank )
			break
		end
	end
	return f44_local0, f44_local1, f44_local2
end

function operationGetMatchCompleted( f45_arg0 )
	local f45_local0 = {}
	for f45_local1 = 0, 4, 1 do
		local f45_local4 = Engine.GetPlayerDataEx( f45_arg0, CoD.StatsGroup.Common, "round", "operationsCompleted", f45_local1 )
		if f45_local4 ~= "" then
			table.insert( f45_local0, {
				opRef = f45_local4,
				tier = getTierForActiveOperation( f45_arg0, f45_local4 )
			} )
		end
	end
	return f45_local0
end

function isUnlockItem( f46_arg0 )
	if not (f46_arg0 == "ClanTag" or not Cac.Customization.FieldIndexes[f46_arg0]) or f46_arg0 == "Camo" then
		return true
	else
		return false
	end
end

function getNameForUnlockItem( f47_arg0, f47_arg1 )
	assert( isUnlockItem( f47_arg0 ) )
	local f47_local0 = ""
	if f47_arg0 == "Camo" then
		f47_local0 = Engine.TableLookup( CamoTable.File, CamoTable.Cols.Ref, f47_arg1, CamoTable.Cols.Name )
	else
		f47_local0 = Cac.Customization.Fields[Cac.Customization.FieldIndexes[f47_arg0]].GetName( f47_arg1 )
	end
	return f47_local0
end

function getMaterialForUnlockItem( f48_arg0, f48_arg1 )
	assert( isUnlockItem( f48_arg0 ) )
	local f48_local0 = ""
	if f48_arg0 == "Camo" then
		f48_local0 = Engine.TableLookup( CamoTable.File, CamoTable.Cols.Ref, f48_arg1, CamoTable.Cols.Image )
	else
		f48_local0 = Cac.Customization.Fields[Cac.Customization.FieldIndexes[f48_arg0]].GetUIMaterial( f48_arg1 )
	end
	return f48_local0
end

function getLocNameForUnlockType( f49_arg0 )
	assert( isUnlockItem( f49_arg0 ) )
	if f49_arg0 == "Camo" then
		return Engine.Localize( "@MENU_CAMO_CAPS" )
	else
		return Engine.Localize( "@LUA_MENU_CUSTOMIZATION_FIELD_" .. Cac.Customization.Fields[Cac.Customization.FieldIndexes[f49_arg0]].LocName .. "_CAPS" )
	end
end

function isWeaponOperation( f50_arg0 )
	return Engine.TableLookup( WeaponChallengeTable.File, WeaponChallengeTable.Cols.Ref, f50_arg0, WeaponChallengeTable.Cols.Idx ) ~= ""
end

function getWeaponOperationWeaponName( f51_arg0 )
	assert( isWeaponOperation( f51_arg0 ) )
	local f51_local0 = GetFieldForChallenge( f51_arg0, AllChallengesTable.Cols.Filter )
	assert( f51_local0 ~= "" )
	return f51_local0
end

function getWeaponOperationWeaponClass( f52_arg0 )
	local f52_local0 = getWeaponOperationWeaponName( f52_arg0 )
	for f52_local7, f52_local8 in pairs( Cac.Weapons ) do
		for f52_local4, f52_local5 in ipairs( f52_local8 ) do
			if f52_local5 == f52_local0 then
				return f52_local7
			end
		end
	end
end

function getWeaponOperationSuffix( f53_arg0 )
	return string.sub( f53_arg0, string.len( getWeaponOperationWeaponName( f53_arg0 ) ) + 4 )
end

function CanAcessOperationCache()
	local f54_local0 = LUI.FlowManager.IsInStack
	local f54_local1 = Engine.GetLuiRoot()
	return f54_local0( f54_local1.flowManager, "operations_main_menu" )
end

function GetOperationCache( f55_arg0 )
	local f55_local0 = LUI.FlowManager.GetMenuScopedDataByMenuName( "operations_main_menu" )
	assert( f55_local0 )
	if not f55_local0[f55_arg0] then
		f55_local0[f55_arg0] = {}
	end
	return f55_local0[f55_arg0]
end

function OperationCacheSortFunction( f56_arg0, f56_arg1 )
	return f56_arg0.sortValue < f56_arg1.sortValue
end

function OperationCacheReverseSortFunction( f57_arg0, f57_arg1 )
	return f57_arg1.sortValue < f57_arg0.sortValue
end

function CacheOperationGroupInfo( f58_arg0, f58_arg1 )
	local f58_local0 = GetOperationCache( OperationUtilsCache.Types.Groups )
	if f58_local0[f58_arg1] then
		return 
	end
	f58_local0[f58_arg1] = {}
	f58_local0[f58_arg1].sortedRefLists = {}
	local f58_local1 = {}
	local f58_local2 = {}
	local f58_local3 = Engine.TableLookup( OperationGroups.File, OperationGroups.Cols.Idx, f58_arg1, OperationGroups.Cols.File )
	local f58_local4 = nil
	if f58_local3 ~= "" then
		for f58_local5 = 0, AnynonOpsTable.MaxOps, 1 do
			local f58_local8 = Engine.TableLookupByRow( f58_local3, f58_local5, AnynonOpsTable.Cols.Ref )
			if f58_local8 ~= "" then
				local f58_local9 = GetCachedOperationData( f58_arg0, f58_local8 )
				f58_local1[f58_local5 + 1] = {
					ref = f58_local8,
					sortValue = Engine.Localize( GetFieldForChallenge( f58_local8, AllChallengesTable.Cols.Name ) )
				}
				f58_local2[f58_local5 + 1] = {
					ref = f58_local8,
					sortValue = f58_local9.PercentProgress
				}
			end
		end
		table.sort( f58_local1, OperationCacheSortFunction )
		table.sort( f58_local2, OperationCacheReverseSortFunction )
		local f58_local5 = {}
		f58_local0[f58_arg1].sortedRefLists.Alphabetical = f58_local5
		local f58_local6 = {}
		f58_local0[f58_arg1].sortedRefLists.Progress = f58_local6
		for f58_local7 = 1, #f58_local1, 1 do
			f58_local5[f58_local7] = f58_local1[f58_local7].ref
			f58_local6[f58_local7] = f58_local2[f58_local7].ref
		end
	end
end

function CacheWeaponOps( f59_arg0, f59_arg1, f59_arg2 )
	local f59_local0 = GetOperationCache( OperationUtilsCache.Types.WeaponOps )
	local f59_local1 = GetOperationCache( OperationUtilsCache.Types.OpRows )
	if f59_local0[f59_arg2] ~= nil then
		return 
	end
	f59_local0[f59_arg2] = {}
	local f59_local2 = {}
	local f59_local3 = {}
	for f59_local8, f59_local9 in pairs( WeaponChallenge.ChallengeSuffixes[f59_arg1] ) do
		local f59_local10 = "ch_" .. f59_arg2 .. f59_local9
		local f59_local11 = Engine.TableLookupGetRowNum( AllChallengesTable.File, AllChallengesTable.Cols.Ref, f59_local10 )
		if f59_local11 and f59_local11 ~= -1 then
			f59_local1[f59_local10] = f59_local11
		end
		local f59_local7 = GetCachedOperationData( f59_arg0, f59_local10 )
		f59_local2[#f59_local2 + 1] = {
			ref = f59_local10,
			sortValue = f59_local7.Name
		}
		f59_local3[#f59_local3 + 1] = {
			ref = f59_local10,
			sortValue = f59_local7.PercentProgress
		}
	end
	f59_local0[f59_arg2].sortedRefLists = {}
	table.sort( f59_local2, OperationCacheSortFunction )
	table.sort( f59_local3, OperationCacheReverseSortFunction )
	f59_local4 = {}
	f59_local0[f59_arg2].sortedRefLists.Alphabetical = f59_local4
	f59_local5 = {}
	f59_local0[f59_arg2].sortedRefLists.Progress = f59_local5
	for f59_local6 = 1, #f59_local2, 1 do
		f59_local4[f59_local6] = f59_local2[f59_local6].ref
		f59_local5[f59_local6] = f59_local3[f59_local6].ref
	end
end

function GetGroupOperationsFromCache( f60_arg0, f60_arg1 )
	local f60_local0 = GetOperationCache( OperationUtilsCache.Types.Groups )
	if not f60_local0[f60_arg1] then
		CacheOperationGroupInfo( f60_arg0, f60_arg1 )
	end
	assert( f60_local0[f60_arg1] ~= nil )
	return f60_local0[f60_arg1].sortedRefLists[OperationUtilsCache.SortTypes[OperationUtilsCache.CurrentSortType]]
end

function GetOperationFromCache( f61_arg0, f61_arg1, f61_arg2 )
	local f61_local0 = GetOperationCache( OperationUtilsCache.Types.Groups )
	if not f61_local0[f61_arg1] then
		CacheOperationGroupInfo( f61_arg0, f61_arg1 )
	end
	assert( f61_local0[f61_arg1] ~= nil )
	local f61_local1 = f61_local0[f61_arg1].sortedRefLists
	local f61_local2 = OperationUtilsCache.SortTypes
	return f61_local1[OperationUtilsCache.SortTypes[OperationUtilsCache.CurrentSortType]][f61_arg2]
end

function GetCachedChallengeTableRowForOp( f62_arg0 )
	local f62_local0 = GetOperationCache( OperationUtilsCache.Types.OpRows )
	if not f62_local0[f62_arg0] then
		f62_local0[f62_arg0] = Engine.TableLookupGetRowNum( AllChallengesTable.File, AllChallengesTable.Cols.Ref, f62_arg0 )
	end
	return f62_local0[f62_arg0]
end

function RandomizeOperationData( f63_arg0 )
	if not Engine.IsDevelopmentBuild() then
		return 
	end
	for f63_local0 = 0, 1000, 1 do
		local f63_local3 = Engine.TableLookupByRow( AllChallengesTable.File, f63_local0, AllChallengesTable.Cols.Ref )
		if f63_local3 and f63_local3 ~= "" then
			local f63_local4 = operationGetNumTiers( f63_local3 )
			local f63_local5 = f63_local4
			local f63_local6 = math.floor( math.random() * f63_local4 + 1 )
			local f63_local7 = operationGetTargetForTier( f63_local3, f63_local6 )
			Engine.SetPlayerDataEx( f63_arg0, CoD.StatsGroup.Ranked, "challengeState", f63_local3, f63_local6 )
			local f63_local8 = math.floor( math.random() * 6 )
			if f63_local8 < 3 then
				Engine.SetPlayerDataEx( f63_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f63_local3, math.floor( math.random() * f63_local7 ) )
			end
			if f63_local8 == 4 then
				Engine.SetPlayerDataEx( f63_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f63_local3, f63_local7 )
			end
			if f63_local8 == 5 then
				Engine.SetPlayerDataEx( f63_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f63_local3, 0 )
			end
		end
	end
end

function ValidateOperations( f64_arg0 )
	if Engine.HasActiveLocalClient( f64_arg0 ) then
		ConvertOldTrackedOpertions( f64_arg0 )
		local f64_local0 = "ch_iw6_riotshield_damage"
		local f64_local1 = getTierForActiveOperation( f64_arg0, f64_local0 )
		local f64_local2 = operationGetNumTiers( f64_local0 )
		if f64_local1 == f64_local2 then
			local f64_local3 = operationGetProgress( f64_arg0, f64_local0 )
			local f64_local4 = tonumber( operationGetTargetForTier( f64_local0, f64_local2 ) )
			if f64_local3 < 0 or f64_local4 <= f64_local3 then
				Engine.SetPlayerDataEx( f64_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f64_local0, f64_local4 - 1 )
			end
		end
		local f64_local3 = "ch_hijacker"
		local f64_local4 = getTierForActiveOperation( f64_arg0, f64_local3 )
		local f64_local5 = operationGetNumTiers( f64_local3 )
		if f64_local4 == f64_local5 then
			local f64_local6 = Engine.GetPlayerDataEx( f64_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f64_local3 )
			if f64_local6 < 0 or tonumber( operationGetTargetForTier( f64_local3, f64_local5 ) ) <= f64_local6 then
				Engine.SetPlayerDataEx( f64_arg0, CoD.StatsGroup.Ranked, "challengeState", f64_local3, f64_local5 + 1 )
				Engine.SetPlayerDataEx( f64_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f64_local3, 0 )
			end
		end
	end
end

function ConvertOldTrackedOpertions( f65_arg0 )
	if Engine.HasActiveLocalClient( f65_arg0 ) then
		local f65_local0 = true
		for f65_local1 = 0, 4, 1 do
			local f65_local4 = f65_local1
			local f65_local5 = Engine.GetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "activeChallenges", 0 )
			if not f65_local5 or f65_local5 == "" then
				f65_local0 = false
				break
			end
		end
		if f65_local0 then
			for f65_local5, f65_local9 in ipairs( GetAllOpGroupRefs() ) do
				for f65_local8 = 0, AnynonOpsTable.MaxOps, 1 do
					local f65_local6 = GetOpForGroup( f65_arg0, f65_local9, f65_local8 )
					if f65_local6 and f65_local6 ~= "" then
						if Engine.GetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "challengeState", f65_local6 ) == 0 then
							Engine.SetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "challengeState", f65_local6, 1 )
						end
						local f65_local7 = getTierForActiveOperation( f65_arg0, f65_local6 )
						if tonumber( operationGetTargetForTier( f65_local6, f65_local7 ) ) <= Engine.GetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f65_local6 ) and f65_local7 <= operationGetNumTiers( f65_local6 ) then
							Engine.SetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "challengeState", f65_local6, f65_local7 + 1 )
							Engine.SetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "challengeProgress", f65_local6, 0 )
						end
					end
				end
			end
			for f65_local2 = 0, MaxTrackedOperations - 1, 1 do
				f65_local9 = nil
				if f65_local2 < 5 then
					f65_local9 = Engine.GetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "activeChallenges", f65_local2 )
					assert( f65_local9 and f65_local9 ~= "" )
					Engine.SetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "activeChallenges", f65_local2, "" )
				else
					local f65_local8 = Cac.WeaponTypes.Primary[f65_local2 - 4]
					local f65_local10 = -1
					local f65_local11 = ""
					for f65_local12 = 1, #Cac.Weapons[f65_local8], 1 do
						local f65_local14 = Cac.Weapons[f65_local8][f65_local12]
						local f65_local15 = Engine.GetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "weaponStats", f65_local14, "kills" )
						if f65_local10 < f65_local15 then
							f65_local11 = f65_local14
							f65_local10 = f65_local15
						end
					end
					f65_local9 = "ch_" .. f65_local11
				end
				Engine.SetPlayerDataEx( f65_arg0, CoD.StatsGroup.Ranked, "currentChallenges", 0, f65_local2, f65_local9 )
			end
		end
	end
end