function ()

    local EnergyRegeneration = UnitSpellHaste("player")/10 +10
    local EnergyCurrent = UnitPower("Player")
    local EnergyMax =  UnitPowerMax("Player")
    local ComboPointsCurrent = GetComboPoints("Player")


    local RakeTimer = 0
    local RakeStrength = 0
    local RakeCost = 35
    local RipTimer = 0
    local RipStrength = 0
    local RipCost = 30
    local ShredCost = 40

    local FerociousBiteCost = 50
    local EnergyNeededFerociousBite = FerociousBiteCost - EnergyCurrent
    if EnergyNeededFerociousBite < 0 then
        EnergyNeededFerociousBite = 0
    end
    local EnergyTimeNeededFerociousBite = EnergyNeededFerociousBite*EnergyRegeneration/100

    local ThrashTimer = 0
    local ThrashStrength = 0
    local ThrashCost = 50

    local SwipeCost = 45

    local ShadowmeldMaxTimer = 120
    local ShadowmeldCD = GetSpellCooldown("Shadowmeld") + ShadowmeldMaxTimer - GetTime()
    local TigersFuryCost = EnergyMax - 35
    if (ShadowmeldCD < 0) then
        ShadowmeldCD = 0
    end

    local TigersFuryMaxTimer = 30
    local TigersFuryTimer = 0
    local TigersFuryCD = GetSpellCooldown("Tiger's Fury") + TigersFuryMaxTimer - GetTime()
    local TigersFuryCost = EnergyMax - 65
    if (TigersFuryCD < 0) then
        TigersFuryCD = 0
    end

    local SavageRoarTimer = 0
    local SavageRoarCost = 25

    local BerserkCost = 90
    local BerserkMaxTimer = 180
    local BerserkTimer = 0
    local BerserkCD =  GetSpellCooldown("Berserk") + BerserkMaxTimer - GetTime()
    if (BerserkCD < 0) then
        BerserkCD = 0
    end
    local EnergyNeededBerserk = BerserkCost - EnergyCurrent
    if EnergyNeededBerserk < 0 then
        EnergyNeededBerserk = 0
    end
    local EnergyTimeNeededBerserk = EnergyNeededBerserk*EnergyRegeneration/100

    local IncarnationMaxTimer = 180
    local IncarnationTimer = 0
    local IncarnationCD =  GetSpellCooldown("Incarnation: King of the Jungle") + IncarnationMaxTimer - GetTime()
    if (IncarnationCD < 0) then
        IncarnationCD = 0
    end

    local Bloodlust = 0
    local Trinket1Proc = 0
    local Trinket2Proc = 0

    local StealthOpener = 0
	local Shadowmeld = 0
	local ShadowmeldMaxTimer = 120
	local ShadowmeldCD = GetSpellCooldown("Shadowmeld") + ShadowmeldMaxTimer - GetTime()
    if (ShadowmeldCD < 0) then
        ShadowmeldCD = 0
    end
	local Clearcasting = 0

    local Smart1st = "1"
    local Smart2nd = "2"
    local Smart3rd = "3"




    for i=1,40 do
        local BuffName,_,_,_,_,BuffDuration,BuffDurationLeft=UnitBuff("player",i)
        local DebuffName,_,_,_,_,DebuffDuration,DebuffDurationLeft=UnitDebuff("target",i)
        if BuffName then
			--[[  Clearcasting--]]
            if "Clearcasting" == BuffName then
                ClearCasting = 1
            end
            --[[  Shadowmeld--]]
            if "Shadowmeld" == BuffName then
                Shadowmeld = 1
            end
            --[[  Prowl--]]
            if "Prowl" == BuffName then
                StealthOpener = 1
            end
            --[[  Tiger's Fury--]]
            if "Tiger's Fury" == BuffName then
                TigersFuryTimer=format("%.2f",-1*(GetTime()-BuffDurationLeft))
            end
            --[[  Berskerk--]]
            if "Berserk" == BuffName then
                BerserkTimer=format("%.2f",-1*(GetTime()-BuffDurationLeft))
            end
            --[[  Incarnation: King of the Jungle--]]
            if "Incarnation: King of the Jungle" == BuffName then
                IncarnationTimer=format("%.2f",-1*(GetTime()-BuffDurationLeft))
                StealthOpener = 1
            end
            --[[  Savage Roar--]]
            if "Savage Roar" == BuffName then
                SavageRoarTimer=format("%.2f",-1*(GetTime()-BuffDurationLeft))
            end
            --[[  Rake--]]
            if "Rake" == DebuffName then
                RakeTimer=format("%.2f",-1*(GetTime()-DebuffDurationLeft));
            end
            --[[  Rip--]]
            if "Rip" == DebuffName then
                RipTimer=format("%.2f",-1*(GetTime()-DebuffDurationLeft))
            end
            --[[  Thrash--]]
            if "Thrash" == DebuffName then
                ThrashTimer=format("%.2f",-1*(GetTime()-DebuffDurationLeft));
            end
        end
    end
if (math.floor(SavageRoarTimer) == 0) and (StealthOpener == 0) then
		return string.format([[ Savage Roar ]])
end
if (math.floor(SavageRoarTimer) > 5) or (StealthOpener == 1) then
	if ComboPointsCurrent < 5 then
		if ComboPointsCurrent > 2 then
			if math.floor(RakeTimer) < 2 then
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														RipTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														RipTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED, Berserk in %.2f
														RAKE in %.2f ]],
														RipTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED, Berserk in %.2f
														RAKE in %.2f ]],
														RipTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													RIP after %.2f or SHRED, Tigers Fury in %.2f
													RAKE in %.2f ]],
													RipTimer,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													RIP after %.2f or SHRED
													RAKE in %.2f ]],
													RipTimer,
													RakeTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														EnergyTimeNeededFerociousBite,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														EnergyTimeNeededFerociousBite,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED, Berserk in %.2f
														RAKE in %.2f ]],
														EnergyTimeNeededFerociousBite,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED, Berserk in %.2f
														RAKE in %.2f ]],
														EnergyTimeNeededFerociousBite,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													FEROCIOUS BITE after %.2f or SHRED, Tigers Fury in %.2f
													RAKE in %.2f ]],
													EnergyTimeNeededFerociousBite,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													FEROCIOUS BITE after %.2f or SHRED
													RAKE in %.2f ]],
													EnergyTimeNeededFerociousBite,
													RakeTimer
												)
						end
					end
				end
			else
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														RipTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														RipTimer,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f
														SHRED ]],
														RipTimer,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f
														SHRED ]],
														RipTimer,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													RIP after %.2f or SHRED/RAKE, Tigers Fury in %.2f
													SHRED ]],
													RipTimer,
													TigersFuryCD
												)
						else
							return string.format([[
													RIP after %.2f or SHRED/RAKE
													SHRED ]],
													RipTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														EnergyTimeNeededFerociousBite,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														EnergyTimeNeededFerociousBite,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED/RAKE, Berserk in %.2f
														SHRED ]],
														EnergyTimeNeededFerociousBite,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														FEROCIOUS BITE after %.2f or SHRED/RAKE, Berserk in %.2f
														SHRED ]],
														EnergyTimeNeededFerociousBite,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													FEROCIOUS BITE in %.2f or SHRED/RAKE, Tigers Fury in %.2f
													SHRED ]],
													EnergyNeededFerociousBite,
													TigersFuryCD
												)
						else
							return string.format([[
													FEROCIOUS BITE in %.2f or SHRED/RAKE
													SHRED ]],
													EnergyNeededFerociousBite
												)
						end
					end
				end
			end
		else
			if math.floor(RakeTimer) < 2 then
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														RipTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														RipTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f
														Rake in %.2f ]],
														RipTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														RIP after %.2f or SHRED/RAKE, Berserk in %.2f
														Rake in %.2f ]],
														RipTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													SHRED, Tigers Fury in %.2f
													RAKE in %.2f ]],
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													SHRED
													RAKE in %.2f ]],
													RakeTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED,  Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														SHRED,  Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED,  Berserk in %.2f
														Rake in %.2f ]],
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														SHRED,  Berserk in %.2f
														Rake in %.2f ]],
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													SHRED, Tigers Fury in %.2f
													RAKE in %.2f ]],
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													SHRED
													RAKE in %.2f ]],
													RakeTimer
												)
						end
					end
				end
			else
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f
														SHRED ]],
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f
														SHRED ]],
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													SHRED/RAKE, Tigers Fury in %.2f
													SHRED ]],
													TigersFuryCD
												)
						else
							return string.format([[
													SHRED/RAKE,
													SHRED ]]
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f
														SHRED ]],
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f
														SHRED ]],
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														SHRED/RAKE,  Berserk in %.2f
														SHRED ]],
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													SHRED/RAKE, Tigers Fury in %.2f
													SHRED ]],
													TigersFuryCD
												)
						else
							return string.format([[
													SHRED/RAKE
													SHRED ]]
												)
						end
					end
				end
			end
		end
	else
		if math.floor(RakeTimer) < 2 then
			if math.floor(RipTimer) < 2 then
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													RIP in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													RipTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													RIP in %.2f ]],
													RakeTimer,
													BerserkCD,
													TigersFuryCD,
													RipTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													RIP in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													RipTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													RIP in %.2f ]],
													RakeTimer,
													BerserkCD,
													RipTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												RAKE after %.2f, Tigers Fury in %.2f
												RIP in %.2f ]],
												RakeTimer,
												TigersFuryCD,
												RipTimer
											)
					else
						return string.format([[
												RAKE after %.2f
												RIP in %.2f ]],
												RakeTimer,
												RipTimer
											)
					end
				end
			else
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													FEROCIOUS BITE in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													EnergyNeededFerociousBite
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													FEROCIOUS BITE in %.2f ]],
													RakeTimer,
													BerserkCD,
													TigersFuryCD,
													EnergyNeededFerociousBite
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													FEROCIOUS BITE in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													EnergyNeededFerociousBite
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													FEROCIOUS BITE in %.2f ]],
													RakeTimer,
													BerserkCD,
													EnergyNeededFerociousBite
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												RAKE after %.2f, Tigers Fury in %.2f
												FEROCIOUS BITE in %.2f ]],
												RakeTimer,
												TigersFuryCD,
												EnergyNeededFerociousBite
											)
					else
						return string.format([[
												RAKE after %.2f
												FEROCIOUS BITE in %.2f ]],
												RakeTimer,
												EnergyNeededFerociousBite
											)
					end
				end
			end
		else
			if math.floor(RipTimer) < 2 then
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													RIP in %.2f ]],
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													RipTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													RIP in %.2f ]],
													BerserkCD,
													TigersFuryCD,
													RipTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													RIP in %.2f ]],
													EnergyTimeNeededBerserk,
													RipTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													RIP in %.2f ]],
													BerserkCD,
													RipTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												SHRED/RAKE, Tigers Fury in %.2f
												RIP in %.2f ]],
												TigersFuryCD,
												RipTimer
											)
					else
						return string.format([[
												SHRED/RAKE
												RIP in %.2f ]],
												RipTimer
											)
					end
				end
			else
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													FEROCIOUS BITE in %.2f ]],
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													EnergyTimeNeededFerociousBite
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													FEROCIOUS BITE in %.2f ]],
													BerserkCD,
													TigersFuryCD,
													EnergyTimeNeededFerociousBite
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													FEROCIOUS BITE in %.2f ]],
													EnergyTimeNeededBerserk,
													EnergyTimeNeededFerociousBite
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													FEROCIOUS BITE in %.2f ]],
													BerserkCD,
													EnergyTimeNeededFerociousBite
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												SHRED/RAKE, Tigers Fury in %.2f
												FEROCIOUS BITE in %.2f ]],
												TigersFuryCD,
												EnergyTimeNeededFerociousBite
											)
					else
						return string.format([[
												SHRED/RAKE
												FEROCIOUS BITE in %.2f ]],
												EnergyTimeNeededFerociousBite
											)
					end
				end
			end
		end
	end
