-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6adccb9277c260065ce9e198"))()
	end)
end)
--[[rscripts:analytics:end]]

-- Kuchisake Radar: embedded runtime for guarded teleport reloads.
local source = [========[
return function(reloadSource, resume)
if game.GameId ~= 9199655655 then warn("Kuchisake Radar only runs in Gakuran"); return end
if not game:IsLoaded() then game.Loaded:Wait() end
local environment = (type(getgenv) == "function" and getgenv()) or _G
local compiler = assert(loadstring, "Kuchisake Radar requires loadstring")
local Rere
local previous = environment.__KuchisakeRadarRere
if type(previous) == "table" and type(previous.Stop) == "function" then previous:Stop() end
local app = {Alive = true, Connections = {}, Sounds = {}}
environment.__KuchisakeRadarRere = app
local function connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(app.Connections, connection)
    return connection
end

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Debris = game:GetService("Debris")
local LocalPlayer = Players.LocalPlayer or Players.PlayerAdded:Wait()

local function readServerMinutes()
    local world = ReplicatedStorage:FindFirstChild("World")
    local clock = world and world:FindFirstChild("MinutesOfDay")
    local value = clock and clock:IsA("NumberValue") and clock.Value
    if type(value) == "number" and value == value and value >= 0 and value < math.huge then return value % 1440 end
    return nil
end
app.InitialMinutes = readServerMinutes()

-- KUCHISAKE_AUTO_RELOAD_V1
do
    local HttpService = game:GetService("HttpService")
    local queue = queue_on_teleport or queueonteleport or (type(syn) == "table" and syn.queue_on_teleport)
    local path = "larp/config/KuchisakeRadar/AutoHop_" .. tostring(game.PlaceId) .. "_" .. tostring(LocalPlayer.UserId) .. ".json"
    local auto = {Enabled = resume == nil or resume.AutoEnabled == true, NextAttempt = 0, Status = "Auto: checking server time..."}
    app.Auto = auto
    auto.Ready = type(queue) == "function" and type(writefile) == "function" and type(readfile) == "function"
        and type(makefolder) == "function" and type(reloadSource) == "string" and #reloadSource > 0
    if not auto.Ready then
        auto.Enabled = false
        auto.Status = "Auto unavailable: teleport queue and writable workspace required"
    end
    local function inWindow(minutes) return minutes ~= nil and minutes >= 990 and minutes <= 1200 end
    function auto:Revoke()
        if not self.Nonce then return end
        local nonce = self.Nonce
        local ok, err = pcall(function()
            local record = HttpService:JSONDecode(readfile(path))
            if record.Nonce == nonce then
                record.Enabled = false
                writefile(path, HttpService:JSONEncode(record))
                local saved = HttpService:JSONDecode(readfile(path))
                assert(saved.Nonce == nonce and saved.Enabled == false, "reload cancellation was not saved")
            end
        end)
        if ok then self.Nonce = nil else warn("Kuchisake Radar: queued reload cancellation failed: " .. tostring(err)) end
    end
    function auto:Arm(id)
        assert(self.Ready, "Teleport queue and writable workspace required")
        self:Revoke()
        local nonce = HttpService:GenerateGUID(false)
        pcall(makefolder, "larp")
        pcall(makefolder, "larp/config")
        pcall(makefolder, "larp/config/KuchisakeRadar")
        local record = {Version = 1, Enabled = true, AutoEnabled = self.Enabled, Nonce = nonce,
            PlaceId = game.PlaceId, UserId = LocalPlayer.UserId, Destination = id, Origin = game.JobId, ExpiresAt = os.time() + 180,
            ServerListNextAt = app.Hop and app.Hop.NextRequestAt,
            AutoAttackEnabled = not app.Combat or app.Combat.Enabled,
            AutoParryEnabled = not app.Combat or app.Combat.ParryEnabled}
        self.Nonce = nonce
        writefile(path, HttpService:JSONEncode(record))
        local saved = HttpService:JSONDecode(readfile(path))
        assert(saved.Nonce == nonce and saved.Enabled == true, "reload state was not saved")
        -- Old queued attempts are inert: only the current nonce, account, place and destination may resume.
        local code = string.format([==[
if game.PlaceId ~= %d then return end
if not game:IsLoaded() then game.Loaded:Wait() end
local players = game:GetService("Players")
local player = players.LocalPlayer or players.PlayerAdded:Wait()
if player.UserId ~= %d or game.JobId ~= %q then return end
local service = game:GetService("HttpService")
local ok, record = pcall(function() return service:JSONDecode(readfile(%q)) end)
if not ok or type(record) ~= "table" or record.Version ~= 1 or record.Enabled ~= true
    or record.Nonce ~= %q or record.PlaceId ~= game.PlaceId or record.UserId ~= player.UserId
    or record.Destination ~= game.JobId or record.Origin == game.JobId
    or type(record.ExpiresAt) ~= "number" or record.ExpiresAt ~= record.ExpiresAt
    or record.ExpiresAt == math.huge or record.ExpiresAt < os.time() then return end
record.Enabled = false
local consumed = pcall(function()
    local path = %q
    writefile(path, service:JSONEncode(record))
    local saved = service:JSONDecode(readfile(path))
    assert(saved.Nonce == record.Nonce and saved.Enabled == false)
end)
if not consumed then return end
local source = %q
local factory = assert(loadstring(source, "KuchisakeRadar/Reload"))()
return factory(source, {AutoEnabled = record.AutoEnabled == true, ServerListNextAt = record.ServerListNextAt,
    AutoAttackEnabled = record.AutoAttackEnabled ~= false, AutoParryEnabled = record.AutoParryEnabled ~= false})
]==], game.PlaceId, LocalPlayer.UserId, id, path, nonce, path, reloadSource)
        queue(code)
    end
    function auto:SetEnabled(enabled)
        self.Enabled = enabled == true and self.Ready
        self.NextAttempt = 0
        if not self.Enabled then
            self:Revoke()
            if app.Hop and app.Hop.Automatic then app.Hop:Stop() end
            self.Status = self.Ready and "Auto: off" or "Auto unavailable: teleport queue and writable workspace required"
        end
    end
    function auto:Stop()
        self.Enabled = false
        self:Revoke()
        self.Status = "Auto: stopped"
    end
    function auto:AllowHop()
        local minutes = readServerMinutes()
        return self.Enabled and minutes ~= nil and not inWindow(minutes)
            and not (app.Combat and app.Combat:HasTarget())
    end
    function auto:Tick()
        if not app.Alive or not self.Enabled then return end
        if app.Combat and app.Combat.ScanTarget then app.Combat:ScanTarget() end
        if not app.Alive or not self.Enabled then return end
        if app.Combat and app.Combat:HasTarget() then
            self.Status = "Auto: staying (combat target active)"
            if app.Hop.Busy and app.Hop.Automatic and not app.Hop.Pending then app.Hop:Stop() end
            return
        end
        local minutes = readServerMinutes()
        if minutes == nil then self.Status = "Auto: waiting for server clock"; return end
        if inWindow(minutes) then
            self.Status = "Auto: staying (16:30-20:00)"
            if app.Hop.Busy and app.Hop.Automatic and not app.Hop.Pending then app.Hop:Stop() end
            return
        end
        if not app.Hop.Busy and os.clock() < self.NextAttempt then
            self.Status = "Auto: retry in " .. tostring(math.ceil(self.NextAttempt - os.clock())) .. "s"
            return
        end
        self.Status = "Auto: outside 16:30-20:00; finding another server"
        if not app.Hop.Busy and os.clock() >= self.NextAttempt then app.Hop:Start(true) end
    end
end
-- KUCHISAKE_AUTO_RELOAD_END

-- KUCHISAKE_MANUAL_SERVER_HOP_V1
do
    local HttpService = game:GetService("HttpService")
    local TeleportService = game:GetService("TeleportService")
    local historyKey = tostring(game.PlaceId) .. "_" .. tostring(LocalPlayer.UserId)
    local historyPath = "larp/config/KuchisakeRadar/ServerHistory_" .. historyKey .. ".json"
    local memory = environment.__KuchisakeRadarHopHistory
    if type(memory) ~= "table" then memory = {}; environment.__KuchisakeRadarHopHistory = memory end
    if type(memory[historyKey]) ~= "table" then memory[historyKey] = {} end
    local hop = {Busy = false, Epoch = 0, Visited = memory[historyKey], Status = "Server hop: ready", StorageNote = "memory only"}
    app.Hop = hop
    local requestApi = request or http_request or (type(http) == "table" and http.request)
    local rate = environment.__KuchisakeRadarServerApi
    if type(rate) ~= "table" then rate = {}; environment.__KuchisakeRadarServerApi = rate end
    local function finiteDelay(value)
        return type(value) == "number" and value == value and value >= 0 and value < math.huge
    end
    if not finiteDelay(rate.NextRequestAt) then rate.NextRequestAt = 0 end
    if not finiteDelay(rate.Failures) then rate.Failures = 0 end
    if resume and finiteDelay(resume.ServerListNextAt) then
        rate.NextRequestAt = math.max(rate.NextRequestAt, math.min(resume.ServerListNextAt, os.time() + 300))
    end
    hop.NextRequestAt = rate.NextRequestAt
    local function deferRequest(seconds)
        rate.NextRequestAt = math.max(rate.NextRequestAt, os.time() + seconds)
        hop.NextRequestAt = rate.NextRequestAt
    end
    local function validId(id) return type(id) == "string" and #id > 0 and #id <= 128 end
    local function active(epoch) return app.Alive and hop.Busy and hop.Epoch == epoch end
    local function cancel(thread)
        if thread and thread ~= coroutine.running() and type(task.cancel) == "function" then pcall(task.cancel, thread) end
    end
    function hop:Finish(text)
        if app.Auto and self.Pending then app.Auto:Revoke() end
        self.Busy = false
        self.Pending = nil
        self.Status = text
        cancel(self.Timeout)
        cancel(self.RequestTimeout)
        cancel(self.Thread)
        self.Timeout, self.RequestTimeout, self.Thread = nil, nil, nil
        if app.Auto then app.Auto.NextAttempt = os.clock() + math.max(5, rate.NextRequestAt - os.time()) end
    end
    function hop:Stop()
        self.Epoch += 1
        self:Finish("Server hop: stopped")
    end
    local function loadHistory()
        if type(isfile) ~= "function" or type(readfile) ~= "function" then return end
        local ok, exists = pcall(isfile, historyPath)
        if not ok then error("Cannot check saved server history") end
        if not exists then return end
        local bytes = readfile(historyPath)
        if type(bytes) ~= "string" or #bytes > 2 * 1024 * 1024 then error("Saved server history is too large") end
        local saved = HttpService:JSONDecode(bytes)
        if type(saved) ~= "table" or saved.Version ~= 1 or saved.PlaceId ~= game.PlaceId
            or saved.UserId ~= LocalPlayer.UserId or type(saved.Visited) ~= "table" then error("Invalid saved server history") end
        for id, stamp in pairs(saved.Visited) do
            if not validId(id) or type(stamp) ~= "number" or stamp ~= stamp or stamp <= 0 or stamp == math.huge then
                error("Invalid saved server history entry")
            end
        end
        for id, stamp in pairs(saved.Visited) do hop.Visited[id] = stamp end
    end
    local historyOk, historyError = pcall(loadHistory)
    if not historyOk then
        hop.HistoryError = "Server hop disabled: " .. tostring(historyError):sub(1,160)
        hop.Status = hop.HistoryError
    end
    if validId(game.JobId) then hop.Visited[game.JobId] = os.time() end
    if historyOk and type(writefile) == "function" and type(makefolder) == "function" then
        local saved = pcall(function()
            pcall(makefolder, "larp")
            pcall(makefolder, "larp/config")
            pcall(makefolder, "larp/config/KuchisakeRadar")
            writefile(historyPath, HttpService:JSONEncode({Version = 1, PlaceId = game.PlaceId, UserId = LocalPlayer.UserId, Visited = hop.Visited}))
        end)
        if saved then hop.StorageNote = "history saved" end
    end
    local function awaitRequest(epoch)
        while active(epoch) and os.time() < rate.NextRequestAt do
            hop.Status = "Server hop: API cooldown " .. tostring(math.ceil(rate.NextRequestAt - os.time())) .. "s"
            task.wait(math.min(1, rate.NextRequestAt - os.time()))
        end
        if not active(epoch) then return false end
        -- The native endpoint advertises 3 requests/minute; preserve pacing across queued reloads.
        deferRequest(22)
        return true
    end
    local function apiFailure(message, retryAfter)
        rate.Failures = math.min(rate.Failures + 1, 4)
        local delay = math.max(math.min(60 * 2 ^ (rate.Failures - 1), 300), retryAfter or 0)
        deferRequest(delay)
        error(message .. "; retry in " .. tostring(math.ceil(delay)) .. "s", 0)
    end
    local function fetchPage(url, epoch)
        if not awaitRequest(epoch) then return nil end
        local function callWithTimeout(callback)
            local timer = task.delay(30, function()
                if active(epoch) then hop:Finish("Server hop: HTTP timed out; retry later") end
            end)
            hop.RequestTimeout = timer
            local ok, response = pcall(callback)
            cancel(timer)
            if hop.RequestTimeout == timer then hop.RequestTimeout = nil end
            return ok, response
        end
        local body, status, headers
        if type(requestApi) == "function" then
            local ok, response = callWithTimeout(function() return requestApi({Url = url, Method = "GET"}) end)
            if not active(epoch) then return nil end
            if ok and type(response) == "table" and type(response.Body) == "string" then
                body, status, headers = response.Body, tonumber(response.StatusCode), response.Headers
            else
                -- Some executors reject Roblox URLs in request(); retain HttpGet compatibility, paced too.
                if not awaitRequest(epoch) then return nil end
            end
        end
        if not body then
            local ok, response = callWithTimeout(function() return game:HttpGet(url, false) end)
            if not active(epoch) then return nil end
            if not ok then apiFailure("Server list HTTP failed: " .. tostring(response):sub(1, 120)) end
            body = response
        end
        local normalized = {}
        if type(headers) == "table" then
            for key, value in pairs(headers) do normalized[string.lower(tostring(key))] = tostring(value) end
        end
        local retryAfter = tonumber(normalized["retry-after"])
        local reset = tonumber(normalized["x-ratelimit-reset"])
        if not finiteDelay(retryAfter) then retryAfter = nil end
        if not finiteDelay(reset) then reset = nil end
        if tonumber(normalized["x-ratelimit-remaining"]) == 0 and reset then deferRequest(math.min(reset + 1, 300)) end
        if status and (status < 200 or status >= 300) then
            apiFailure("Server list HTTP " .. tostring(status), math.min(math.max(retryAfter or 0, reset or 0), 300))
        end
        local ok, response = pcall(function() return HttpService:JSONDecode(body) end)
        if not ok or type(response) ~= "table" then apiFailure("Server list returned invalid JSON") end
        if type(response.data) ~= "table" then
            local detail = "missing data"
            if type(response.errors) == "table" then
                local first = response.errors[1]
                if type(first) == "table" then
                    local message = tostring(first.message or ""):gsub("[%c]", " "):sub(1, 100)
                    detail = "Roblox API error " .. tostring(first.code or "unknown") .. (message ~= "" and (": " .. message) or " (empty message)")
                end
            end
            apiFailure("Server list: " .. detail)
        end
        rate.Failures = 0
        return response
    end
    local function findLowest(epoch)
        local pool, bestCount, cursor, seenCursors, seenIds = {}, math.huge, nil, {}, {}
        for page = 1, 25 do
            if not active(epoch) then return nil end
            hop.Status = "Server hop: searching (page " .. tostring(page) .. ")..."
            local url = "https://games.roblox.com/v1/games/" .. tostring(game.PlaceId) .. "/servers/Public?sortOrder=Asc&limit=100"
            if cursor then url ..= "&cursor=" .. HttpService:UrlEncode(cursor) end
            local response = fetchPage(url, epoch)
            if not active(epoch) then return nil end
            local passedLowest = false
            for _, server in ipairs(response.data) do
                if type(server) == "table" then
                    local count, capacity, id = server.playing, server.maxPlayers, server.id
                    if type(count) == "number" and count == count and count >= 0 and count < math.huge and count % 1 == 0
                        and type(capacity) == "number" and capacity > count and capacity < math.huge and capacity % 1 == 0
                        and validId(id) and id ~= game.JobId and not hop.Visited[id] and not seenIds[id] then
                        seenIds[id] = true
                        if count < bestCount then bestCount = count; table.clear(pool) end
                        if count == bestCount then table.insert(pool, id) end
                    end
                    if type(count) == "number" and bestCount < math.huge and count > bestCount then passedLowest = true end
                end
            end
            local nextCursor = response.nextPageCursor
            if nextCursor == "" then nextCursor = nil end
            if nextCursor ~= nil and (type(nextCursor) ~= "string" or #nextCursor > 2048) then error("Invalid server list cursor") end
            -- Ascending population order lets us stop after the entire lowest eligible group.
            if not nextCursor or (#pool > 0 and passedLowest) then
                if #pool == 0 then return nil end
                return pool[math.random(1, #pool)], bestCount, #pool
            end
            if seenCursors[nextCursor] then error("Server list repeated a page") end
            seenCursors[nextCursor], cursor = true, nextCursor
            task.wait(0.2)
        end
        error("Search limit reached; click again later")
    end
    function hop:Start(automatic)
        if not app.Alive or self.Busy then return false end
        if app.Auto and not app.Auto.Ready then self.Status = app.Auto.Status; return false end
        if automatic and app.Auto and not app.Auto:AllowHop() then return false end
        if self.HistoryError then self.Status = self.HistoryError; return false end
        self.Automatic = automatic == true
        self.Epoch += 1
        local epoch = self.Epoch
        self.Busy = true
        self.Status = "Server hop: searching..."
        self.Timeout = task.delay(660, function()
            if active(epoch) then self:Finish("Server hop: search timed out; click to retry") end
        end)
        self.Thread = task.defer(function()
            local ok, err = pcall(function()
                local id, count = findLowest(epoch)
                if not active(epoch) then return end
                if self.Automatic and app.Auto and not app.Auto:AllowHop() then self:Finish("Server hop: time window reached / auto stopped"); return end
                if not id then self:Finish("Server hop: no unvisited public server available"); return end
                self.Pending = id
                self.Status = string.format("Server hop: joining %d-player server...", count)
                cancel(self.Timeout)
                self.Timeout = task.delay(20, function()
                    if active(epoch) then self:Finish("Server hop: teleport timed out; click to retry") end
                end)
                if app.Auto then app.Auto:Arm(id) end
                if not active(epoch) or (self.Automatic and app.Auto and not app.Auto:AllowHop()) then
                    self:Finish("Server hop: cancelled before teleport"); return
                end
                TeleportService:TeleportToPlaceInstance(game.PlaceId, id, LocalPlayer)
            end)
            if not ok and active(epoch) then self:Finish("Server hop failed: " .. tostring(err):sub(1,160)) end
            if self.Thread == coroutine.running() then self.Thread = nil end
        end)
        return true
    end
    connect(TeleportService.TeleportInitFailed, function(player, _, message, placeId, options)
        if player ~= LocalPlayer or not hop.Pending or (placeId and placeId ~= game.PlaceId) then return end
        if options then
            local ok, id = pcall(function() return options.ServerInstanceId end)
            if ok and validId(id) and id ~= hop.Pending then return end
        end
        hop:Finish("Server hop failed: " .. tostring(message):sub(1,160))
    end)
    connect(LocalPlayer.OnTeleport, function(state)
        if hop.Pending and state == Enum.TeleportState.Failed then hop:Finish("Server hop failed; click to retry") end
    end)
end
-- KUCHISAKE_MANUAL_SERVER_HOP_END

local function getMinutesOfDay()
    return readServerMinutes() or 0
end

local function formatClock(min)
    local h = math.floor(min / 60) % 24
    local m = math.floor(min % 60)
    return string.format("%02d:%02d", h, m)
end

local function isPrivateServer()
    return game.PrivateServerId ~= "" and game.PrivateServerOwnerId ~= 0
end

local Status = {Text = "Status: Initializing...", TextColor3 = Color3.fromRGB(220, 220, 220)}
local ClockLabel = {Text = "In-game Time: --:--", TextColor3 = Color3.fromRGB(180, 180, 190)}
local TargetLabel = {Text = "Targets: Scanning (HP >= 200)...", TextColor3 = Color3.fromRGB(255, 200, 50)}
local HealthLabel = {Text = "Boss HP: None Active", TextColor3 = Color3.fromRGB(120, 220, 255)}
local UIStroke = {}
app.View = {Status = Status, Clock = ClockLabel, Targets = TargetLabel, Health = HealthLabel}

local function createAlertBeep()
    local s = Instance.new("Sound")
    s.SoundId = "rbxassetid://9120839174"
    s.Volume = 1
    s.Parent = workspace
    app.Sounds[s] = true
    Debris:AddItem(s, 15)
    s:Play()
    local ended
    ended = connect(s.Ended, function()
        app.Sounds[s] = nil
        ended:Disconnect()
        s:Destroy()
    end)
end

local trackedEntities = {}

local function removeTracked(model)
    local data = trackedEntities[model]
    if data then
        if data.Highlight and data.Highlight.Parent then
            data.Highlight:Destroy()
        end
        if data.Billboard and data.Billboard.Parent then
            data.Billboard:Destroy()
        end
        trackedEntities[model] = nil
    end
end

function app:Stop()
    if not self.Alive then return end
    self.Alive = false
    if self.Combat then self.Combat:Stop() end
    if self.Auto then self.Auto:Stop() end
    if self.Hop then self.Hop:Stop() end
    for _, connection in ipairs(self.Connections) do pcall(function() connection:Disconnect() end) end
    table.clear(self.Connections)
    local models = {}
    for model in pairs(trackedEntities) do table.insert(models, model) end
    for _, model in ipairs(models) do removeTracked(model) end
    for sound in pairs(self.Sounds) do pcall(function() sound:Destroy() end) end
    table.clear(self.Sounds)
    if Rere then pcall(Rere.Shutdown) end
    if environment.__KuchisakeRadarRere == self then environment.__KuchisakeRadarRere = nil end
end

local function addOrUpdateTracked(model, reason, targetPlayer)
    local hum = model:FindFirstChild("Humanoid")
    if not hum or hum.MaxHealth < 200 or hum.Health <= 0 then
        removeTracked(model)
        return
    end

    local data = trackedEntities[model]
    local targetName = targetPlayer and targetPlayer.Name or "Unknown"

    if not data then
        createAlertBeep()

        local hl = Instance.new("Highlight")
        hl.Name = "KuchisakeTrackerHL"
        hl.FillColor = Color3.fromRGB(255, 20, 60)
        hl.OutlineColor = Color3.fromRGB(255, 255, 255)
        hl.FillTransparency = 0.35
        hl.OutlineTransparency = 0
        hl.Adornee = model
        hl.Parent = model

        local bb = nil
        local hrp = model:FindFirstChild("HumanoidRootPart") or model:FindFirstChild("Head") or model.PrimaryPart
        if hrp then
            bb = Instance.new("BillboardGui")
            bb.Name = "KuchisakeTrackerBB"
            bb.Size = UDim2.fromOffset(220, 60)
            bb.AlwaysOnTop = true
            bb.Adornee = hrp
            bb.StudsOffset = Vector3.new(0, 3.5, 0)

            local t = Instance.new("TextLabel")
            t.Name = "TagText"
            t.Size = UDim2.fromScale(1, 1)
            t.BackgroundTransparency = 1
            t.Font = Enum.Font.GothamBold
            t.TextSize = 13
            t.TextColor3 = Color3.fromRGB(255, 40, 40)
            t.TextStrokeTransparency = 0.2
            t.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            t.Text = string.format("⚠ KUCHISAKE-ONNA ⚠\n[NPC: %s]\nTARGET: %s", model.Name, targetName)
            t.Parent = bb
            bb.Parent = model
        end

        trackedEntities[model] = {
            Highlight = hl,
            Billboard = bb,
            TargetPlayer = targetPlayer,
            Reason = reason
        }
    else
        data.TargetPlayer = targetPlayer or data.TargetPlayer
        data.Reason = reason or data.Reason
        if data.Billboard then
            local t = data.Billboard:FindFirstChild("TagText")
            if t then
                t.Text = string.format("⚠ KUCHISAKE-ONNA ⚠\n[NPC: %s]\nTARGET: %s", model.Name, targetName)
            end
        end
    end
end

local function inspectModel(model)
    if not model or not model:IsA("Model") then
        return false, nil
    end
    local hum = model:FindFirstChild("Humanoid")
    if not hum or hum.MaxHealth < 200 or hum.Health <= 0 then
        return false, nil
    end

    local faction = tostring(model:GetAttribute("FactionId") or "")
    if faction:find("Kuchisake") or faction:find("SE_") then
        return true, "Faction=" .. faction
    end

    if model:GetAttribute("CanFight") == true then
        local baseSpeed = tonumber(model:GetAttribute("BaseWalkSpeed")) or 0
        if baseSpeed >= 20 or hum.MaxHealth >= 300 then
            return true, string.format("HP=%.0f Spd=%d", hum.MaxHealth, baseSpeed)
        end
    end
    return false, nil
end

-- KUCHISAKE_COMBAT_V1
do
    local combat = {Enabled = not resume or resume.AutoAttackEnabled ~= false,
        ParryEnabled = not resume or resume.AutoParryEnabled ~= false,
        Status = "Combat: looking for NPC (Max HP 355-375)", NextAttack = 0, NextEquip = 0,
        NextScan = 0, NextMove = 0, NextBlock = 0, BlockAttempts = 0, Parries = 0,
        AnimationIds = {}, Modules = {}}
    app.Combat = combat
    local function rootOf(model)
        return model and (model:FindFirstChild("HumanoidRootPart") or model.PrimaryPart)
    end
    local function alive(model)
        local humanoid = model and model.Parent and model:FindFirstChildOfClass("Humanoid")
        return humanoid and humanoid.Health > 0 and rootOf(model) ~= nil
    end
    local function eligible(model)
        if not model or not model:IsA("Model") or model == LocalPlayer.Character
            or Players:GetPlayerFromCharacter(model) then return false end
        local humanoid = model:FindFirstChildOfClass("Humanoid")
        return alive(model) and humanoid.MaxHealth >= 355 and humanoid.MaxHealth <= 375
            and inspectModel(model)
    end
    function combat:HasTarget() return self.Enabled and alive(self.Target) == true end
    local function getModule(name)
        local character = LocalPlayer.Character
        local data = character and character:FindFirstChild("PlayerData")
        local combatType = data and data:GetAttribute("CombatType") or "Base"
        local key = tostring(combatType) .. "/" .. name
        if combat.Modules[key] then return combat.Modules[key] end
        local system = ReplicatedStorage:FindFirstChild("CombatSystemClient")
        local folder = system and system:FindFirstChild("Combat")
        folder = folder and (folder:FindFirstChild(combatType) or folder:FindFirstChild("Base"))
        local module = folder and folder:FindFirstChild(name)
        if not module then return nil end
        local ok, value = pcall(require, module)
        if ok and type(value) == "table" then combat.Modules[key] = value; return value end
    end
    local function sharedModule(folderName, name)
        local shared = ReplicatedStorage:FindFirstChild("Shared")
        local folder = shared and shared:FindFirstChild(folderName)
        local module = folder and folder:FindFirstChild(name)
        if not module then return nil end
        local ok, value = pcall(require, module)
        return ok and type(value) == "table" and value or nil
    end
    local function unblock()
        local owned = combat.BlockOwner
        combat.BlockOwner, combat.BlockUntil = nil, nil
        if owned and owned.Character == LocalPlayer.Character and type(owned.Module.Unblock) == "function" then
            pcall(owned.Module.Unblock)
        end
    end
    local function stopMove()
        local humanoid = combat.MoveOwner
        combat.MoveOwner = nil
        if humanoid and humanoid.Parent and LocalPlayer.Character == humanoid.Parent then
            local root = rootOf(humanoid.Parent)
            if root then pcall(humanoid.MoveTo, humanoid, root.Position) end
        end
    end
    function combat:ClearTarget()
        if self.Thread and self.Thread ~= coroutine.running() and type(task.cancel) == "function" then
            pcall(task.cancel, self.Thread)
            self.Thread, self.Running = nil, false
        end
        unblock(); stopMove()
        self.Target, self.TargetHumanoid = nil, nil
        table.clear(self.AnimationIds)
    end
    function combat:Stop()
        self.Enabled = false
        self:ClearTarget()
        self.Status = "Combat: off"
    end
    function combat:SetEnabled(value)
        if not value then self:Stop(); return end
        self.Enabled, self.NextScan = true, 0
        self.Status = "Combat: looking for NPC (Max HP 355-375)"
    end
    function combat:SetParry(value)
        self.ParryEnabled = value == true
        if not self.ParryEnabled then unblock() end
    end
    local function buildAnimations(model)
        table.clear(combat.AnimationIds)
        combat.Config = sharedModule("Config", "CombatConfig")
        combat.AnimationUtils = sharedModule("Utils", "CombatAnimationUtils")
        local utils = combat.AnimationUtils
        if not utils or type(utils.GetCombatStyleForCharacter) ~= "function"
            or type(utils.GetCombatAnimsFolderForCharacter) ~= "function" then return end
        local ok, style = pcall(utils.GetCombatStyleForCharacter, model)
        if ok and type(style) == "string" then combat.Style = string.lower(style) end
        local good, folder = pcall(utils.GetCombatAnimsFolderForCharacter, model)
        if not good or not folder then return end
        local names = {["1stm1"] = 1, ["2ndm1"] = 2, ["3rdm1"] = 3, ["4thm1"] = 4}
        for _, animation in ipairs(folder:GetDescendants()) do
            if animation:IsA("Animation") then
                local name = string.lower(animation.Name)
                local index = names[name]
                if index or name == "m2" then
                    local id = tostring(animation.AnimationId):match("%d+")
                    if id then combat.AnimationIds[id] = {Index = index, Heavy = name == "m2"} end
                end
            end
        end
    end
    local function acquire(now, root)
        if now < combat.NextScan then return end
        combat.NextScan = now + 0.5
        local nearest, distance = nil, math.huge
        local function consider(model)
            if eligible(model) then
                local delta = (rootOf(model).Position - root.Position).Magnitude
                if delta < distance then nearest, distance = model, delta end
            end
        end
        local folder = workspace:FindFirstChild("NPCs")
        if folder then for _, model in ipairs(folder:GetChildren()) do consider(model) end end
        for _, model in ipairs(workspace:GetChildren()) do consider(model) end
        if nearest then
            combat.Target, combat.TargetHumanoid = nearest, nearest:FindFirstChildOfClass("Humanoid")
            buildAnimations(nearest)
        end
    end
    function combat:ScanTarget()
        if not app.Alive or not self.Enabled then return end
        if self.Target and not alive(self.Target) then self:ClearTarget() end
        local character = LocalPlayer.Character
        local humanoid = character and character:FindFirstChildOfClass("Humanoid")
        local root = rootOf(character)
        if not self.Target and humanoid and humanoid.Health > 0 and root then acquire(os.clock(), root) end
    end
    local function blocked(character, attack)
        for _, name in ipairs({"Stunned", "GuardBroken", "Downed", "Ragdoll", "Grappling", "GrappleWinnerStun",
            "CantAnything", "SpecTimeSlowed", "Greenzone", "RpCombatLocked", "StaffModPeaceMode"}) do
            if character:GetAttribute(name) then return true end
        end
        for _, name in ipairs({"M1", "M2", "PendingM2", "CombatAttacking", "ParryAttackLockout", "BlockAttackLockout"}) do
            if character:GetAttribute(name) then return true end
        end
        return attack and (character:GetAttribute("Blocking") == true or character:GetAttribute("PerfectBlocking") == true)
    end
    local function delays(info)
        local cfg, style = combat.Config, combat.Style
        if not cfg or not style then return nil end
        if not info.Heavy and type(cfg.GetScaledStyleM1HitboxDelay) == "function" then
            local ok, value = pcall(cfg.GetScaledStyleM1HitboxDelay, style, info.Index, 1)
            if ok and type(value) == "number" and value > 0 then return {value} end
        elseif info.Heavy and type(cfg.GetStyleM2HitboxDelay) == "function" and type(cfg.GetScaledHitboxDelay) == "function" then
            local raw
            if type(cfg.GetStyleM2MultiHitDelays) == "function" then
                local ok, values = pcall(cfg.GetStyleM2MultiHitDelays, style)
                if ok and type(values) == "table" and #values > 0 then raw = values end
            end
            if not raw then
                local ok, value = pcall(cfg.GetStyleM2HitboxDelay, style)
                if ok and type(value) == "number" then raw = {value} end
            end
            local result = {}
            for _, value in ipairs(raw or {}) do
                local ok, scaled = pcall(cfg.GetScaledHitboxDelay, value, 1)
                if ok and type(scaled) == "number" and scaled > 0 then table.insert(result, scaled) end
            end
            if #result > 0 then return result end
        end
    end
    local function incoming(humanoid)
        local animator = humanoid:FindFirstChildOfClass("Animator")
        local fallback = combat.Target:GetAttribute("M1") or combat.Target:GetAttribute("M2")
            or combat.Target:GetAttribute("CombatAttacking")
        local known, future, due = false, false, false
        local pingOk, ping = pcall(LocalPlayer.GetNetworkPing, LocalPlayer)
        local cfg = combat.Config
        local window = cfg and cfg.Block and cfg.Block.PerfectBlockWindow or 0.125
        local lead = math.clamp((pingOk and ping or 0) * 2 + window * 0.5, 0.05, 0.22)
        for _, track in ipairs(animator and animator:GetPlayingAnimationTracks() or {}) do
            local id = track.Animation and tostring(track.Animation.AnimationId):match("%d+")
            local info = id and combat.AnimationIds[id]
            if info and track.IsPlaying and track.Speed > 0 then
                local times = delays(info)
                if times then
                    known = true
                    for _, delay in ipairs(times) do
                        local remaining = (delay - track.TimePosition) / track.Speed
                        if remaining >= -window then
                            future = true
                            if remaining <= lead then due = true end
                        end
                    end
                end
            end
        end
        return due or (not known and fallback == true), future or fallback == true, not known and fallback == true
    end
    function combat:Step(now)
        if not app.Alive or not self.Enabled then return end
        if app.Hop and app.Hop.Pending then self:ClearTarget(); self.Status = "Combat: waiting for teleport"; return end
        local character = LocalPlayer.Character
        local humanoid = character and character:FindFirstChildOfClass("Humanoid")
        local root = rootOf(character)
        if not humanoid or humanoid.Health <= 0 or not root then self:ClearTarget(); self.Status = "Combat: waiting for character"; return end
        if self.Target and not alive(self.Target) then self:ClearTarget() end
        if not self.Target then acquire(now, root) end
        if not app.Alive or not self.Enabled or character ~= LocalPlayer.Character then self:ClearTarget(); return end
        if not self.Target then self.Status = "Combat: looking for NPC (Max HP 355-375)"; return end
        self.TargetHumanoid = self.Target:FindFirstChildOfClass("Humanoid")
        local targetRoot = rootOf(self.Target)
        local delta = targetRoot.Position - root.Position
        local distance = delta.Magnitude
        if character:GetAttribute("Equip") ~= true then
            self.Status = "Combat: equipping stance"
            if now >= self.NextEquip then
                self.NextEquip = now + 2
                local remote = sharedModule("Network", "CombatRemoteClient")
                if remote and type(remote.Fire) == "function" and app.Alive and self.Enabled
                    and character == LocalPlayer.Character then pcall(remote.Fire, "Equip", "Equip") end
            end
            return
        end
        if self.BlockUntil and now >= self.BlockUntil then unblock() end
        if blocked(character, false) then stopMove(); self.Status = "Combat: waiting for native recovery"; return end
        if distance > 5 then
            unblock()
            self.Status = "Combat: approaching " .. self.Target.Name
            if now >= self.NextMove then
                self.NextMove = now + 0.3
                local away = root.Position - targetRoot.Position
                away = Vector3.new(away.X, 0, away.Z)
                local goal = targetRoot.Position + (away.Magnitude > 0.01 and away.Unit * 4 or Vector3.new(0, 0, 4))
                humanoid:MoveTo(goal); self.MoveOwner = humanoid
            end
        else stopMove() end
        local flat = Vector3.new(targetRoot.Position.X, root.Position.Y, targetRoot.Position.Z)
        if (flat - root.Position).Magnitude > 0.01 then root.CFrame = CFrame.lookAt(root.Position, flat) end
        local towardUs = root.Position - targetRoot.Position
        local facingUs = towardUs.Magnitude < 0.01 or targetRoot.CFrame.LookVector:Dot(towardUs.Unit) > 0
        local due, threat, unknown = incoming(self.TargetHumanoid)
        if self.ParryEnabled and distance <= 10 and facingUs and (due or self.BlockOwner) then
            stopMove()
            if not self.BlockOwner and due and now >= self.NextBlock and character:GetAttribute("Blocking") ~= true then
                local module = getModule("Block")
                if module and type(module.Block) == "function" and app.Alive and self.Enabled and self.ParryEnabled
                    and character == LocalPlayer.Character and alive(self.Target) then
                    self.NextBlock = now + (self.Config and self.Config.Block and self.Config.Block.CooldownSeconds or 0.5)
                    self.BlockOwner, self.BlockUntil = {Character = character, Module = module}, now + 0.22
                    local ok, err = pcall(module.Block)
                    if not ok then unblock(); self.Status = "Combat: Block error " .. tostring(err):sub(1, 90); return end
                    self.BlockAttempts += 1
                    if character:GetAttribute("Blocking") ~= true then self.BlockOwner, self.BlockUntil = nil, nil end
                end
            end
            self.Status = unknown and "Combat: guarding (unknown NPC windup)" or "Combat: parry attempt"
            return
        end
        if self.BlockOwner then self.Status = "Combat: guarding"; return end
        if self.ParryEnabled and threat and distance <= 10 and facingUs then
            self.Status = "Combat: waiting for incoming hit"; return
        end
        if distance > 5 or math.abs(delta.Y) > 5 or blocked(character, true) then return end
        if now >= self.NextAttack then
            self.NextAttack = now + 0.18
            local module = getModule("M1")
            if not module or type(module.OnM1Activated) ~= "function" then self.Status = "Combat: M1 module unavailable"; return end
            if not app.Alive or not self.Enabled or character ~= LocalPlayer.Character or not alive(self.Target) then return end
            local ok, err = pcall(module.OnM1Activated)
            self.Status = ok and ("Combat: attacking " .. self.Target.Name) or ("Combat: M1 error " .. tostring(err):sub(1, 90))
        end
    end
    local elapsed = 0
    connect(RunService.Heartbeat, function(dt)
        elapsed += dt
        if elapsed < 0.05 or combat.Running then return end
        elapsed, combat.Running, combat.Thread = 0, true, coroutine.running()
        local ok, err = pcall(combat.Step, combat, os.clock())
        combat.Running, combat.Thread = false, nil
        if not ok then combat:Stop(); combat.Faulted = true; combat.Status = "Combat stopped: " .. tostring(err):sub(1, 120) end
    end)
    connect(LocalPlayer.CharacterRemoving, function() combat:ClearTarget() end)
    local shared = ReplicatedStorage:FindFirstChild("Shared")
    local network = shared and shared:FindFirstChild("Network")
    local broadcast = network and network:FindFirstChild("CombatBroadcastURE")
    if broadcast then connect(broadcast.OnClientEvent, function(event, attacker, defender)
        local target = combat.Target
        if target and (attacker == target or attacker == target.Name)
            and (defender == LocalPlayer.Name or defender == LocalPlayer.Character)
            and (event == "M1PerfectBlocked" or event == "M2PerfectBlocked") then combat.Parries += 1 end
    end) end
end
-- KUCHISAKE_COMBAT_END


local npcsFolder = workspace:FindFirstChild("NPCs")

local function onNewChild(child)
    if not child:IsA("Model") then
        return
    end
    task.wait(0.15)
    if not app.Alive then return end
    local isBoss, reason = inspectModel(child)
    if isBoss then
        addOrUpdateTracked(child, "CONFIRMED " .. reason, nil)
    end
end

if npcsFolder then
    connect(npcsFolder.ChildAdded, onNewChild)
end
connect(workspace.ChildAdded, onNewChild)

local remotes = ReplicatedStorage:FindFirstChild("Remotes")
if remotes then
    local chatBubble = remotes:FindFirstChild("ChatBubble")
    if chatBubble and chatBubble:IsA("RemoteEvent") then
        connect(chatBubble.OnClientEvent, function(data)
            if typeof(data) == "table" and typeof(data.Message) == "string" then
                if data.SourceIsPlayer ~= 1 then
                    local targetPlayer = nil
                    if typeof(data.LookAtUserId) == "number" then
                        targetPlayer = Players:GetPlayerByUserId(data.LookAtUserId)
                    end
                    local sourceModel = workspace:FindFirstChild(data.SourceName)
                    if not sourceModel and npcsFolder then
                        sourceModel = npcsFolder:FindFirstChild(data.SourceName)
                    end
                    if sourceModel then
                        local isBoss, reason = inspectModel(sourceModel)
                        if isBoss then
                            addOrUpdateTracked(sourceModel, "Spoke: " .. data.Message, targetPlayer)
                        end
                    end
                end
            end
        end)
    end

    local rerollNarration = remotes:FindFirstChild("RerollNarration") or remotes:FindFirstChild("RerollChannel")
    if rerollNarration and rerollNarration:IsA("RemoteEvent") then
        connect(rerollNarration.OnClientEvent, function(cmd, payload)
            if (cmd == "Narration" or typeof(cmd) == "table") then
                local text = typeof(cmd) == "table" and cmd.Text or (typeof(payload) == "table" and payload.Text) or ""
                if text:find("Kuchisake") or text:find("fled") then
                    TargetLabel.Text = "KUCHISAKE FLED (+10 RR RECEIVED)"
                    TargetLabel.TextColor3 = Color3.fromRGB(80, 255, 120)
                end
            end
        end)
    end
end

local lastScan = 0
connect(RunService.Heartbeat, function()
    if not app.Alive then return end
    local now = tick()
    if now - lastScan < 0.6 then return end
    local minutes = getMinutesOfDay()
    local realSecPerIngameHour = 200
    local ingameMinPerRealSec = 60 / realSecPerIngameHour

    ClockLabel.Text = string.format("In-game Time: %s (%d min)", formatClock(minutes), math.floor(minutes))

    if isPrivateServer() then
        Status.Text = "Status: PRIVATE SERVER (Will NOT Spawn)"
        Status.TextColor3 = Color3.fromRGB(255, 80, 80)
        return
    end

    local inWindow = (minutes >= 1080 and minutes <= 1200)
    if inWindow then
        Status.Text = "Status: 6-8 PM WINDOW ACTIVE (50% Chance)"
        Status.TextColor3 = Color3.fromRGB(255, 210, 60)
    else
        local diff = (1080 - minutes) % 1440
        local realSecLeft = diff / ingameMinPerRealSec
        local waitMins = math.floor(realSecLeft / 60)
        local waitSecs = math.floor(realSecLeft % 60)
        Status.Text = string.format("Status: Waiting for 18:00 (~%02d:%02d real time)", waitMins, waitSecs)
        Status.TextColor3 = Color3.fromRGB(160, 160, 180)
    end

    for model, _ in pairs(trackedEntities) do
        if not model.Parent or not model:FindFirstChild("Humanoid") or model.Humanoid.Health <= 0 then
            removeTracked(model)
        end
    end

    if now - lastScan >= 0.6 then
        lastScan = now
        local candidates = {}
        if npcsFolder then
            for _, c in ipairs(npcsFolder:GetChildren()) do
                if c:IsA("Model") and c:FindFirstChild("Humanoid") then
                    table.insert(candidates, c)
                end
            end
        end
        for _, c in ipairs(workspace:GetChildren()) do
            if c:IsA("Model") and c:FindFirstChild("Humanoid") and not Players:GetPlayerFromCharacter(c) then
                table.insert(candidates, c)
            end
        end

        for _, model in ipairs(candidates) do
            local isBoss, reason = inspectModel(model)
            if isBoss then
                local hrp = model:FindFirstChild("HumanoidRootPart")
                local closestPlayer = nil
                local closestDist = math.huge
                for _, player in ipairs(Players:GetPlayers()) do
                    local char = player.Character
                    local pRoot = char and char:FindFirstChild("HumanoidRootPart")
                    if pRoot and hrp then
                        local d = (hrp.Position - pRoot.Position).Magnitude
                        if d < closestDist then
                            closestDist = d
                            closestPlayer = player
                        end
                    end
                end
                addOrUpdateTracked(model, string.format("%s (%.0f studs)", reason, closestDist), closestPlayer)
            end
        end

        local count = 0
        local hpTexts = {}
        local targetTexts = {}
        for model, data in pairs(trackedEntities) do
            count = count + 1
            local hum = model:FindFirstChild("Humanoid")
            local tName = data.TargetPlayer and data.TargetPlayer.Name or "None"
            if hum then
                table.insert(hpTexts, string.format("[%s: %.0f/%.0f]", model.Name, hum.Health, hum.MaxHealth))
                table.insert(targetTexts, string.format("%s->%s", model.Name, tName))
            end
        end

        if count > 0 then
            UIStroke.Color = Color3.fromRGB(255, 30, 30)
            TargetLabel.TextColor3 = Color3.fromRGB(255, 60, 60)
            TargetLabel.Text = string.format("Active (%d): %s", count, table.concat(targetTexts, ", "))
            HealthLabel.Text = table.concat(hpTexts, " | ")
        else
            UIStroke.Color = Color3.fromRGB(200, 50, 75)
            TargetLabel.TextColor3 = Color3.fromRGB(255, 200, 50)
            TargetLabel.Text = "Targets: Scanning (HP >= 200)..."
            HealthLabel.Text = "Boss HP: None Active"
        end
    end
end)


local function startUI()
    Rere.Init(LocalPlayer:WaitForChild("PlayerGui"))
    local camera = workspace.CurrentCamera
    local viewport = camera and camera.ViewportSize or Vector2.new(1280, 720)
    local size = Vector2.new(math.min(480, math.max(240, viewport.X - 32)), math.min(430, math.max(180, viewport.Y - 32)))
    local window = {
        size = Rere.State(size),
        position = Rere.State(Vector2.new(math.max(0, (viewport.X - size.X) / 2), math.max(0, (viewport.Y - size.Y) / 2))),
        isOpened = Rere.State(true),
        isUncollapsed = Rere.State(true),
    }
    local autoState = Rere.State(app.Auto.Enabled)
    local attackState = Rere.State(app.Combat.Enabled)
    local parryState = Rere.State(app.Combat.ParryEnabled)
    local unbindClose = Rere.BindClose("Kuchisake Radar", function(title)
        return title == "Kuchisake Radar"
    end, function() app:Stop() end)
    table.insert(app.Connections, {Disconnect = unbindClose})
    local disconnect = Rere:Connect(function()
        if not app.Alive then return end
        Rere.SetNextWidgetID("KuchisakeRadar/Window")
        Rere.Window({"Kuchisake Radar"}, window)
        if window.isOpened.value and window.isUncollapsed.value then
            Rere.SetNextWidgetID("KuchisakeRadar/Session")
            Rere.SeparatorText({"Session"})
            for _, row in ipairs({{"Clock", ClockLabel}, {"Status", Status}}) do
                Rere.SetNextWidgetID("KuchisakeRadar/" .. row[1])
                Rere.PushConfig({TextColor = row[2].TextColor3})
                Rere.TextWrapped({row[2].Text})
                Rere.PopConfig()
            end
            Rere.SetNextWidgetID("KuchisakeRadar/ServerHop")
            Rere.SeparatorText({"Server Hop"})
            Rere.SetNextWidgetID("KuchisakeRadar/ServerHop/Auto")
            Rere.Checkbox({"Auto Hop (16:30-20:00)"}, {isChecked = autoState})
            if autoState.value ~= app.Auto.Enabled then app.Auto:SetEnabled(autoState.value) end
            Rere.SetNextWidgetID("KuchisakeRadar/ServerHop/AutoStatus")
            Rere.TextWrapped({app.Auto.Status})
            Rere.SetNextWidgetID("KuchisakeRadar/ServerHop/Button")
            if Rere.Button({"Hop to Lowest-Player Server"}).clicked() then app.Hop:Start() end
            Rere.SetNextWidgetID("KuchisakeRadar/ServerHop/Status")
            Rere.TextWrapped({app.Hop.Status .. " (" .. app.Hop.StorageNote .. ")"})
            Rere.SetNextWidgetID("KuchisakeRadar/Combat")
            Rere.SeparatorText({"Kuchisake Combat"})
            Rere.SetNextWidgetID("KuchisakeRadar/Combat/Attack")
            if app.Combat.Faulted then attackState.value = false; app.Combat.Faulted = nil end
            Rere.Checkbox({"Auto Attack (NPC Max HP 355-375)"}, {isChecked = attackState})
            if attackState.value ~= app.Combat.Enabled then app.Combat:SetEnabled(attackState.value) end
            Rere.SetNextWidgetID("KuchisakeRadar/Combat/Parry")
            Rere.Checkbox({"Auto Parry"}, {isChecked = parryState})
            if parryState.value ~= app.Combat.ParryEnabled then app.Combat:SetParry(parryState.value) end
            Rere.SetNextWidgetID("KuchisakeRadar/Combat/Status")
            Rere.TextWrapped({app.Combat.Status})
            Rere.SetNextWidgetID("KuchisakeRadar/Tracking")
            Rere.SeparatorText({"Multi-Target Tracking"})
            for _, row in ipairs({{"Targets", TargetLabel}, {"Health", HealthLabel}}) do
                Rere.SetNextWidgetID("KuchisakeRadar/" .. row[1])
                Rere.PushConfig({TextColor = row[2].TextColor3})
                Rere.TextWrapped({row[2].Text})
                Rere.PopConfig()
            end
        end
        Rere.End()
    end)
    table.insert(app.Connections, {Disconnect = disconnect})
end
app.Auto:Tick()
local autoElapsed = 0
connect(RunService.Heartbeat, function(dt)
    autoElapsed += dt
    if autoElapsed >= 1 then autoElapsed = 0; app.Auto:Tick() end
end)
local ok, err = pcall(function()
    Rere = assert(compiler(game:HttpGet("https://api.x8stuff.lol/assets/Rere.lua"), "KuchisakeRadar/Rere"))()
    assert(type(Rere.BindClose) == "function", "Rere is missing BindClose; update the library")
    startUI()
end)
if not ok then app:Stop(); error("Kuchisake Radar UI: " .. tostring(err), 0) end
local reloadState = getfenv().STATE
if type(reloadState) == "table" and type(reloadState.onCleanup) == "function" then
    reloadState.onCleanup(function() app:Stop() end)
end
return app
end
]========]
return assert(loadstring(source, "KuchisakeRadar/Runtime"))()(source)