else
	if ComboPointsCurrent < 5 then
		if ComboPointsCurrent > 2 then
			if math.floor(RakeTimer) < 2 then
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													SavageRoarTimer after %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													RakeTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														RAKE in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													Savage Roar after %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													RakeTimer
												)
						end
					end
				end
			else
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													SHRED ]],
													SavageRoarTimer,
													TigersFuryCD
												)
						else
							return string.format([[
													Savage Roar after %.2f
													SHRED ]],
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar in %.2f, Tigers Fury in %.2f
													SHRED ]],
													SavageRoarTimer,
													TigersFuryCD
												)
						else
							return string.format([[
													Savage Roar in %.2f
													SHRED ]],
													SavageRoarTimer
												)
						end
					end
				end
			end
		else
			if math.floor(RakeTimer) < 2 then
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f, Berserk in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													Savage Roar after %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													RakeTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f, Tigers Fury in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD,
														RakeTimer
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														RakeTimer
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														Rake in %.2f ]],
														SavageRoarTimer,
														BerserkCD,
														RakeTimer
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													TigersFuryCD,
													RakeTimer
												)
						else
							return string.format([[
													Savage Roar after %.2f
													RAKE in %.2f ]],
													SavageRoarTimer,
													RakeTimer
												)
						end
					end
				end
			else
				if math.floor(RipTimer) < 2 then
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													SHRED ]],
													SavageRoarTimer,
													TigersFuryCD
												)
						else
							return string.format([[
													Savage Roar after %.2f,
													SHRED ]],
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(BerserkCD) < 5 then
						if math.floor(TigersFuryCD) < 2 then
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f, Tigers Fury in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk,
														TigersFuryCD
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD,
														TigersFuryCD
													)
                            end
						else
							if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														EnergyTimeNeededBerserk
													)
                            else
								return string.format([[
														Savage Roar after %.2f,  Berserk in %.2f
														SHRED ]],
														SavageRoarTimer,
														BerserkCD
													)
                            end
						end
					else
						if math.floor(TigersFuryCD) < 2 then
							return string.format([[
													Savage Roar after %.2f, Tigers Fury in %.2f
													SHRED ]],
													SavageRoarTimer,
													TigersFuryCD
												)
						else
							return string.format([[
													Savage Roar after %.2f
													SHRED ]],
													SavageRoarTimer
												)
						end
					end
				end
			end
		end
	else
		if math.floor(RakeTimer) < 2 then
			if math.floor(RipTimer) < 2 then
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													SavageRoarTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													BerserkCD,
													TigersFuryCD,
													SavageRoarTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													SavageRoarTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													BerserkCD,
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												RAKE after %.2f, Tigers Fury in %.2f
												Savage Roar in %.2f ]],
												RakeTimer,
												TigersFuryCD,
												SavageRoarTimer
											)
					else
						return string.format([[
												RAKE after %.2f
												Savage Roar in %.2f ]],
												RakeTimer,
												SavageRoarTimer
											)
					end
				end
			else
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													SavageRoarTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													BerserkCD,
													TigersFuryCD,
													SavageRoarTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													EnergyTimeNeededBerserk,
													SavageRoarTimer
												)
						else
							return string.format([[
													RAKE after %.2f, Berserk in %.2f
													Savage Roar in %.2f ]],
													RakeTimer,
													BerserkCD,
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												RAKE after %.2f, Tigers Fury in %.2f
												Savage Roar in %.2f ]],
												RakeTimer,
												TigersFuryCD,
												SavageRoarTimer
											)
					else
						return string.format([[
												RAKE after %.2f
												Savage Roar in %.2f ]],
												RakeTimer,
												SavageRoarTimer
											)
					end
				end
			end
		else
			if math.floor(RipTimer) < 2 then
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													SavageRoarTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													BerserkCD,
													TigersFuryCD,
													SavageRoarTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													Savage Roar in %.2f ]],
													EnergyTimeNeededBerserk,
													SavageRoarTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													Savage Roar in %.2f ]],
													BerserkCD,
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												SHRED/RAKE, Tigers Fury in %.2f
												Savage Roar in %.2f ]],
												TigersFuryCD,
												SavageRoarTimer
											)
					else
						return string.format([[
												SHRED/RAKE
												Savage Roar in %.2f ]],
												SavageRoarTimer
											)
					end
				end
			else
				if math.floor(BerserkCD) < 5 then
					if math.floor(TigersFuryCD) < 2 then
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													EnergyTimeNeededBerserk,
													TigersFuryCD,
													SavageRoarTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f, Tigers Fury in %.2f
													Savage Roar in %.2f ]],
													BerserkCD,
													TigersFuryCD,
													SavageRoarTimer
												)
						end
					else
						if math.floor(BerserkCD) < math.floor(EnergyTimeNeededBerserk) then
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													Savage Roar in %.2f ]],
													EnergyTimeNeededBerserk,
													SavageRoarTimer
												)
						else
							return string.format([[
													SHRED/RAKE, Berserk in %.2f
													Savage Roar in %.2f ]],
													BerserkCD,
													SavageRoarTimer
												)
						end
					end
				else
					if math.floor(TigersFuryCD) < 2 then
						return string.format([[
												SHRED/RAKE, Tigers Fury in %.2f
												Savage Roar in %.2f ]],
												TigersFuryCD,
												SavageRoarTimer
											)
					else
						return string.format([[
												SHRED/RAKE
												Savage Roar in %.2f ]],
												SavageRoarTimer
											)
					end
				end
			end
		end
	end
end

	return string.format ([[
    ShadowmeldCD: %.2f
    Tiger's Fury Timer: %.2f
    TigersFuryCD: %.2f
    BerserkCD: %.2f
    BerserkTimer: %.2f
    Incarnation Timer: %.2f
    IncarnationCD: %.2f
    Savage Roar: %.2f
    Rake: %.2f
    Rip: %.2f
    Thrash: %.2f
    Energy Current: %.f
    Energy Max: %.f
    EnergyNeededBerserk: %.f
    EnergyTimeNeededBerserk: %.2f
    ComboPointsCurrent: %.f
    ---------------
    Smart1st: %s
    Smart2nd: %s
    Smart3rd: %s
    StealthOpener: %.f]],
        ShadowmeldCD,
        TigersFuryTimer,
        TigersFuryCD,
        BerserkTimer,
        BerserkCD,
        IncarnationTimer,
        IncarnationCD,
        SavageRoarTimer,
        RakeTimer,
        RipTimer,
        ThrashTimer,
        EnergyCurrent,
        EnergyMax,
        EnergyNeededBerserk,
        EnergyTimeNeededBerserk,
        ComboPointsCurrent,
        Smart1st,
        Smart2nd,
        Smart3rd,
        StealthOpener
    )

end