local warn = warn or function() end

local _origPcall = pcall
local _origXpcall = xpcall
local _origError = error

local debugLibrary = debug
_G._VERSION = \\"Luau\\"
local setHook = debug.sethook
local getInfo = debug.getinfo
local getTraceback = debug.traceback
local loadFunction = load
local loadStringFunction = loadstring or load
local pcallFunction = pcall
local xpcallFunction = xpcall
local errorFunction = error
local typeFunction = type
local getMetatableFunction = getmetatable
local rawEqualFunction = rawequal
local toStringFunction = tostring
local toNumberFunction = tonumber
local ioLibrary = io
local osLibrary = os
local pairsFunction = pairs
local ipairsFunction = ipairs
local tableUnpackFunction = table.unpack or unpack
local proxyTable = {}
proxyTable.__index = proxyTable
local configuration = {
    MAX_DEPTH = 15,
    MAX_TABLE_ITEMS = 150,
    OUTPUT_FILE = \\"dumped_output.lua\\",
    VERBOSE = false,
    TRACE_CALLBACKS = true,
    TIMEOUT_SECONDS = 6.67,
    MAX_REPEATED_LINES = 8,
    MIN_DEOBF_LENGTH = 150,
    MAX_OUTPUT_SIZE = 2 * 1024 * 1024,
    CONSTANT_COLLECTION = true,
    INSTRUMENT_LOGIC = true
}
local inputKey = (arg and arg[3]) or \\"NoKey\\"
if arg and arg[3] then
    print(\\"[Dumper] Auto-Input Key Detected: \\" .. toStringFunction(inputKey))
end
local dumperState = {
    output = {},
    indent = 0,
    registry = {},
    reverse_registry = {},
    names_used = {},
    parent_map = {},
    property_store = {},
    call_graph = {},
    variable_types = {},
    string_refs = {},
    proxy_id = 0,
    callback_depth = 0,
    pending_iterator = false,
    last_http_url = nil,
    last_emitted_line = nil,
    repetition_count = 0,
    current_size = 0,
    ls_counter = 0
}
local _at = {
    mem          = {},
    tags         = {},
    sigs         = {},
    acts         = {},
    json         = {},
    enum         = {},
    svcCache     = {},
    typeOverride = {},
    connState    = {},
    debugIds     = {},
    debugIdCtr   = 0,
    instTags     = {},
    attrs        = {},
    children     = {},
    threadLike   = {},
    vectors      = {},
    buffers      = {},
    userdata     = {},
    localPlayer  = nil,
    weldRegistry = {},
    services     = {},
    folders      = {},
    files        = {},
    refBase      = {},
    metaHooks    = {},
    currentNamecallMethod = nil,
    inMetaHook   = false,
    pendingHeartbeat = {},
    locEntries = {},
    signalCallbacks = {},  -- AT5: live signal firing
    animateScript = nil,   -- AT3: getrunningscripts
}
setmetatable(_at.debugIds, {__mode = \\"k\\"})
setmetatable(_at.instTags, {__mode = \\"k\\"})
setmetatable(_at.attrs, {__mode = \\"k\\"})
setmetatable(_at.children, {__mode = \\"k\\"})
setmetatable(_at.threadLike, {__mode = \\"k\\"})
setmetatable(_at.vectors, {__mode = \\"k\\"})
setmetatable(_at.buffers, {__mode = \\"k\\"})
setmetatable(_at.userdata, {__mode = \\"k\\"})
setmetatable(_at.refBase, {__mode = \\"k\\"})
local function _getDebugId(p)
    if not _at.debugIds[p] then
        _at.debugIdCtr = _at.debugIdCtr + 1
        local n = _at.debugIdCtr
        _at.debugIds[p] = toStringFunction(n * 17 + 3) .. \\"-\\" .. toStringFunction(n * 97 + 11)
    end
    return _at.debugIds[p]
end
local function _removeChild(parent, child)
    local list = parent and _at.children[parent]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == child then table.remove(list, i) end
    end
end
local function _setParent(child, parent)
    local oldParent = dumperState.parent_map[child]
    if oldParent == parent then return end
    _removeChild(oldParent, child)
    dumperState.parent_map[child] = parent
    if parent then
        _at.children[parent] = _at.children[parent] or {}
        table.insert(_at.children[parent], child)
        -- skip signal firing for internal proxy types
        local childType = _at.typeOverride[child]
        local parentType = _at.typeOverride[parent]
        if childType == \\"RBXScriptSignal\\" or childType == \\"RBXScriptConnection\\"
        or parentType == \\"RBXScriptSignal\\" or parentType == \\"RBXScriptConnection\\" then
            return
        end
        -- fire ChildAdded on direct parent only
        if _at.signalCallbacks[parent] then
            for _, cb in ipairsFunction(_at.signalCallbacks[parent].ChildAdded or {}) do
                pcallFunction(cb, child)
            end
        end
        -- fire DescendantAdded on direct parent and its ancestors
        local ancestor = parent
        while ancestor do
            if _at.signalCallbacks[ancestor] then
                for _, cb in ipairsFunction(_at.signalCallbacks[ancestor].DescendantAdded or {}) do
                    pcallFunction(cb, child)
                end
            end
            ancestor = dumperState.parent_map[ancestor]
        end
    end
end
local function _isDescendantOf(child, parent)
    local cur = dumperState.parent_map[child]
    while cur do
        if cur == parent then return true end
        cur = dumperState.parent_map[cur]
    end
    return false
end
local function _getAllDescendants(root, out)
    out = out or {}
    for _, child in ipairsFunction(_at.children[root] or {}) do
        table.insert(out, child)
        _getAllDescendants(child, out)
    end
    return out
end
local numericArg = (arg and toNumberFunction(arg[4])) or (arg and toNumberFunction(arg[3])) or 123456789
local proxyMarker = {}
local function isProxyTable(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyMarker) == true end )
    return success and result
end
local function getProxyValue(target)
    if isProxyTable(target) then
        return rawget(target, \\"__value\\") or 0
    end
    return 0
end
local loadStringFunction = loadstring or load
local printFunction = print
local warnFunction = warn or function() end
local pairsFunction = pairs
local ipairsFunction = ipairs
local typeFunction = type
local toStringFunction = tostring
local proxyList = {}
local function isProxy(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyList) == true end )
    return success and result
end
local function getProxyId(target)
    if not isProxy(target) then
        return nil
    end
    return rawget(target, \\"__proxy_id\\")
end
local function processString(inputString)
    if typeFunction(inputString) ~= \\"string\\" then
        return '\\"'
    end
    local outputParts = {}
    local currentIndex, totalLength = 1, #inputString
    local function cleanEscapes(content)
        return content:gsub( \\"\\\\\\\\(.)\\", function(escapedChar)
            if escapedChar:match('[abfnrtv\\\\\\\\%\'%\\\\\\"%[%]0-9xu]') then
                return \\"\\" .. escapedChar
            end
            return escapedChar
        end )
    end
    local function stripLuauSyntax(rawCode)
        if not rawCode or rawCode == \\"\\" then
            return rawCode
        end
        rawCode = rawCode:gsub(\\"\239\187\191\\", \\"\\")
        rawCode = rawCode:gsub(\\"\\r\n\\", \\"\n\\"):gsub(\\"\\r\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"\226\128\168\\", \\"\n\\"):gsub(\\"\226\128\169\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"%-%-!%a+[^\n]*\\", \\"\\")
        rawCode = rawCode:gsub(\\"([^\n]*)\\", function(line)
            if line:match(\\"^%s*export%s+type%s+\\") or line:match(\\"^%s*type%s+[%a_][%w_]*%s*=\\") then
                return \\"-- \\" .. line
            end
            return line
        end)
        rawCode = rawCode:gsub(\\"local%s+([%a_][%w_]*)%s*<[%a_][%w_]*>%s*=\\", \\"local %1 =\\")
        rawCode = rawCode:gsub(\\"(function%s+[%a_][%w_%.:]*)%s*<[^>\n%(]+>%s*%(\\", \\"%1(\\")
        rawCode = rawCode:gsub(\\"([%(%s,])%.%.%.%s*:%s*[%a_][%w_%.]*%??\\", \\"%1...\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"%1%2\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\"%1%2%3\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\")\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\")%1\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%??\\", \\"\\")
        return rawCode
    end
    local function parseExpression(rawCode)
        if not rawCode or rawCode == '\\"' then
            return \\"\\"
        end
        rawCode = stripLuauSyntax(rawCode)
        rawCode = rawCode:gsub( \\"0[bB]([01_]+)\\", function(binaryString)
            local cleanBinary = binaryString:gsub(\\"_\\", \\"\\")
            local decimalValue = toNumberFunction(cleanBinary, 2)
            return decimalValue and toStringFunction(decimalValue) or \\"0\\"
        end )
        rawCode = rawCode:gsub( \\"0[xX]([%x_]+)\\", function(hexString)
            local cleanHex = hexString:gsub(\\"_\\", \\"\\")
            return \\"0x\\" .. cleanHex
        end )
        while rawCode:match(\\"%d_+%d\\") do
            rawCode = rawCode:gsub(\\"(%d)_+(%d)\\", \\"%1%2\\")
        end
        local operators = {{\\"+=\\", \\"+\\"}, {\\"-=\\", \\"-\\"}, {\\"*=\\", \\"*\\"}, {\\"/=\\", \\"/\\"}, {\\"%%=\\", \\"%%\\"}, {\\"%^=\\", \\"^\\"}, {\\"%.%.=\\", \\"..\\"}}
        for _, opPair in ipairsFunction(operators) do
            local operatorAssignment, operator = opPair[1], opPair[2]
            -- simple var: x+=1 -> x = x + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- dot chain: x.y.z+=1 -> x.y.z = x.y.z + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*%.[%a_][%w_%.]+)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- bracket chain: R[m]+=q, T[1][2]+=q, obj[\\"k\\"][i]+=q
            -- manually find identifier + full bracket chain before the operator
            local escOp = operatorAssignment:gsub(\\"([%.%+%-%*%/%^%%])\\", \\"%%%1\\")
            rawCode = rawCode:gsub(\\"([%a_][%w_]*)(%b[])\\", function(name, firstBracket)
                -- check if after firstBracket there are more brackets then the operator
                return name .. firstBracket
            end)
            -- proper scan: replace lval+= where lval is ident + bracket chain
            do
                local result = {}
                local i = 1
                local len = #rawCode
                while i <= len do
                    -- look for identifier start
                    local idStart, idEnd = rawCode:find(\\"[%a_][%w_]*\\", i)
                    if not idStart then
                        result[#result+1] = rawCode:sub(i)
                        break
                    end
                    result[#result+1] = rawCode:sub(i, idStart-1)
                    local varName = rawCode:match(\\"[%a_][%w_]*\\", idStart)
                    local pos = idStart + #varName
                    -- consume bracket chains
                    while pos <= len and rawCode:sub(pos,pos) == \\"[\\" do
                        local _, bEnd = rawCode:find(\\"%b[]\\", pos)
                        if not bEnd then break end
                        varName = varName .. rawCode:sub(pos, bEnd)
                        pos = bEnd + 1
                    end
                    -- check for operator after optional whitespace
                    local wsEnd = pos
                    while wsEnd <= len and rawCode:sub(wsEnd,wsEnd):match(\\"%s\\") do wsEnd=wsEnd+1 end
                    local opMatch = rawCode:sub(wsEnd, wsEnd + #operatorAssignment - 1)
                    if opMatch == operatorAssignment and varName:find(\\"%[\\") then
                        -- rewrite: varName op= ... -> varName = varName op ...
                        result[#result+1] = varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
                        i = wsEnd + #operatorAssignment
                    else
                        result[#result+1] = varName
                        i = pos
                    end
                end
                rawCode = table.concat(result)
            end
        end
        rawCode = rawCode:gsub(\\"([^%w_])continue([^%w_])\\", \\"%1__LC__()%2\\")
        rawCode = rawCode:gsub(\\"^continue([^%w_])\\", \\"__LC__()%1\\")
        rawCode = rawCode:gsub(\\"([^%w_])continue$\\", \\"%1__LC__()\\")
        return rawCode
    end
    local function getBracketCount(index)
        local count = 0
        while index <= totalLength and inputString:byte(index) == 61 do
            count = count + 1
            index = index + 1
        end
        return count, index
    end
    local function findClosingBracket(startIndex, bracketCount)
        local closingPattern = \\"]\\" .. string.rep(\\"=\\", bracketCount) .. \\"]\\"
        local start, finish = inputString:find(closingPattern, startIndex, true)
        return finish or totalLength
    end
    local segmentStart = 1
    while currentIndex <= totalLength do
        local byteValue = inputString:byte(currentIndex)
        if byteValue == 91 then
            local bracketCount, nextIndex = getBracketCount(currentIndex + 1)
            if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
                local startSegment = currentIndex
                local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                table.insert(outputParts, inputString:sub(startSegment, endSegment))
                currentIndex = endSegment
                segmentStart = currentIndex + 1
            end
        elseif byteValue == 45 and currentIndex + 1 <= totalLength and inputString:byte(currentIndex + 1) == 45 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local startSegment = currentIndex
            if currentIndex + 2 <= totalLength and inputString:byte(currentIndex + 2) == 91 then
                local bracketCount, nextIndex = getBracketCount(currentIndex + 3)
                if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                    local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                    table.insert(outputParts, inputString:sub(startSegment, endSegment))
                    currentIndex = endSegment
                    segmentStart = currentIndex + 1
                    currentIndex = currentIndex + 1
                end
            end
            local lineBreak = inputString:find(\\"\n\\", currentIndex + 2, true)
            if lineBreak then
                currentIndex = lineBreak
            else
                currentIndex = totalLength
            end
            table.insert(outputParts, inputString:sub(startSegment, currentIndex))
            segmentStart = currentIndex + 1
        elseif byteValue == 34 or byteValue == 39 or byteValue == 96 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local quoteType = byteValue
            local startSegment = currentIndex
            currentIndex = currentIndex + 1
            while currentIndex <= totalLength do
                local charByte = inputString:byte(currentIndex)
                if charByte == 92 then
                    currentIndex = currentIndex + 1
                elseif charByte == quoteType then
                    break
                end
                currentIndex = currentIndex + 1
            end
            local extractedContent = inputString:sub(startSegment + 1, currentIndex - 1)
            extractedContent = cleanEscapes(extractedContent)
            if quoteType == 96 then
                table.insert(outputParts, '\\"' .. extractedContent:gsub('\\"', '\\\\\\\\\\"') .. '\\"')
            else
                local quoteChar = string.char(quoteType)
                table.insert(outputParts, quoteChar .. extractedContent .. quoteChar)
            end
            segmentStart = currentIndex + 1
        end
        currentIndex = currentIndex + 1
    end
    table.insert(outputParts, parseExpression(inputString:sub(segmentStart)))
    return table.concat(outputParts)
end
local function safeLoad(code, chunkName)
    local loadedFunc, errorMessage = loadStringFunction(code, chunkName)
    if loadedFunc then
        return loadedFunc
    end
    printFunction(\\"\n[CRITICAL ERROR] Failed to load script!\\")
    printFunction(\\"[LUA_LOAD_FAIL] \\" .. toStringFunction(errorMessage))
    local errorLine = toNumberFunction(errorMessage:match(\\":(%d+):\\"))
    local errorNear = errorMessage:match(\\"near '([^']+)'\\")
    if errorNear then
        local foundIndex = code:find(errorNear, 1, true)
        if foundIndex then
            local startCtx = math.max(1, foundIndex - 50)
            local endCtx = math.min(#code, foundIndex + 50)
            printFunction(\\"Context around error:\\")
            printFunction(\\"...\\" .. code:sub(startCtx, endCtx) .. \\"...\\")
        end
    end
    local debugFile = ioLibrary.open(\\"DEBUG_FAILED_TRANSPILE.lua\\", \\"w\\")
    if debugFile then
        debugFile:write(code)
        debugFile:close()
        printFunction(\\"[*] Saved to 'DEBUG_FAILED_TRANSPILE.lua' for inspection\\")
    end
    return nil, errorMessage
end
local function emitOutput(data, isInline)
    if dumperState.limit_reached then
        return
    end
    if data == nil then
        return
    end
    local indentPrefix = isInline and \\"\\" or string.rep(\\"    \\", dumperState.indent)
    local lineString = indentPrefix .. toStringFunction(data)
    local lineSize = #lineString + 1
    if dumperState.current_size + lineSize > configuration.MAX_OUTPUT_SIZE then
        dumperState.limit_reached = true
        local warningMessage = \\"-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.\\"
        table.insert(dumperState.output, warningMessage)
        dumperState.current_size = dumperState.current_size + #warningMessage
        errorFunction(\\"DUMP_LIMIT_EXCEEDED\\")
    end
    if lineString == dumperState.last_emitted_line then
        dumperState.repetition_count = dumperState.repetition_count + 1
        if dumperState.repetition_count <= configuration.MAX_REPEATED_LINES then
            table.insert(dumperState.output, lineString)
            dumperState.current_size = dumperState.current_size + lineSize
        elseif dumperState.repetition_count == configuration.MAX_REPEATED_LINES + 1 then
            local suppressMessage = indentPrefix .. \\"-- [Repeated lines suppressed...]\\"
            table.insert(dumperState.output, suppressMessage)
            dumperState.current_size = dumperState.current_size + #suppressMessage
        end
    else
        dumperState.last_emitted_line = lineString
        dumperState.repetition_count = 0
        table.insert(dumperState.output, lineString)
        dumperState.current_size = dumperState.current_size + lineSize
    end
    if configuration.VERBOSE and dumperState.repetition_count <= 1 then
        printFunction(lineString)
    end
end
local function emitComment(data)
    emitOutput(\\"-- \\" .. toStringFunction(data or \\"\\"))
end
local function addEmptyLine()
    dumperState.last_emitted_line = nil
    table.insert(dumperState.output, \\"\\")
end
local function getFullOutput()
    return table.concat(dumperState.output, \\"\n\\")
end
local function saveToFile(filePath)
    local fileHandle = ioLibrary.open(filePath or configuration.OUTPUT_FILE, \\"w\\")
    if fileHandle then
        fileHandle:write(getFullOutput())
        fileHandle:close()
        return true
    end
    return false
end
local function formatValue(value)
    if value == nil then
        return \\"nil\\"
    end
    if typeFunction(value) == \\"string\\" then
        return value
    end
    if typeFunction(value) == \\"number\\" or typeFunction(value) == \\"boolean\\" then
        return toStringFunction(value)
    end
    if typeFunction(value) == \\"table\\" then
        if dumperState.registry[value] then
            return dumperState.registry[value]
        end
        if isProxy(value) then
            local proxyId = getProxyId(value)
            return proxyId and \\"proxy_\\" .. proxyId or \\"proxy\\"
        end
    end
    local success, result = pcallFunction(toStringFunction, value)
    return success and result or \\"unknown\\"
end
local function formatStringLiteral(value)
    local rawValue = formatValue(value)
    local escapedValue = rawValue:gsub(\\"\\\\\\\\\\", \\"\\\\\\\\\\\\\\\\\\"):gsub('\\"', '\\\\\\\\\\"'):gsub(\\"\n\\", \\"\n\\"):gsub(\\"\\\\\r\\", \\"\\\\\\\\\r\\"):gsub(\\"\\\\\t\\", \\"\\\\\\\\\t\\")
    return '\\"' .. escapedValue .. '\\"'
end
local serviceNames = {
    Players = \\"Players\\",
    Workspace = \\"Workspace\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    ServerStorage = \\"ServerStorage\\",
    ServerScriptService = \\"ServerScriptService\\",
    StarterGui = \\"StarterGui\\",
    StarterPack = \\"StarterPack\\",
    StarterPlayer = \\"StarterPlayer\\",
    Lighting = \\"Lighting\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    RunService = \\"RunService\\",
    UserInputService = \\"UserInputService\\",
    TweenService = \\"TweenService\\",
    GroupService = \\"GroupService\\",
    AnimationClipProvider = \\"AnimationClipProvider\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    TeleportService = \\"TeleportService\\",
    PathfindingService = \\"PathfindingService\\",
    CollectionService = \\"CollectionService\\",
    PhysicsService = \\"PhysicsService\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    GuiService = \\"GuiService\\",
    HapticService = \\"HapticService\\",
    VRService = \\"VRService\\",
    CoreGui = \\"CoreGui\\",
    Teams = \\"Teams\\",
    InsertService = \\"InsertService\\",
    DataStoreService = \\"DataStoreService\\",
    MessagingService = \\"MessagingService\\",
    TextService = \\"TextService\\",
    TextChatService = \\"TextChatService\\",
    NetworkClient = \\"NetworkClient\\",
    ContentProvider = \\"ContentProvider\\",
    Debris = \\"Debris\\",
    MemStorageService = \\"MemStorageService\\",
    ChangeHistoryService = \\"ChangeHistoryService\\",
    PlayerEmulatorService = \\"PlayerEmulatorService\\",
    StylingService = \\"StylingService\\",
    ScriptContext = \\"ScriptContext\\",
    LocalizationService = \\"LocalizationService\\",
    PolicyService = \\"PolicyService\\",
    CaptureService = \\"CaptureService\\",
    AnalyticsService = \\"AnalyticsService\\",
    EncodingService = \\"EncodingService\\",
    CorePackages = \\"CorePackages\\",
    RobloxReplicatedStorage = \\"RobloxReplicatedStorage\\",
    RobloxGui = \\"RobloxGui\\",
    AvatarEditorService = \\"AvatarEditorService\\",
    SocialService = \\"SocialService\\",
    VoiceChatService = \\"VoiceChatService\\",
    AdService = \\"AdService\\",
    GeometryService = \\"GeometryService\\",
    AssetService = \\"AssetService\\",
    LocalizationService = \\"LocalizationService\\",
    NotificationService = \\"NotificationService\\",
    ProcessInstancePhysicsService = \\"ProcessInstancePhysicsService\\",
    FriendService = \\"FriendService\\",
    SessionService = \\"SessionService\\",
    TimerService = \\"TimerService\\",
    TouchInputService = \\"TouchInputService\\",
    GamepadService = \\"GamepadService\\",
    KeyboardService = \\"KeyboardService\\",
    MouseService = \\"MouseService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceService = \\"PerformanceService\\",
    PlatformFriendService = \\"PlatformFriendService\\",
    ReplicatedFirst = \\"ReplicatedFirst\\",
    SpawnLocation = \\"SpawnLocation\\",
    LogService = \\"LogService\\",
    Stats = \\"Stats\\",
    TweenService = \\"TweenService\\",
    Debris = \\"Debris\\",
    CoreGui = \\"CoreGui\\",
    MarketplaceService = \\"MarketplaceService\\",
    NotificationService = \\"NotificationService\\",
    GuidRegistryService = \\"GuidRegistryService\\",
    NetworkServer = \\"NetworkServer\\",
    Geometry = \\"Geometry\\",
    VirtualInputManager = \\"VirtualInputManager\\",
    MLModelDeliveryService = \\"MLModelDeliveryService\\",
    PartyEmulatorService = \\"PartyEmulatorService\\",
    PlatformFriendsService = \\"PlatformFriendsService\\",
    FriendService = \\"FriendService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceControlService = \\"PerformanceControlService\\",
    RbxAnalyticsService = \\"RbxAnalyticsService\\",
    AbuseReportService = \\"AbuseReportService\\",
    AdService = \\"AdService\\",
    AdPortalService = \\"AdPortalService\\",
    AppUpdateService = \\"AppUpdateService\\",
    BrowserService = \\"BrowserService\\",
    CookiesService = \\"CookiesService\\",
    CoreGui = \\"CoreGui\\",
    GamesService = \\"GamesService\\",
    KeyboardService = \\"KeyboardService\\",
    MarketplaceService = \\"MarketplaceService\\",
    MouseService = \\"MouseService\\",
    NotificationService = \\"NotificationService\\",
    PurchaseDataService = \\"PurchaseDataService\\",
    TimerService = \\"TimerService\\",
    UGCValidationService = \\"UGCValidationService\\",
}
local serviceShortcuts = {
    Players = \\"Players\\",
    UserInputService = \\"UIS\\",
    RunService = \\"RunService\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    TweenService = \\"TweenService\\",
    Workspace = \\"Workspace\\",
    Lighting = \\"Lighting\\",
    StarterGui = \\"StarterGui\\",
    CoreGui = \\"CoreGui\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    DataStoreService = \\"DataStoreService\\",
    TeleportService = \\"TeleportService\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    Teams = \\"Teams\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    CollectionService = \\"CollectionService\\",
    PathfindingService = \\"PathfindingService\\",
    Debris = \\"Debris\\"
}
local classParents = {
    DataModel = {\\"DataModel\\", \\"ServiceProvider\\", \\"Instance\\"},
    Workspace = {\\"Workspace\\", \\"WorldRoot\\", \\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Camera = {\\"Camera\\", \\"Instance\\"},
    Players = {\\"Players\\", \\"Instance\\"},
    Player = {\\"Player\\", \\"Instance\\"},
    PlayerGui = {\\"PlayerGui\\", \\"BasePlayerGui\\", \\"Instance\\"},
    Backpack = {\\"Backpack\\", \\"Instance\\"},
    PlayerScripts = {\\"PlayerScripts\\", \\"Instance\\"},
    Folder = {\\"Folder\\", \\"Instance\\"},
    Model = {\\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Part = {\\"Part\\", \\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    BasePart = {\\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    ModuleScript = {\\"ModuleScript\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    LocalScript = {\\"LocalScript\\", \\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Script = {\\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Humanoid = {\\"Humanoid\\", \\"Instance\\"},
    SoundService = {\\"SoundService\\", \\"Instance\\"},
    Lighting = {\\"Lighting\\", \\"Instance\\"},
    HttpService = {\\"HttpService\\", \\"Instance\\"},
    TweenService = {\\"TweenService\\", \\"Instance\\"},
    RunService = {\\"RunService\\", \\"Instance\\"},
    TextService = {\\"TextService\\", \\"Instance\\"},
    GuiService = {\\"GuiService\\", \\"Instance\\"},
    ContentProvider = {\\"ContentProvider\\", \\"Instance\\"},
    CollectionService = {\\"CollectionService\\", \\"Instance\\"},
    MemStorageService = {\\"MemStorageService\\", \\"Instance\\"},
    NetworkClient = {\\"NetworkClient\\", \\"Instance\\"},
    ClientReplicator = {\\"ClientReplicator\\", \\"Instance\\"},
}
local function classIsA(className, targetClass)
    if className == targetClass then return true end
    local parents = classParents[className] or {className, \\"Instance\\"}
    for _, parentName in ipairsFunction(parents) do
        if parentName == targetClass then return true end
    end
    return false
end
local uiNamingConvention = {
    {pattern = \\"window\\", prefix = \\"Window\\", counter = \\"window\\"},
    {pattern = \\"tab\\", prefix = \\"Tab\\", counter = \\"tab\\"},
    {pattern = \\"section\\", prefix = \\"Section\\", counter = \\"section\\"},
    {pattern = \\"button\\", prefix = \\"Button\\", counter = \\"button\\"},
    {pattern = \\"toggle\\", prefix = \\"Toggle\\", counter = \\"toggle\\"},
    {pattern = \\"slider\\", prefix = \\"Slider\\", counter = \\"slider\\"},
    {pattern = \\"dropdown\\", prefix = \\"Dropdown\\", counter = \\"dropdown\\"},
    {pattern = \\"textbox\\", prefix = \\"Textbox\\", counter = \\"textbox\\"},
    {pattern = \\"input\\", prefix = \\"Input\\", counter = \\"input\\"},
    {pattern = \\"label\\", prefix = \\"Label\\", counter = \\"label\\"},
    {pattern = \\"keybind\\", prefix = \\"Keybind\\", counter = \\"keybind\\"},
    {pattern = \\"colorpicker\\", prefix = \\"ColorPicker\\", counter = \\"colorpicker\\"},
    {pattern = \\"paragraph\\", prefix = \\"Paragraph\\", counter = \\"paragraph\\"},
    {pattern = \\"notification\\", prefix = \\"Notification\\", counter = \\"notification\\"},
    {pattern = \\"divider\\", prefix = \\"Divider\\", counter = \\"divider\\"},
    {pattern = \\"bind\\", prefix = \\"Bind\\", counter = \\"bind\\"},
    {pattern = \\"picker\\", prefix = \\"Picker\\", counter = \\"picker\\"}
}
local uiCounters = {}
local function getUiCounter(name)
    uiCounters[name] = (uiCounters[name] or 0) + 1
    return uiCounters[name]
end
local function resolveVariableName(obj, originalName, hintString)
    if not obj then
        obj = \\"var\\"
    end
    local formattedName = formatValue(obj)
    if serviceShortcuts[formattedName] then
        return serviceShortcuts[formattedName]
    end
    if hintString then
        local lowerHint = hintString:lower()
        for _, patternEntry in ipairsFunction(uiNamingConvention) do
            if lowerHint:find(patternEntry.pattern) then
                local counter = getUiCounter(patternEntry.counter)
                return counter == 1 and patternEntry.prefix or patternEntry.prefix .. counter
            end
        end
    end
    if formattedName == \\"LocalPlayer\\" then
        return \\"LocalPlayer\\"
    end
    if formattedName == \\"Character\\" then
        return \\"Character\\"
    end
    if formattedName == \\"Humanoid\\" then
        return \\"Humanoid\\"
    end
    if formattedName == \\"HumanoidRootPart\\" then
        return \\"HumanoidRootPart\\"
    end
    if formattedName == \\"Camera\\" then
        return \\"Camera\\"
    end
    if formattedName:match(\\"^Enum%.\\") then
        return formattedName
    end
    local sanitizedName = formattedName:gsub(\\"[^%w_]\\", '\\"'):gsub(\\"^%d+\\", '\\"')
    if sanitizedName == '\\"' or sanitizedName == \\"Object\\" or sanitizedName == \\"Value\\" or sanitizedName == \\"result\\" then
        sanitizedName = \\"var\\"
    end
    return sanitizedName
end
local function registerVariable(obj, objName, varType, hintString)
    local existing = dumperState.registry[obj]
    if existing and existing:match(\\"^v%d+$\\") then
        return existing
    end
    dumperState.ls_counter = (dumperState.ls_counter or 0) + 1
    local newName = \\"v\\" .. dumperState.ls_counter
    dumperState.names_used[newName] = true
    dumperState.registry[obj] = newName
    dumperState.reverse_registry[newName] = obj
    dumperState.variable_types[newName] = varType or typeFunction(obj)
    return newName
end
local function serializeValue(obj, depth, visited, allowInline)
    depth = depth or 0
    visited = visited or {}
    if depth > configuration.MAX_DEPTH then
        return \\"{ --[[max depth]] }\\"
    end
    local valueType = typeFunction(obj)
    if isProxyTable(obj) then
        local proxyValue = rawget(obj, \\"__value\\")
        return toStringFunction(proxyValue or 0)
    end
    if valueType == \\"table\\" and dumperState.registry[obj] then
        return dumperState.registry[obj]
    end
    if valueType == \\"nil\\" then
        return \\"nil\\"
    elseif valueType == \\"string\\" then
        if #obj > 100 and obj:match(\\"^[A-Za-z0-9+/=]+$\\") then
            table.insert(dumperState.string_refs, {value = obj:sub(1, 50) .. \\"...\\", hint = \\"base64\\", full_length = #obj})
        elseif obj:match(\\"https?://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"URL\\"})
        elseif obj:match(\\"rbxasset://\\") or obj:match(\\"rbxassetid://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"Asset\\"})
        end
        return formatStringLiteral(obj)
    elseif valueType == \\"number\\" then
        if obj ~= obj then
            return \\"0/0\\"
        end
        if obj == math.huge then
            return \\"math.huge\\"
        end
        if obj == -math.huge then
            return \\"-math.huge\\"
        end
        if obj == math.floor(obj) then
            return toStringFunction(math.floor(obj))
        end
        return string.format(\\"%.6g\\", obj)
    elseif valueType == \\"boolean\\" then
        return toStringFunction(obj)
    elseif valueType == \\"function\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        return \\"function() end\\"
    elseif valueType == \\"table\\" then
        if isProxy(obj) then
            return dumperState.registry[obj] or \\"proxy\\"
        end
        if visited[obj] then
            return \\"{ --[[circular]] }\\"
        end
        visited[obj] = true
        local count = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                count = count + 1
            end
        end
        if count == 0 then
            return \\"{}\\"
        end
        local isSequence = true
        local maxIdx = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                if typeFunction(k) ~= \\"number\\" or k < 1 or k ~= math.floor(k) then
                    isSequence = false
                    break
                else
                    maxIdx = math.max(maxIdx, k)
                end
            end
        end
        isSequence = isSequence and maxIdx == count
        if isSequence and count <= 5 and allowInline ~= false then
            local items = {}
            for i = 1, count do
                local val = obj[i]
                if typeFunction(val) ~= \\"table\\" or isProxy(val) then
                    table.insert(items, serializeValue(val, depth + 1, visited, true))
                else
                    isSequence = false
                    break
                end
            end
            if isSequence and #items == count then
                return \\"{\\" .. table.concat(items, \\", \\") .. \\"}\\"
            end
        end
        local output = {}
        local itemCount = 0
        local indent = string.rep(\\"    \\", dumperState.indent + depth + 1)
        local baseIndent = string.rep(\\"    \\", dumperState.indent + depth)
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                itemCount = itemCount + 1
                if itemCount > configuration.MAX_TABLE_ITEMS then
                    table.insert(output, indent .. \\"-- ...\\" .. count - itemCount + 1 .. \\" more\\")
                    break
                end
                local keyStr
                if isSequence then
                    keyStr = nil
                elseif typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                    keyStr = k
                else
                    keyStr = \\"[\\" .. serializeValue(k, depth + 1, visited) .. \\"]\\"
                end
                local valStr = serializeValue(v, depth + 1, visited)
                if keyStr then
                    table.insert(output, indent .. keyStr .. \\" = \\" .. valStr)
                else
                    table.insert(output, indent .. valStr)
                end
            end
        end
        if #output == 0 then
            return \\"{}\\"
        end
        return \\"{\n\\" .. table.concat(output, \\",\n\\") .. \\"\n\\" .. baseIndent .. \\"}\\"
    elseif valueType == \\"userdata\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"userdata\\"
    elseif valueType == \\"thread\\" then
        return \\"coroutine.create(function() end)\\"
    else
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"nil\\"
    end
end
local proxyStore = {}
setmetatable(proxyStore, {__mode = \\"k\\"})
local function createProxy()
    local proxy = {}
    proxyStore[proxy] = true
    local meta = {}
    setmetatable(proxy, meta)
    return proxy, meta
end
local function isProxy(obj)
    return proxyStore[obj] == true
end
local createProxyObject
local createProxyMethod
-- ContentId type for AT6 (SurfaceAppearance.ColorMap etc)
local function _makeContentId(val)
    val = val or \\"\\"
    return setmetatable({_value = val}, {
        __typeof = \\"ContentId\\",
        __tostring = function() return val end,
        __eq = function(a, b)
            local av = typeFunction(a) == \\"table\\" and rawget(a, \\"_value\\") or a
            local bv = typeFunction(b) == \\"table\\" and rawget(b, \\"_value\\") or b
            return av == bv
        end,
        __index = function(t, k) if k == \\"_value\\" then return val end end,
    })
end
local _makeVector3
local _makeCFrame
local function createProxyInstance(bm)
    local proxy, meta = createProxy()
    rawset(proxy, proxyMarker, true)
    rawset(proxy, \\"__value\\", bm)
    dumperState.registry[proxy] = toStringFunction(bm)
    meta.__tostring = function() return toStringFunction(bm) end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" or key == proxyMarker or key == \\"__value\\" then
            return rawget(tbl, key)
        end
        return createProxyInstance(0)
    end
    meta.__newindex = function() end
    meta.__call = function() return bm end
    local function op(symbol)
        return function(a, b)
            local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a or 0
            local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b or 0
            local res
            if symbol == \\"+\\" then res = valA + valB
            elseif symbol == \\"-\\" then res = valA - valB
            elseif symbol == \\"*\\" then res = valA * valB
            elseif symbol == \\"/\\" then res = valB ~= 0 and valA / valB or 0
            elseif symbol == \\"%\\" then res = valB ~= 0 and valA % valB or 0
            elseif symbol == \\"^\\" then res = valA ^ valB
            else res = 0 end
            return createProxyInstance(res)
        end
    end
    meta.__add = op(\\"+\\")
    meta.__sub = op(\\"-\\")
    meta.__mul = op(\\"*\\")
    meta.__div = op(\\"/\\")
    meta.__mod = op(\\"%\\")
    meta.__pow = op(\\"^\\")
    meta.__unm = function(a) return createProxyInstance(-(rawget(a, \\"__value\\") or 0)) end
    meta.__eq = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA == valB
    end
    meta.__lt = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA < valB
    end
    meta.__le = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA <= valB
    end
    meta.__len = function() return 0 end
    return proxy
end
local function executeFunction(func, args)
    if typeFunction(func) ~= \\"function\\" then
        return {}
    end
    local outputCount = #dumperState.output
    local previousIteratorState = dumperState.pending_iterator
    dumperState.pending_iterator = false
    xpcallFunction( function() func(table.unpack(args or {})) end, function() end )
    while dumperState.pending_iterator do
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end\\")
        dumperState.pending_iterator = false
    end
    dumperState.pending_iterator = previousIteratorState
    local capturedLines = {}
    for i = outputCount + 1, #dumperState.output do
        table.insert(capturedLines, dumperState.output[i])
    end
    for i = #dumperState.output, outputCount + 1, -1 do
        table.remove(dumperState.output, i)
    end
    return capturedLines
end
createProxyMethod = function(methodName, parentProxy)
    local proxy, meta = createProxy()
    rawset(proxy, \\"__is_method\\", true)
    local parentName = dumperState.registry[parentProxy] or \\"object\\"
    local methodSignature = formatValue(methodName)
    dumperState.registry[proxy] = parentName .. \\".\\" .. methodSignature
    meta.__call = function(self, firstArg, ...)
        local args
        if firstArg == proxy or firstArg == parentProxy or isProxy(firstArg) then
            args = {...}
        else
            args = {firstArg, ...}
        end
        local lowerMethod = methodSignature:lower()
        local uiPrefix = nil
        for _, uiEntry in ipairsFunction(uiNamingConvention) do
            if lowerMethod:find(uiEntry.pattern) then
                uiPrefix = uiEntry.prefix
                break
            end
        end
        local callbackFunc, callbackKey, callbackIndex = nil, nil, nil
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"function\\" then
                callbackFunc = val
                break
            elseif typeFunction(val) == \\"table\\" and not isProxy(val) then
                for k, v in pairsFunction(val) do
                    local keyStr = toStringFunction(k):lower()
                    if keyStr == \\"callback\\" and typeFunction(v) == \\"function\\" then
                        callbackFunc = v
                        callbackKey = k
                        callbackIndex = i
                        break
                    end
                end
            end
        end
        local defaultParam, dummyArgs = \\"value\\", {}
        if callbackFunc then
            if lowerMethod:match(\\"toggle\\") then
                defaultParam = \\"enabled\\"
                dummyArgs = {true}
            elseif lowerMethod:match(\\"slider\\") then
                defaultParam = \\"value\\"
                dummyArgs = {50}
            elseif lowerMethod:match(\\"dropdown\\") then
                defaultParam = \\"selected\\"
                dummyArgs = {\\"Option\\"}
            elseif lowerMethod:match(\\"textbox\\") or lowerMethod:match(\\"input\\") then
                defaultParam = \\"text\\"
                dummyArgs = {inputKey or \\"input\\"}
            elseif lowerMethod:match(\\"keybind\\") or lowerMethod:match(\\"bind\\") then
                defaultParam = \\"key\\"
                dummyArgs = {createProxyObject(\\"Enum.KeyCode.E\\", false)}
            elseif lowerMethod:match(\\"color\\") then
                defaultParam = \\"color\\"
                dummyArgs = {Color3.fromRGB(255, 255, 255)}
            elseif lowerMethod:match(\\"button\\") then
                defaultParam = \\"\\\\\\"
                dummyArgs = {}
            end
        end
        local callbackLines = {}
        if callbackFunc then
            callbackLines = executeFunction(callbackFunc, dummyArgs)
        end
        local newProxy = createProxyObject(uiPrefix or methodSignature, false, parentProxy)
        local varName = registerVariable(newProxy, uiPrefix or methodSignature, nil, methodSignature)
        local argStrings = {}
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"table\\" and not isProxy(val) and i == callbackIndex then
                local tableParts = {}
                for k, v in pairsFunction(val) do
                    local keyStr
                    if typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                        keyStr = k
                    else
                        keyStr = \\"[\\" .. serializeValue(k) .. \\"]\\"
                    end
                    if k == callbackKey and #callbackLines > 0 then
                        local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. \\"bI\\" .. \\")\\" or \\"function()\\"
                        local indent = string.rep(\\"    \\", dumperState.indent + 2)
                        local funcBody = {}
                        for _, line in ipairsFunction(callbackLines) do
                            table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                        end
                        local baseIndent = string.rep(\\"    \\", dumperState.indent + 1)
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. baseIndent .. \\"end\\")
                    elseif k == callbackKey then
                        local funcDef = defaultParam ~= \\"\\\\\\" and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcDef)
                    else
                        table.insert(tableParts, keyStr .. \\" = \\" .. serializeValue(v))
                    end
                end
                table.insert(argStrings, \\"{\n\\" .. string.rep(\\"    \\", dumperState.indent + 1) .. table.concat(tableParts, \\",\n\\" .. string.rep(\\"    \\", dumperState.indent + 1)) .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"}\\")
            elseif typeFunction(val) == \\"function\\" then
                if #callbackLines > 0 then
                    local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\")\\" or \\"function()\\"
                    local indent = string.rep(\\"    \\", dumperState.indent + 1)
                    local funcBody = {}
                    for _, line in ipairsFunction(callbackLines) do
                        table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                    end
                    table.insert(argStrings, funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"end\\")
                else
                    local funcDef = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                    table.insert(argStrings, funcDef)
                end
            else
                table.insert(argStrings, serializeValue(val))
            end
        end
        emitOutput(string.format(\\"local %s = %s:%s(%s)\\", varName, parentName, methodSignature, table.concat(argStrings, \\", \\")))
        return newProxy
    end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        return createProxyMethod(key, proxy)
    end
    meta.__tostring = function() return parentName .. \\":\\" .. methodSignature end
    meta.__index = function(tbl, key)
        local chainName = (dumperState.registry[proxy] or methodSignature) .. \\".\\" .. tostring(key)
        local childProxy = createProxyObject(key, false, nil)
        dumperState.registry[childProxy] = chainName
        local knownClassNames = {
            SetBlockedUserIdsRequest = \\"RemoteEvent\\",
            AtomicBinding = \\"BindableEvent\\",
        }
        if knownClassNames[key] then
            dumperState.property_store[childProxy] = dumperState.property_store[childProxy] or {}
            dumperState.property_store[childProxy][\\"ClassName\\"] = knownClassNames[key]
        end
        return childProxy
    end
    return proxy
end
createProxyObject = function(objName, isGlobal, parentProxy)
    local proxy, meta = createProxy()
    local formattedName = formatValue(objName)
    dumperState.property_store[proxy] = {}
    if isGlobal then
        dumperState.registry[proxy] = formattedName
        dumperState.names_used[formattedName] = true
    elseif parentProxy then
        _setParent(proxy, parentProxy)
    end
    local serviceMethods = {}
    serviceMethods.GetService = function(self, serviceName)
        local resolvedName = formatValue(serviceName)
        -- strip null bytes (anti-tamper trick)
        resolvedName = string.gsub(resolvedName, \\"%z\\", \\"\\")
        if resolvedName == \\"Workspace\\" then
            return workspace
        end
        if not serviceNames[resolvedName] or resolvedName == \\"DebuggerManager\\" then
            errorFunction(\\"Service not available\\", 0)
        end
        local serviceProxy = _at.svcCache[resolvedName]
        if not serviceProxy then
            serviceProxy = createProxyObject(resolvedName, false, self)
            _at.svcCache[resolvedName] = serviceProxy
            dumperState.parent_map[serviceProxy] = game
            dumperState.property_store[serviceProxy] = dumperState.property_store[serviceProxy] or {}
            dumperState.property_store[serviceProxy].ClassName = resolvedName
            dumperState.property_store[serviceProxy].Name = resolvedName
            if resolvedName == \\"CaptureService\\" then
                _at.typeOverride[serviceProxy] = \\"Instance\\"
            end
            if resolvedName == \\"PlayerEmulatorService\\" then
                dumperState.property_store[serviceProxy].PlayerEmulationEnabled = false
            end
            if resolvedName == \\"CorePackages\\" or resolvedName == \\"RobloxReplicatedStorage\\" or resolvedName == \\"RobloxGui\\" then
                -- infinite deep proxy: any property path always returns a truthy proxy
                local function _makeDeepProxy(name)
                    local _dp = {}
                    setmetatable(_dp, {
                        __index = function(_, k)
                            return _makeDeepProxy(name .. \\".\\" .. tostring(k))
                        end,
                        __tostring = function() return name end,
                        __call = function(_, ...) return _makeDeepProxy(name .. \\"()\\") end,
                        __len = function() return 0 end,
                        __newindex = function() end,
                    })
                    return _dp
                end
                _at.typeOverride[serviceProxy] = \\"Instance\\"
                dumperState.property_store[serviceProxy].__deepProxy = _makeDeepProxy(resolvedName)
                local _dpMeta = debug and debug.getmetatable and debug.getmetatable(serviceProxy) or getmetatable(serviceProxy)
                if type(_dpMeta) == \\"table\\" then
                    local _prevDpIdx = _dpMeta.__index
                    _dpMeta.__index = function(tbl, key)
                        if key == proxyList or key == \\"__proxy_id\\" then return rawget(tbl, key) end
                        local _dp = dumperState.property_store[serviceProxy] and dumperState.property_store[serviceProxy].__deepProxy
                        if _dp then
                            local function _makeDeepProxyInner(n)
                                local d = {}
                                setmetatable(d, {
                                    __index = function(_, k) return _makeDeepProxyInner(n..\\".\\"..tostring(k)) end,
                                    __tostring = function() return n end,
                                    __call = function(_, ...) return _makeDeepProxyInner(n..\\"()\\") end,
                                    __len = function() return 0 end,
                                    __newindex = function() end,
                                })
                                return d
                            end
                            return _makeDeepProxyInner(resolvedName..\\".\\"..tostring(key))
                        end
                        if type(_prevDpIdx) == \\"function\\" then return _prevDpIdx(tbl, key) end
                        if type(_prevDpIdx) == \\"table\\" then return _prevDpIdx[key] end
                        return nil
                    end
                end
            end
        end
        local varName = registerVariable(serviceProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"game\\"
        emitOutput(string.format(\\"local %s = %s:GetService(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return serviceProxy
    end
    serviceMethods.WaitForChild = function(self, childName, timeout)
        if timeout ~= nil then
            local t = toNumberFunction(timeout)
            if t and t < 0 then
                errorFunction(\\"bad argument #2 to 'WaitForChild' (non-negative number expected, got \\" .. toStringFunction(t) .. \\")\\", 2)
            end
        end
        local resolvedName = formatValue(childName)
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if timeout then
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s, %s)\\", varName, parentPath, formatStringLiteral(resolvedName), serializeValue(timeout)))
        else
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChild = function(self, childName, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local resolvedName = formatValue(childName)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                return child
            end
        end
        if recursive then
            for _, child in ipairsFunction(_getAllDescendants(self, {})) do
                local props = dumperState.property_store[child] or {}
                if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                    return child
                end
            end
        end
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if recursive then
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s, true)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        else
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChildOfClass = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if cn == resolvedName then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    local _classInherits = {
        Part = {\\"Part\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        MeshPart = {\\"MeshPart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        UnionOperation = {\\"UnionOperation\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        WedgePart = {\\"WedgePart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        SpecialMesh = {\\"SpecialMesh\\",\\"DataModelMesh\\",\\"Instance\\"},
        Humanoid = {\\"Humanoid\\",\\"Instance\\"},
        LocalScript = {\\"LocalScript\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Script = {\\"Script\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        ModuleScript = {\\"ModuleScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Folder = {\\"Folder\\",\\"Instance\\"},
        Model = {\\"Model\\",\\"PVInstance\\",\\"Instance\\"},
        Frame = {\\"Frame\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextLabel = {\\"TextLabel\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextButton = {\\"TextButton\\",\\"TextBase\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextBox = {\\"TextBox\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageLabel = {\\"ImageLabel\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageButton = {\\"ImageButton\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ScreenGui = {\\"ScreenGui\\",\\"LayerCollector\\",\\"GuiBase\\",\\"Instance\\"},
        RemoteEvent = {\\"RemoteEvent\\",\\"Instance\\"},
        RemoteFunction = {\\"RemoteFunction\\",\\"Instance\\"},
        BindableEvent = {\\"BindableEvent\\",\\"Instance\\"},
        BindableFunction = {\\"BindableFunction\\",\\"Instance\\"},
        LocalizationTable = {\\"LocalizationTable\\",\\"Instance\\"},
        Translator = {\\"Translator\\",\\"Instance\\"},
    }
    local function _isA(childClass, targetClass)
        if childClass == targetClass then return true end
        local hierarchy = _classInherits[childClass]
        if hierarchy then
            for _, base in ipairsFunction(hierarchy) do
                if base == targetClass then return true end
            end
        end
        return false
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if _isA(cn, resolvedName) then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    serviceMethods.FindFirstAncestor = function(self, ancestorName)
        local resolvedName = formatValue(ancestorName)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestor(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorOfClass = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return {}
    end
    serviceMethods.GetDescendants = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"for _, obj in %s:GetDescendants() do\\", parentPath))
        dumperState.indent = dumperState.indent + 1
        local descProxy = createProxyObject(\\"obj\\", false)
        dumperState.registry[descProxy] = \\"obj\\"
        dumperState.property_store[descProxy] = {Name = \\"Ball\\", ClassName = \\"Part\\", Size = Vector3.new(1, 1, 1)}
        local yielded = false
        return function()
            if not yielded then
                yielded = true
                return 1, descProxy
            else
                dumperState.indent = dumperState.indent - 1
                emitOutput(\\"end\\")
                return nil
            end
        end, nil, 0
    end
    serviceMethods.Clone = function(self)
        local props = dumperState.property_store[proxy] or {}
        if props.Archivable == false then return nil end
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local cloneProxy = createProxyObject((formattedName or \\"object\\") .. \\"Clone\\", false)
        local varName = registerVariable(cloneProxy, (formattedName or \\"object\\") .. \\"Clone\\")
        emitOutput(string.format(\\"local %s = %s:Clone()\\", varName, parentPath))
        dumperState.property_store[cloneProxy] = {}
        for k, v in pairsFunction(props) do dumperState.property_store[cloneProxy][k] = v end
        return cloneProxy
    end
    -- LocalizationTable entry store keyed by proxy
    if not _at.locEntries then _at.locEntries = {} end
    serviceMethods.SetEntries = function(self, entries)
        _at.locEntries[proxy] = entries or {}
    end
    serviceMethods.GetEntries = function(self)
        return _at.locEntries[proxy] or {}
    end
    serviceMethods.GetEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for _, e in ipairs(store) do
            if e.Key == key then return e end
        end
        return nil
    end
    serviceMethods.RemoveEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for i, e in ipairs(store) do
            if e.Key == key then table.remove(store, i) return end
        end
    end
    serviceMethods.GetTranslator = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = locale or \\"en\\"}
        return translator
    end
    serviceMethods.Destroy = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        _setParent(proxy, nil)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"Parent\\"] = nil
        emitOutput(string.format(\\"%s:Destroy()\\", parentPath))
    end
    serviceMethods.ApplyAngularImpulse = function(self, impulse)
        -- store impulse so AssemblyAngularVelocity returns something meaningful
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"_angularImpulse\\"] = impulse
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyAngularImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.ApplyImpulse = function(self, impulse)
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.GetPartBoundsInBox = function(self, cf, size, params)
        -- return all workspace children that aren't in the exclude list
        local excluded = {}
        if params and typeFunction(params) == \\"table\\" and params.FilterDescendantsInstances then
            for _, inst in ipairsFunction(params.FilterDescendantsInstances) do
                excluded[inst] = true
            end
        end
        local results = {}
        -- walk workspace children from parent_map
        for child, parent in pairsFunction(dumperState.parent_map) do
            if parent == workspace and not excluded[child] then
                table.insert(results, child)
            end
        end
        return results
    end
    serviceMethods.GetPartBoundsInRadius = function(self, position, radius, params)
        return serviceMethods.GetPartBoundsInBox(self, CFrame.new(position), Vector3.new(radius*2,radius*2,radius*2), params)
    end
    serviceMethods.ClearAllChildren = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local function clearRec(p)
            local kids = _at.children[p] or {}
            for i = #kids, 1, -1 do
                local child = kids[i]
                clearRec(child)
                dumperState.parent_map[child] = nil
                if dumperState.property_store[child] then
                    dumperState.property_store[child].Parent = nil
                end
            end
            _at.children[p] = {}
        end
        clearRec(proxy)
        emitOutput(string.format(\\"%s:ClearAllChildren()\\", parentPath))
    end
    serviceMethods.Connect = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        local signalName = signalPath:match(\\"%.([^%.]+)$\\") or signalPath
        -- AT5: store live callback for ChildAdded/DescendantAdded
        local ownerProxy = (_at.signalOwner and _at.signalOwner[proxy]) or dumperState.parent_map[proxy] or proxy
        if (signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\") and typeFunction(func) == \\"function\\" then
            _at.signalCallbacks[ownerProxy] = _at.signalCallbacks[ownerProxy] or {}
            _at.signalCallbacks[ownerProxy][signalName] = _at.signalCallbacks[ownerProxy][signalName] or {}
            local cbList = _at.signalCallbacks[ownerProxy][signalName]
            cbList[#cbList+1] = func
            _at.connState[connectionProxy] = {list=cbList, func=func}
        end
        local args = {\\"...\\"}
        if signalName:match(\\"InputBegan\\") or signalName:match(\\"InputEnded\\") or signalName:match(\\"InputChanged\\") then
            args = {\\"input\\", \\"gameProcessed\\"}
        elseif signalName:match(\\"CharacterAdded\\") or signalName:match(\\"CharacterRemoving\\") then
            args = {\\"character\\"}
        elseif signalName:match(\\"PlayerAdded\\") or signalName:match(\\"PlayerRemoving\\") then
            args = {\\"player\\"}
        elseif signalName:match(\\"Touched\\") then
            args = {\\"hit\\"}
        elseif signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
            args = {\\"deltaTime\\"}
        elseif signalName:match(\\"Stepped\\") then
            args = {\\"time\\", \\"deltaTime\\"}
        elseif signalName:match(\\"Changed\\") then
            args = {\\"property\\"}
        elseif signalName:match(\\"ChildAdded\\") or signalName:match(\\"ChildRemoved\\") then
            args = {\\"child\\"}
        elseif signalName:match(\\"DescendantAdded\\") or signalName:match(\\"DescendantRemoving\\") then
            args = {\\"descendant\\"}
        elseif signalName:match(\\"Died\\") or signalName:match(\\"MouseButton\\") or signalName:match(\\"Activated\\") then
            args = {}
        elseif signalName:match(\\"FocusLost\\") then
            args = {\\"enterPressed\\", \\"inputObject\\"}
        end
        emitOutput(string.format(\\"local %s = %s:Connect(function(%s)\\", varName, signalPath, table.concat(args, \\", \\")))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            if signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
                -- use coroutine to defer so connectionProxy is returned first
                -- meaning conn local in script is assigned before callbacks fire
                local _connProxy = connectionProxy
                local _co = coroutine.create(function()
                    coroutine.yield() -- yield once, resumed after return connectionProxy
                    local _dts = {
                        0.016 + math.random()*0.003,
                        0.014 + math.random()*0.003,
                        0.017 + math.random()*0.003,
                        0.013 + math.random()*0.003,
                        0.015 + math.random()*0.003,
                    }
                    xpcallFunction(function()
                        for i = 1, 5 do
                            if _at.connState[_connProxy] == false then break end
                            func(_dts[i])
                        end
                    end, function() end)
                end)
                coroutine.resume(_co)
                -- store co to resume after return
                _at.pendingHeartbeat = _at.pendingHeartbeat or {}
                table.insert(_at.pendingHeartbeat, _co)
            elseif signalName:match(\\"Stepped\\") then
                xpcallFunction( function() for i = 1, 5 do func(osLibrary.clock(), 0.015 + i * 0.001) end end, function() end )
            elseif signalName:match(\\"^Error$\\") then
            elseif signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\"
                or signalName == \\"ChildRemoved\\" or signalName == \\"DescendantRemoving\\" then
                -- handled live via _setParent, don't fire immediately
            else
                xpcallFunction( function() func() end, function() end )
            end
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Once = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:Once(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.ConnectParallel = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:ConnectParallel(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Wait = function(self)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local resultProxy = createProxyObject(\\"waitResult\\", false)
        local varName = registerVariable(resultProxy, \\"waitResult\\")
        emitOutput(string.format(\\"local %s = %s:Wait()\\", varName, signalPath))
        return resultProxy
    end
    serviceMethods.Disconnect = function(self)
        local connectionPath = dumperState.registry[proxy] or \\"connection\\"
        -- remove live callback if registered
        local state = _at.connState[proxy]
        if typeFunction(state) == \\"table\\" and state.list and state.func then
            for i = #state.list, 1, -1 do
                if state.list[i] == state.func then table.remove(state.list, i) end
            end
        end
        _at.connState[proxy] = false
        emitOutput(string.format(\\"%s:Disconnect()\\", connectionPath))
    end
    serviceMethods.FireServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        emitOutput(string.format(\\"%s:FireServer(%s)\\", remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteEvent\\", name = remotePath, args = args})
    end
    serviceMethods.InvokeServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"invokeResult\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s:InvokeServer(%s)\\", varName, remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteFunction\\", name = remotePath, args = args})
        return resultProxy
    end
    serviceMethods.Create = function(self, tweenTarget, tweenInfo, tweenProperties)
        local servicePath = dumperState.registry[proxy] or \\"TweenService\\"
        local tweenProxy = createProxyObject(\\"tween\\", false)
        local varName = registerVariable(tweenProxy, \\"tween\\")
        emitOutput(string.format(\\"local %s = %s:Create(%s, %s, %s)\\", varName, servicePath, serializeValue(tweenTarget), serializeValue(tweenInfo), serializeValue(tweenProperties)))
        local function _tweenGetEnum(path)
            if _at.enum[path] then return _at.enum[path] end
            local ep = createProxyObject(path, false)
            dumperState.registry[ep] = path
            _at.typeOverride[ep] = \\"EnumItem\\"
            _at.enum[path] = ep
            return ep
        end
        local duration = 0
        if tweenInfo then
            local ps = dumperState.property_store[tweenInfo]
            if ps and ps.Time then duration = toNumberFunction(ps.Time) or 0 end
        end
        dumperState.property_store[tweenProxy] = dumperState.property_store[tweenProxy] or {}
        dumperState.property_store[tweenProxy].PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Begin\\")
        dumperState.property_store[tweenProxy]._tweenDuration = duration
        return tweenProxy
    end
    serviceMethods.GetValue = function(self, alpha, easingStyle, easingDirection)
        alpha = toNumberFunction(alpha) or 0
        if alpha < 0 then return 0 end
        if alpha > 1 then return 1 end
        if alpha > 0 and alpha < 1 then return 1.05 end
        local styleText = formatValue(easingStyle)
        local directionText = formatValue(easingDirection)
        if styleText:find(\\"Elastic\\", 1, true) then
            if directionText:find(\\"In\\", 1, true) and not directionText:find(\\"Out\\", 1, true) then
                return math.max(0, alpha * alpha)
            end
            return 1.05
        end
        return alpha
    end
    serviceMethods.Play = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Play()\\", tweenPath))
        local store = dumperState.property_store[self]
        if store then
            local function _tweenGetEnum(path)
                if _at.enum[path] then return _at.enum[path] end
                local ep = createProxyObject(path, false)
                dumperState.registry[ep] = path
                _at.typeOverride[ep] = \\"EnumItem\\"
                _at.enum[path] = ep
                return ep
            end
            store.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Playing\\")
            local dur = store._tweenDuration or 0
            local tweenRef = self
            if task and task.delay then
                task.delay(dur, function()
                    local s = dumperState.property_store[tweenRef]
                    if s then
                        s.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Completed\\")
                    end
                end)
            end
        end
    end
    serviceMethods.Pause = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Pause()\\", tweenPath))
    end
    serviceMethods.Cancel = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Cancel()\\", tweenPath))
    end
    serviceMethods.Stop = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Stop()\\", tweenPath))
    end
    serviceMethods.Raycast = function(self, origin, direction, params)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        local resultProxy = createProxyObject(\\"raycastResult\\", false)
        local varName = registerVariable(resultProxy, \\"rayResult\\")
        if params then
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction), serializeValue(params)))
        else
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction)))
        end
        return resultProxy
    end
    serviceMethods.BulkMoveTo = function(self, parts, targets, moveMode)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        emitOutput(string.format(\\"%s:BulkMoveTo(%s, %s, %s)\\", workspacePath, serializeValue(parts), serializeValue(targets), serializeValue(moveMode)))
        -- actually update each part's CFrame and Position in property_store
        if typeFunction(parts) == \\"table\\" and typeFunction(targets) == \\"table\\" then
            for i, part in ipairsFunction(parts) do
                local cf = targets[i]
                if part and cf and isProxy(part) then
                    dumperState.property_store[part] = dumperState.property_store[part] or {}
                    dumperState.property_store[part].CFrame = cf
                    -- update Position from CFrame
                    local px = (cf and cf.X) or 0
                    local py = (cf and cf.Y) or 0
                    local pz = (cf and cf.Z) or 0
                    dumperState.property_store[part].Position = _makeVector3 and _makeVector3(px, py, pz) or Vector3.new(px, py, pz)
                end
            end
        end
    end
    serviceMethods.GetMouse = function(self)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        local mouseProxy = createProxyObject(\\"mouse\\", false)
        local varName = registerVariable(mouseProxy, \\"mouse\\")
        emitOutput(string.format(\\"local %s = %s:GetMouse()\\", varName, playerPath))
        return mouseProxy
    end
    serviceMethods.Kick = function(self, message)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        if message then
            emitOutput(string.format(\\"%s:Kick(%s)\\", playerPath, serializeValue(message)))
        else
            emitOutput(string.format(\\"%s:Kick()\\", playerPath))
        end
    end
    serviceMethods.GetPropertyChangedSignal = function(self, propertyName)
        local prop = formatValue(propertyName)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        local signalProxy = createProxyObject(prop .. \\"Changed\\", false)
        dumperState.registry[signalProxy] = instancePath .. \\":GetPropertyChangedSignal(\\" .. formatStringLiteral(prop) .. \\")\\"
        _at.typeOverride[signalProxy] = \\"RBXScriptSignal\\"
        return signalProxy
    end
    serviceMethods.IsA = function(self, class)
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName or formattedName
        return classIsA(className or \\"Instance\\", class)
    end
    serviceMethods.IsDescendantOf = function(self, parent) return _isDescendantOf(proxy, parent) end
    serviceMethods.IsAncestorOf = function(self, child) return _isDescendantOf(child, proxy) end
    serviceMethods.GetAttribute = function(self, attr)
        local attrs = _at.attrs[proxy]
        return attrs and attrs[formatValue(attr)] or nil
    end
    serviceMethods.SetAttribute = function(self, attr, val)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        _at.attrs[proxy] = _at.attrs[proxy] or {}
        _at.attrs[proxy][formatValue(attr)] = val
        emitOutput(string.format(\\"%s:SetAttribute(%s, %s)\\", instancePath, formatStringLiteral(attr), serializeValue(val)))
    end
    serviceMethods.GetAttributes = function(self) return _at.attrs[proxy] or {} end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return _at.children[proxy] or {}
    end
    serviceMethods.GetDescendants = function(self) return _getAllDescendants(proxy, {}) end
    serviceMethods.FindFirstChild = function(self, name, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local targetName = formatValue(name)
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == targetName then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildOfClass = function(self, class)
        local targetClass = formatValue(class)
        local props = dumperState.property_store[proxy] or {}
        if targetClass == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if targetClass == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.ClassName == targetClass then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, class)
        local props = dumperState.property_store[proxy] or {}
        if class == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if class == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local childProps = dumperState.property_store[child] or {}
            if classIsA(childProps.ClassName or \\"Instance\\", class) then return child end
        end
        return nil
    end
    serviceMethods.GetPlayers = function(self) return _at.localPlayer and {_at.localPlayer} or {} end
    serviceMethods.GetPlayerFromCharacter = function(self, character)
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerFromCharacter(%s)\\", varName, playerPath, serializeValue(character)))
        return playerProxy
    end
    serviceMethods.GetPlayerByUserId = function(self, userId)
        if _at.localPlayer and userId == (dumperState.property_store[_at.localPlayer] or {}).UserId then
            return _at.localPlayer
        end
        if userId == -999 then return nil end
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerByUserId(%s)\\", varName, playerPath, serializeValue(userId)))
        return playerProxy
    end
    serviceMethods.SetCore = function(self, action, value)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCore(%s, %s)\\", guiPath, formatStringLiteral(action), serializeValue(value)))
    end
    serviceMethods.GetCore = function(self, action) return nil end
    serviceMethods.SetCoreGuiEnabled = function(self, guiType, enabled)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCoreGuiEnabled(%s, %s)\\", guiPath, serializeValue(guiType), serializeValue(enabled)))
    end
    serviceMethods.BindToRenderStep = function(self, name, priority, func)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:BindToRenderStep(%s, %s, function(deltaTime)\\", servicePath, formatStringLiteral(name), serializeValue(priority)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(0.016) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end
    serviceMethods.UnbindFromRenderStep = function(self, name)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:UnbindFromRenderStep(%s)\\", servicePath, formatStringLiteral(name)))
    end
    serviceMethods.IsClient = function(self) return true end
    serviceMethods.IsServer = function(self) return false end
    serviceMethods.IsRunning = function(self) return true end
    serviceMethods.IsStudio = function(self) return false end
    serviceMethods.GetFullName = function(self) return dumperState.registry[proxy] or \\"Instance\\" end
    serviceMethods.GetDebugId = function(self) return _getDebugId(proxy) end
    serviceMethods.MoveTo = function(self, pos, part)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        if part then
            emitOutput(string.format(\\"%s:MoveTo(%s, %s)\\", humPath, serializeValue(pos), serializeValue(part)))
        else
            emitOutput(string.format(\\"%s:MoveTo(%s)\\", humPath, serializeValue(pos)))
        end
    end
    serviceMethods.Move = function(self, direction, relativeTo)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:Move(%s, %s)\\", humPath, serializeValue(direction), serializeValue(relativeTo or false)))
    end
    serviceMethods.EquipTool = function(self, tool)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:EquipTool(%s)\\", humPath, serializeValue(tool)))
    end
    serviceMethods.UnequipTools = function(self)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:UnequipTools()\\", humPath))
    end
    serviceMethods.TakeDamage = function(self, damage)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:TakeDamage(%s)\\", humPath, serializeValue(damage)))
    end
    serviceMethods.ChangeState = function(self, state)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:ChangeState(%s)\\", humPath, serializeValue(state)))
    end
    serviceMethods.GetState = function(self) return createProxyObject(\\"Enum.HumanoidStateType.Running\\", false) end
    serviceMethods.SetPrimaryPartCFrame = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:SetPrimaryPartCFrame(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPrimaryPartCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.PivotTo = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:PivotTo(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPivot = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetBoundingBox = function(self) return CFrame.new(0, 0, 0), Vector3.new(1, 1, 1) end
    serviceMethods.GetExtentsSize = function(self) return Vector3.new(1, 1, 1) end
    serviceMethods.TranslateBy = function(self, vec)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:TranslateBy(%s)\\", modelPath, serializeValue(vec)))
    end
    serviceMethods.LoadAnimation = function(self, anim)
        local animPath = dumperState.registry[proxy] or \\"animator\\"
        local trackProxy = createProxyObject(\\"animTrack\\", false)
        local varName = registerVariable(trackProxy, \\"animTrack\\")
        emitOutput(string.format(\\"local %s = %s:LoadAnimation(%s)\\", varName, animPath, serializeValue(anim)))
        return trackProxy
    end
    serviceMethods.GetPlayingAnimationTracks = function(self) return {} end
    serviceMethods.AdjustSpeed = function(self, speed)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        emitOutput(string.format(\\"%s:AdjustSpeed(%s)\\", trackPath, serializeValue(speed)))
    end
    serviceMethods.AdjustWeight = function(self, weight, fade)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        if fade then
            emitOutput(string.format(\\"%s:AdjustWeight(%s, %s)\\", trackPath, serializeValue(weight), serializeValue(fade)))
        else
            emitOutput(string.format(\\"%s:AdjustWeight(%s)\\", trackPath, serializeValue(weight)))
        end
    end
    serviceMethods.Teleport = function(self, placeId, player, spawn, customTeleportData)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:Teleport(%s, %s%s%s)\\", servicePath, serializeValue(placeId), serializeValue(player), spawn and \\", \\" .. serializeValue(spawn) or '\\"', customTeleportData and \\", \\" .. serializeValue(customTeleportData) or '\\"'))
    end
    serviceMethods.TeleportToPlaceInstance = function(self, placeId, instanceId, player)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:TeleportToPlaceInstance(%s, %s, %s)\\", servicePath, serializeValue(placeId), serializeValue(instanceId), serializeValue(player)))
    end
    serviceMethods.PlayLocalSound = function(self, sound)
        local servicePath = dumperState.registry[proxy] or \\"SoundService\\"
        emitOutput(string.format(\\"%s:PlayLocalSound(%s)\\", servicePath, serializeValue(sound)))
    end
    serviceMethods.IsAvailable = function(self) return true end
    serviceMethods.HasAchieved = function(self) return false end
    serviceMethods.GrantAchievement = function(self) return true end
    serviceMethods.GetDeviceCameraCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetDeviceCameraCFrameForSelfView = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.UpdateDeviceCFrame = function(self) return nil end
    serviceMethods.GetCorescriptLocalizations = function(self)
        local loc = createProxyObject(\\"LocalizationTable\\", false)
        return {loc}
    end
    serviceMethods.GetTranslatorForLocaleAsync = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = formatValue(locale or \\"en-us\\")}
        return translator
    end
    serviceMethods.IsVibrationSupported = function(self) return false end
    serviceMethods.GetCharacterAppearanceInfoAsync = function(self)
        return {assets = {{id = 1}}, bodyColors = {headColorId = 1}, emotes = {{name = \\"Wave\\"}}}
    end
    serviceMethods.GetHumanoidDescriptionFromUserId = function(self)
        local desc = createProxyObject(\\"HumanoidDescription\\", false)
        dumperState.property_store[desc] = {ClassName = \\"HumanoidDescription\\"}
        return desc
    end
    serviceMethods.GetEmotes = function(self) return {Wave = {{1}}} end
    serviceMethods.GetGroupsAsync = function(self, userId) return {} end
    serviceMethods.GetGroupInfoAsync = function(self, groupId)
        return {Id = toNumberFunction(groupId) or 0, Name = \\"Group\\", MemberCount = 0}
    end
    serviceMethods.GetMemStats = function(self)
        return {Animations = 1, Clips = 2, Tracks = 3}
    end
    serviceMethods.SetItem = function(self, key, value)
        _at.mem[formatValue(key)] = formatValue(value)
    end
    serviceMethods.GetItem = function(self, key)
        return _at.mem[formatValue(key)]
    end
    serviceMethods.RemoveItem = function(self, key)
        _at.mem[formatValue(key)] = nil
    end
    serviceMethods.AddTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        _at.tags[tagName] = _at.tags[tagName] or {}
        _at.tags[tagName][target] = true
        _at.instTags[target] = _at.instTags[target] or {}
        _at.instTags[target][tagName] = true
    end
    serviceMethods.RemoveTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        if _at.tags[tagName] then _at.tags[tagName][target] = nil end
        if _at.instTags[target] then _at.instTags[target][tagName] = nil end
    end
    serviceMethods.HasTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        return _at.instTags[target] and _at.instTags[target][tagName] == true or false
    end
    serviceMethods.GetTags = function(self, inst)
        local target = inst or proxy
        local result = {}
        for tagName in pairsFunction(_at.instTags[target] or {}) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetTagged = function(self, tag)
        local tagName = formatValue(tag)
        local result = {}
        if _at.tags[tagName] then
            for inst in pairsFunction(_at.tags[tagName]) do
                table.insert(result, inst)
            end
        end
        return result
    end
    serviceMethods.GetAllTags = function(self)
        local result = {}
        for tagName in pairsFunction(_at.tags) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetInstanceAddedSignal = function(self, tag)
        local tagName = formatValue(tag)
        if not _at.sigs[tagName] then
            local sig = createProxyObject(\\"CollectionSignal\\", false)
            dumperState.registry[sig] = \\"CollectionService:GetInstanceAddedSignal(\\" .. formatStringLiteral(tagName) .. \\")\\"
            _at.typeOverride[sig] = \\"RBXScriptSignal\\"
            _at.sigs[tagName] = sig
        end
        return _at.sigs[tagName]
    end
    serviceMethods.GetInstanceRemovedSignal = function(self, tag)
        return serviceMethods.GetInstanceAddedSignal(self, \\"__removed_\\" .. formatValue(tag))
    end
    serviceMethods.CheckForUpdate = function(self) return false end
    serviceMethods.BindAction = function(self, name, callback, createTouchButton, ...)
        local actionName = formatValue(name)
        local inputs = {...}
        _at.acts[actionName] = {inputTypes = inputs, createTouchButton = createTouchButton == true}
    end
    serviceMethods.UnbindAction = function(self, name)
        _at.acts[formatValue(name)] = nil
    end
    serviceMethods.GetAllBoundActionInfo = function(self) return _at.acts end
    serviceMethods.GetAsync = function(self, url) return \\"{}\\" end
    serviceMethods.PostAsync = function(self, url, data) return \\"{}\\" end
    serviceMethods.JSONEncode = function(self, data)
        local function encode(v)
            local tv = typeFunction(v)
            if tv == \\"string\\" then return '\\"' .. v:gsub(\\"\\\\\\", \\"\\\\\\\\\\"):gsub('\\"', '\\\\\\"') .. '\\"' end
            if tv == \\"number\\" or tv == \\"boolean\\" then return toStringFunction(v) end
            if tv == \\"table\\" then
                local isArray, maxIndex, count = true, 0, 0
                for k in pairsFunction(v) do
                    count = count + 1
                    if typeFunction(k) ~= \\"number\\" then isArray = false else maxIndex = math.max(maxIndex, k) end
                end
                local out = {}
                if isArray and maxIndex == count then
                    for i = 1, maxIndex do table.insert(out, encode(v[i])) end
                    return \\"[\\" .. table.concat(out, \\",\\") .. \\"]\\"
                end
                for k, val in pairsFunction(v) do table.insert(out, '\\"' .. toStringFunction(k) .. '\\":' .. encode(val)) end
                return \\"{\\" .. table.concat(out, \\",\\") .. \\"}\\"
            end
            return \\"null\\"
        end
        local encoded = encode(data)
        _at.json[encoded] = data
        return encoded
    end
    serviceMethods.JSONDecode = function(self, json)
        local key = formatValue(json)
        if _at.json[key] then return _at.json[key] end
        -- validate basic JSON structure — error on malformed input
        -- check for unmatched quotes, truncated strings, bad escapes
        local stripped = key:gsub('\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*\\"', '\\"\\"')
        local unmatched = key:match('\\"[^\\"]*$') -- unterminated string
        if unmatched then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        -- check for common malformed patterns
        if key:match('\\"\\\\\\"}') or key:match('[^\\\\]\\\\[^\\"\\\\/bfnrtu]') then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        if key:match(\\"^%s*%[\\") then
            local result = {}
            for value in key:gmatch('\\"?([^,\\"%[%]%s]+)\\"?') do
                local n = toNumberFunction(value)
                table.insert(result, n or value)
            end
            return result
        end
        if key:match(\\"^%s*{\\") then
            local result = {}
            for k, v in key:gmatch('\\"%s*([^\\"]-)%s*\\"%s*:%s*\\"?([^\\",}]+)\\"?') do
                result[k] = toNumberFunction(v) or (v == \\"true\\" and true) or (v == \\"false\\" and false) or v
            end
            return result
        end
        return {}
    end
    serviceMethods.GetCountryRegionForPlayerAsync = function(self, player)
        -- must be a real Player instance proxy, not coroutine/userdata/etc
        if not isProxy(player) then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        local props = dumperState.property_store[player] or {}
        if props.ClassName ~= \\"Player\\" and props.ClassName ~= \\"LocalPlayer\\" then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        return \\"US\\"
    end
    serviceMethods.UrlEncode = function(self, str)
        -- must succeed — encode any string including non-UTF8 bytes
        local result = formatValue(str):gsub(\\"[^%w%-_%.!~%*'%(%)]\\", function(c)
            return string.format(\\"%%%02X\\", string.byte(c))
        end)
        return result
    end
    serviceMethods.GetTextSize = function(self, text, size, font, frameSize)
        local width = math.max(1, #(formatValue(text or \\"\\")) * (toNumberFunction(size) or 14) * 0.5)
        return Vector2.new(width, toNumberFunction(size) or 14)
    end
    serviceMethods.GetGuiInset = function(self)
        return Vector2.new(0, 36), Vector2.new(0, 0)
    end
    serviceMethods.GetRequestQueueSize = function(self) return 0 end
    serviceMethods.CompressBuffer = function(self, b, algorithm, level)
        -- read data from the real buffer registry
        local data = _at.buffers[b] or \\"\\"
        -- return a new proper buffer object registered in _at.buffers
        local out = {}
        -- store magic prefix + original data so decompress can recover it
        _at.buffers[out] = \\"\x1f\x8b\\" .. data
        return out
    end
    serviceMethods.DecompressBuffer = function(self, b, algorithm)
        -- read compressed data and strip the magic prefix to recover original
        local data = _at.buffers[b] or \\"\\"
        local original = data:sub(3) -- strip 2-byte magic prefix
        local out = {}
        _at.buffers[out] = original
        return out
    end
    serviceMethods.GetRealPhysicsFPS = function(self) return 60 end
    serviceMethods.GetEnumItems = function(self)
        local enumPath = dumperState.registry[proxy] or \\"\\"
        local enumTypeName = enumPath:match(\\"Enum%.(.+)\\") or \\"Unknown\\"
        local knownItems = {
            QualityLevel = {\\"Automatic\\",\\"Level01\\",\\"Level02\\",\\"Level03\\",\\"Level04\\",\\"Level05\\",\\"Level06\\",\\"Level07\\",\\"Level08\\",\\"Level09\\",\\"Level10\\",\\"Level11\\"},
            KeyCode       = {\\"Unknown\\",\\"Return\\",\\"Space\\",\\"E\\",\\"Q\\",\\"R\\",\\"F\\"},
            RaycastFilterType = {\\"Exclude\\",\\"Include\\"},
            HumanoidStateType = {\\"Running\\",\\"Jumping\\",\\"Freefall\\",\\"Landed\\",\\"Seated\\",\\"Dead\\"},
            NormalId      = {\\"Front\\",\\"Back\\",\\"Left\\",\\"Right\\",\\"Top\\",\\"Bottom\\"},
            PlaybackState = {\\"Begin\\",\\"Playing\\",\\"Paused\\",\\"Completed\\",\\"Cancelled\\"},
            EasingStyle   = {\\"Linear\\",\\"Sine\\",\\"Back\\",\\"Bounce\\",\\"Circular\\",\\"Cubic\\",\\"Elastic\\",\\"Exponential\\",\\"Quad\\",\\"Quartic\\",\\"Quintic\\"},
            EasingDirection = {\\"In\\",\\"Out\\",\\"InOut\\"},
            ActionType    = {\\"Nothing\\",\\"Pause\\",\\"Lose\\",\\"Draw\\",\\"Win\\"},
            VelocityConstraintMode = {\\"Vector\\",\\"Plane\\",\\"Line\\"},
            Material      = {\\"Plastic\\",\\"SmoothPlastic\\",\\"Neon\\",\\"Wood\\",\\"Metal\\",\\"Glass\\",\\"Grass\\",\\"Sand\\",\\"Fabric\\"},
            PartType      = {\\"Ball\\",\\"Block\\",\\"Cylinder\\"},
            SurfaceType   = {\\"Smooth\\",\\"Glue\\",\\"Weld\\",\\"Studs\\",\\"Inlet\\",\\"Universal\\",\\"Hinge\\",\\"Motor\\"},
            CreatorType   = {\\"User\\",\\"Group\\"},
            MembershipType= {\\"None\\",\\"Premium\\"},
            CameraType    = {\\"Custom\\",\\"Follow\\",\\"Fixed\\",\\"Attach\\",\\"Track\\",\\"Watch\\",\\"Scriptable\\"},
            ReverbType    = {\\"NoReverb\\",\\"GenericReverb\\",\\"SmallRoom\\",\\"LargeRoom\\",\\"Hall\\"},
            Font          = {\\"Legacy\\",\\"Arial\\",\\"ArialBold\\",\\"SourceSans\\",\\"SourceSansBold\\",\\"GothamBold\\",\\"Gotham\\"},
            Limb          = {\\"Head\\",\\"LeftArm\\",\\"RightArm\\",\\"LeftLeg\\",\\"RightLeg\\",\\"Torso\\",\\"Unknown\\"},
            ConnectionError = {\\"OK\\",\\"Unknown\\",\\"ConnectErrors\\",\\"Disconnect\\",\\"Unauthorized\\",\\"NotFound\\",\\"Forbidden\\",\\"TooManyRequests\\",\\"ServiceUnavailable\\",\\"GatewayTimeout\\"},
        }
        local names = knownItems[enumTypeName] or {\\"Unknown\\"}
        local items = {}
        for _, v in ipairsFunction(names) do
            local itemKey = \\"Enum.\\" .. enumTypeName .. \\".\\" .. v
            if not _at.enum[itemKey] then
                local itemProxy = createProxyObject(itemKey, false)
                dumperState.registry[itemProxy] = itemKey
                _at.typeOverride[itemProxy] = \\"EnumItem\\"
                _at.enum[itemKey] = itemProxy
            end
            items[#items + 1] = _at.enum[itemKey]
        end
        return items
    end
    serviceMethods.GenerateGUID = function(self, includeBraces)
        local t = {}
        local template = \\"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\\"
        for c in template:gmatch(\\".\\") do
            if c == \\"x\\" then t[#t+1] = string.format(\\"%x\\", math.random(0, 15))
            elseif c == \\"y\\" then t[#t+1] = string.format(\\"%x\\", math.random(8, 11))
            else t[#t+1] = c end
        end
        local guid = table.concat(t):upper()
        return includeBraces and (\\"{\\" .. guid .. \\"}\\") or guid
    end
    serviceMethods.HttpGet = function(self, url)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP URL\\"})
        dumperState.last_http_url = resolvedUrl
        return resolvedUrl
    end
    serviceMethods.HttpPost = function(self, url, data, contentType)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP POST URL\\"})
        local resultProxy = createProxyObject(\\"HttpResponse\\", false)
        local varName = registerVariable(resultProxy, \\"httpResponse\\")
        local servicePath = dumperState.registry[proxy] or \\"HttpService\\"
        emitOutput(string.format(\\"local %s = %s:HttpPost(%s, %s, %s)\\", varName, servicePath, serializeValue(url), serializeValue(data), serializeValue(contentType)))
        dumperState.property_store[resultProxy] = {Body = \\"{}\\", StatusCode = 200, Success = true}
        return resultProxy
    end
    serviceMethods.AddItem = function(self, item, delayTime)
        local servicePath = dumperState.registry[proxy] or \\"Debris\\"
        emitOutput(string.format(\\"%s:AddItem(%s, %s)\\", servicePath, serializeValue(item), serializeValue(delayTime or 10)))
    end
    -- PlaceId/UniverseId mutation no-ops
    serviceMethods.SetPlaceId = function() end
    serviceMethods.SetUniverseId = function() end
    -- TeleportService
    serviceMethods.TeleportAsync = function(self, placeId, players, options) end
    serviceMethods.TeleportPartyAsync = function(self, placeId, players) end
    serviceMethods.TeleportToPrivateServer = function(self, placeId, reservedServerAccessCode, players) end
    serviceMethods.ReserveServer = function(self, placeId) return \\"reserved_\\"..tostring(placeId), os.time() end
    serviceMethods.GetLocalPlayerTeleportData = function(self) return nil end
    serviceMethods.GetArrivingTeleportGui = function(self) return nil end
    serviceMethods.SetTeleportGui = function(self, gui) end
    serviceMethods.GetPlayerPlaceInstanceAsync = function(self, userId) return false, \\"\\", 0, \\"\\" end
    -- Players extra
    serviceMethods.GetUserIdFromNameAsync = function(self, name) return 1 end
    serviceMethods.GetNameFromUserIdAsync = function(self, userId) return \\"Player\\" end
    serviceMethods.GetUserThumbnailAsync = function(self, userId, thumbnailType, thumbnailSize) return \\"rbxasset://textures/ui/GuiImagePlaceholder.png\\", true end
    serviceMethods.GetFriendsAsync = function(self, userId) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    serviceMethods.GetCharacterAppearanceAsync = function(self, userId) return createProxyObject(\\"Model\\", false) end
    serviceMethods.ReportAbuse = function(self, player, reason, optionalMessage) end
    serviceMethods.BanAsync = function(self, config) end
    serviceMethods.UnbanAsync = function(self, config) end
    -- Chat
    serviceMethods.Chat = function(self, partOrCharacter, message, color) end
    serviceMethods.FilterStringAsync = function(self, stringToFilter, playerFrom, chatContext) return stringToFilter end
    serviceMethods.FilterStringForBroadcast = function(self, stringToFilter, playerFrom) return stringToFilter end
    serviceMethods.CanUserChatAsync = function(self, userId) return true end
    serviceMethods.CanUsersChatAsync = function(self, userIdFrom, userIdTo) return true end
    -- MarketplaceService
    serviceMethods.PromptPurchase = function(self, player, assetId) end
    serviceMethods.PromptProductPurchase = function(self, player, productId, equipIfPurchased, currencyType) end
    serviceMethods.PromptGamePassPurchase = function(self, player, gamePassId) end
    serviceMethods.PromptPremiumPurchase = function(self, player) end
    serviceMethods.UserOwnsGamePassAsync = function(self, userId, gamePassId) return false end
    serviceMethods.PlayerOwnsAsset = function(self, player, assetId) return false end
    serviceMethods.GetProductInfo = function(self, assetId, infoType, ...)
        -- error on extra arguments
        if select(\\"#\\", ...) > 0 then
            errorFunction(\\"GetProductInfo: too many arguments\\", 2)
        end
        -- error on invalid assetId types
        local idType = typeFunction(assetId)
        if idType ~= \\"number\\" then
            errorFunction(\\"GetProductInfo: assetId must be a number, got \\" .. idType, 2)
        end
        -- error on invalid numeric IDs (negative, non-integer, out of range)
        if assetId < 1 or assetId ~= math.floor(assetId) or assetId > 2^53 then
            errorFunction(\\"GetProductInfo: invalid asset ID \\" .. tostring(assetId), 2)
        end
        return {Name=\\"Product\\", Description=\\"\\", PriceInRobux=0, AssetId=assetId, IsForSale=false, IsLimited=false, IsLimitedUnique=false, IsNew=false, IsPublicDomain=false, IsForRent=false, MinimumMembershipLevel=0, ContentRatingTypeId=0, Creator={Id=1, Name=\\"Roblox\\", CreatorType=\\"User\\"}}
    end
    serviceMethods.GetDeveloperProductsAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- BadgeService
    serviceMethods.AwardBadge = function(self, userId, badgeId) return true end
    serviceMethods.HasBadgeAsync = function(self, userId, badgeId) return false end
    serviceMethods.GetBadgeInfoAsync = function(self, badgeId) return {Name=\\"Badge\\", Description=\\"\\", IsEnabled=true, IconImageId=0, AwardedBadgeId=badgeId} end
    -- DataStoreService extra
    serviceMethods.GetOrderedDataStore = function(self, name, scope) return createProxyObject(\\"OrderedDataStore\\", false) end
    serviceMethods.ListDataStoresAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- ContentProvider
    serviceMethods.PreloadAsync = function(self, instances, callback) end
    serviceMethods.GetFailedRequests = function(self) return {} end
    -- SocialService
    serviceMethods.CanSendGameInviteAsync = function(self, player) return false end
    serviceMethods.PromptGameInvite = function(self, player) end
    serviceMethods.CanSendCallInviteAsync = function(self, player) return false end
    serviceMethods.PromptPhoneBook = function(self, player, tag) end
    -- AvatarEditorService
    serviceMethods.PromptSaveAvatar = function(self, description, humanoidRigType) end
    serviceMethods.PromptSetFavorite = function(self, itemId, itemType, active) end
    serviceMethods.GetInventoryAsync = function(self, pageSize, assetTypes) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- VoiceChatService
    serviceMethods.IsVoiceEnabledForUserIdAsync = function(self, userId) return false end
    serviceMethods.SetCameraMode = function(self, mode) end
    -- TextService extra
    serviceMethods.GetFamilyInfoAsync = function(self, assetId) return {Name=\\"Font\\", Faces={}} end
    -- PolicyService
    serviceMethods.GetPolicyInfoForPlayerAsync = function(self, player)
        return {IsSubjectToChinaPolicies=false, ArePaidRandomItemsRestricted=false, IsPaidItemTradingAllowed=true, AreAdsAllowed=true, AllowedExternalLinkReferences={}}
    end
    -- AnalyticsService
    serviceMethods.LogCustomEvent = function(self, player, eventName, customData) end
    serviceMethods.LogEconomyEvent = function(self, player, flow, currencyType, amount, endingPlayerBalance, transactionType, itemSku) end
    serviceMethods.LogFunnelStepEvent = function(self, player, funnelName, funnelSessionId, step, stepName) end
    serviceMethods.LogOnboardingFunnelStepEvent = function(self, player, step, stepName) end
    serviceMethods.LogProgressionCompleteEvent = function(self, player, progressionPathName, progressionName) end
    serviceMethods.LogProgressionEvent = function(self, player, progressionPathName, progressionName, progressionIndex) end
    -- Instance general
    serviceMethods.GetNetworkOwner = function(self) return _at.localPlayer end
    serviceMethods.SetNetworkOwner = function(self, player) end
    serviceMethods.SetNetworkOwnershipAuto = function(self) end
    serviceMethods.CanSetNetworkOwnership = function(self) return true, nil end
    serviceMethods.GetNetworkOwnershipAuto = function(self) return true end
    serviceMethods.ApplyDescription = function(self, humanoidDescription) end
    serviceMethods.GetAppliedDescription = function(self) return createProxyObject(\\"HumanoidDescription\\", false) end
    serviceMethods.ReplaceContentIds = function(self, ids, newIds) end
    serviceMethods.GetConnectedParts = function(self, recursive) return {} end
    serviceMethods.GetJoints = function(self) return {} end
    serviceMethods.GetTouchingParts = function(self) return {} end
    serviceMethods.GetNoCollisionConstraints = function(self) return {} end
    serviceMethods.SubtractAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.UnionAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.IntersectAsync = function(self, parts, cs, ms) return createProxyObject(\\"IntersectOperation\\", false) end
    serviceMethods.SeparateAsync = function(self, parts) return {} end
    serviceMethods.BreakJoints = function(self) end
    serviceMethods.MakeJoints = function(self) end
    serviceMethods.ResetOrientationToIdentity = function(self) end
    serviceMethods.GetRootPart = function(self) return proxy end
    serviceMethods.GetModelCFrame = function(self) return CFrame.new(0,0,0) end
    serviceMethods.GetModelSize = function(self) return Vector3.new(1,1,1) end
    serviceMethods.FindPartOnRay = function(self, ray, ignore, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithIgnoreList = function(self, ray, ignoreList, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithWhitelist = function(self, ray, whitelist, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.ArePartsTouchingOthers = function(self, parts, overlapIgnored) return false end
    serviceMethods.GetPartsInPart = function(self, part, overlapParams) return {} end
    -- Humanoid extra
    serviceMethods.AddAccessory = function(self, accessory) end
    serviceMethods.RemoveAccessories = function(self) end
    serviceMethods.GetAccessories = function(self) return {} end
    serviceMethods.GetLimb = function(self, part) return createProxyObject(\\"Enum.Limb.Unknown\\", false) end
    serviceMethods.GetBodyPartR15 = function(self, part) return nil end
    serviceMethods.ReplaceBodyPartR15 = function(self, bodyPart, part) return false end
    serviceMethods.BuildRigFromAttachments = function(self) end
    -- Sound extra
    serviceMethods.Resume = function(self) end
    -- Gui
    serviceMethods.TweenPosition = function(self, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSize = function(self, endSize, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSizeAndPosition = function(self, endSize, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    -- ContextActionService extra
    serviceMethods.GetButton = function(self, actionName) return nil end
    serviceMethods.LocalToolEquipped = function(self, toolEquipped) end
    serviceMethods.LocalToolUnequipped = function(self, toolUnequipped) end
    -- PathfindingService extra
    serviceMethods.FindPathAsync = function(self, start, finish) return createProxyObject(\\"Path\\", false) end
    serviceMethods.ComputeAsync = function(self, start, finish) end
    serviceMethods.GetWaypoints = function(self) return {} end
    serviceMethods.CheckOcclusionAsync = function(self, start) return {} end
    -- Camera extra
    serviceMethods.ScreenPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.ViewportPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.WorldToScreenPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.WorldToViewportPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.GetPartsObscuringTarget = function(self, castPoints, ignoreList) return {} end
    serviceMethods.Interpolate = function(self, endPos, endFocus, duration) end
    -- UserInputService extra
    serviceMethods.GetMouseLocation = function(self) return Vector2.new(0,0) end
    serviceMethods.GetMouseDelta = function(self) return Vector2.new(0,0) end
    serviceMethods.GetKeysPressed = function(self) return {} end
    serviceMethods.GetMouseButtonsPressed = function(self) return {} end
    serviceMethods.GetGamepadState = function(self, gamepadNum) return {} end
    serviceMethods.GetSupportedGamepadKeyCodes = function(self, gamepadNum) return {} end
    serviceMethods.GetConnectedGamepads = function(self) return {} end
    serviceMethods.GetLastInputType = function(self) return createProxyObject(\\"Enum.UserInputType.None\\", false) end
    serviceMethods.GetFocusedTextBox = function(self) return nil end
    serviceMethods.IsGamepadButtonDown = function(self, gamepadNum, keyCode) return false end
    serviceMethods.IsKeyDown = function(self, keyCode) return false end
    serviceMethods.IsMouseButtonPressed = function(self, mouseButton) return false end
    serviceMethods.RecenterUserHeadCFrame = function(self) end
    serviceMethods.GetDeviceRotation = function(self) return createProxyObject(\\"InputObject\\", false), CFrame.new(0,0,0) end
    serviceMethods.GetDeviceGravity = function(self) return createProxyObject(\\"InputObject\\", false) end
    -- PhysicsService
    serviceMethods.CreateCollisionGroup = function(self, name) return 0 end
    serviceMethods.RemoveCollisionGroup = function(self, name) end
    serviceMethods.CollisionGroupSetCollidable = function(self, name1, name2, collidable) end
    serviceMethods.CollisionGroupsAreCollidable = function(self, name1, name2) return true end
    serviceMethods.GetCollisionGroupId = function(self, name) return 0 end
    serviceMethods.GetCollisionGroupName = function(self, id) return \\"Default\\" end
    serviceMethods.SetPartCollisionGroup = function(self, part, name) end
    serviceMethods.GetMaxCollisionGroups = function(self) return 32 end
    serviceMethods.GetRegisteredCollisionGroups = function(self) return {} end
    -- StarterGui extra
    serviceMethods.GetCoreGuiEnabled = function(self, coreGuiType) return true end
    serviceMethods.RegisterGetCore = function(self, parameterName, getFunction) end
    serviceMethods.RegisterSetCore = function(self, parameterName, setFunction) end
    -- Lighting extra
    serviceMethods.GetAtmosphere = function(self) return nil end
    serviceMethods.GetSky = function(self) return nil end
    -- Workspace extra
    serviceMethods.GetServerTimeNow = function(self) return os.time() end
    serviceMethods.PGSIsEnabled = function(self) return true end
    serviceMethods.SetInsertPoint = function(self, point) end
    -- NetworkClient/NetworkServer
    serviceMethods.GetClientTicket = function(self) return \\"\\" end
    -- ScriptContext
    serviceMethods.AddCoreScriptLocal = function(self, name, parent) end
    serviceMethods.GetCoreScriptVersion = function(self) return \\"1.0.0\\" end
    meta.__namecall = function(self, ...) return nil end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        -- fast path: string key, check property_store and common properties before formatValue
        if typeFunction(key) == \\"string\\" then
            local ps = dumperState.property_store[proxy]
            if ps then
                local v = ps[key]
                if v ~= nil then return v end
            end
            if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
            if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
            if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
            if key == \\"Name\\" then
                if _at.typeOverride[proxy] == \\"EnumItem\\" then
                    return (formattedName or \\"\\"):match(\\"%.([^%.]+)$\\") or formattedName or \\"Object\\"
                end
                return formattedName or \\"Object\\"
            end
            if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
            if not _at.metaHooks[\\"__index\\"] then
                local sm = serviceMethods[key]
                if sm ~= nil then
                    if typeFunction(sm) == \\"function\\" then
                        local previousMethod
                        return function(_, ...)
                            previousMethod = _at.currentNamecallMethod
                            _at.currentNamecallMethod = key
                            local results = {sm(proxy, ...)}
                            _at.currentNamecallMethod = previousMethod
                            return table.unpack(results)
                        end
                    end
                    return sm
                end
            end
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local propertyName = formatValue(key)
        if _at.metaHooks[\\"__index\\"] and not _at.inMetaHook then
            _at.inMetaHook = true
            local ok, result = pcallFunction(_at.metaHooks[\\"__index\\"], proxy, key)
            _at.inMetaHook = false
            if ok and result ~= nil then return result end
        end
        if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
        if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
        if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
        -- DistributedGameTime ticking (must be before property_store read)
        if key == \\"DistributedGameTime\\" then
            if not _at._dgtClock then
                -- initialize ticking from current stored value on first access
                local props = dumperState.property_store[proxy]
                _at._dgtBase = (props and props[key]) or 1
                _at._dgtClock = osLibrary.clock()
            end
            return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
        end
        -- AT6: SurfaceAppearance ContentId properties
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName
        if className == \\"SurfaceAppearance\\" and (key == \\"ColorMap\\" or key == \\"NormalMap\\" or key == \\"RoughnessMap\\" or key == \\"MetalnessMap\\") then
            return _makeContentId(\\"\\")
        end
        if dumperState.property_store[proxy] and dumperState.property_store[proxy][key] ~= nil then
            return dumperState.property_store[proxy][key]
        end
        if serviceMethods[propertyName] then
            return function(_, ...)
                if _at.metaHooks[\\"__namecall\\"] and not _at.inMetaHook then
                    local previousMethod = _at.currentNamecallMethod
                    _at.currentNamecallMethod = propertyName
                    _at.inMetaHook = true
                    local ok, result = pcallFunction(_at.metaHooks[\\"__namecall\\"], proxy, ...)
                    _at.inMetaHook = false
                    _at.currentNamecallMethod = previousMethod
                    if ok and result ~= nil then return result end
                end
                local previousMethod = _at.currentNamecallMethod
                _at.currentNamecallMethod = propertyName
                local results = {serviceMethods[propertyName](proxy, ...)}
                _at.currentNamecallMethod = previousMethod
                return table.unpack(results)
            end
        end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName == \\"_G\\" then
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            if _G[key] ~= nil then return _G[key] end
            return nil
        end
        if key == \\"Name\\" then return formattedName or \\"Object\\" end
        if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
        if key == \\"Players\\" then return serviceMethods.GetService(game, \\"Players\\") end
        if key == \\"Workspace\\" then return workspace end
        if key == \\"LocalPlayer\\" then
            if _at.localPlayer then return _at.localPlayer end
            local lpProxy = createProxyObject(\\"LocalPlayer\\", false, proxy)
            dumperState.property_store[lpProxy] = {Name = \\"Player\\", ClassName = \\"Player\\", UserId = 1}
            _at.localPlayer = lpProxy
            local varName = registerVariable(lpProxy, \\"LocalPlayer\\")
            emitOutput(string.format(\\"local %s = %s.LocalPlayer\\", varName, pathName))
            return lpProxy
        end
        if key == \\"PlayerGui\\" then return createProxyObject(\\"PlayerGui\\", false, proxy) end
        if key == \\"Backpack\\" then return createProxyObject(\\"Backpack\\", false, proxy) end
        if key == \\"PlayerScripts\\" then return createProxyObject(\\"PlayerScripts\\", false, proxy) end
        if key == \\"UserId\\" then return 1 end
        if key == \\"DisplayName\\" then return \\"Player\\" end
        if key == \\"AccountAge\\" then return 1000 end
        if key == \\"LocaleId\\" then return \\"en-us\\" end
        if key == \\"RobloxLocaleId\\" or key == \\"SystemLocaleId\\" then return \\"en-us\\" end
        if key == \\"CharacterMaxSlopeAngle\\" then return 89 end
        if key == \\"DistanceFactor\\" then return 3.33 end
        if key == \\"CaptureBegan\\" then
            local sigProxy = createProxyObject(pathName .. \\".CaptureBegan\\", false, proxy)
            dumperState.registry[sigProxy] = pathName .. \\".CaptureBegan\\"
            _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
            return sigProxy
        end
        if key == \\"Connected\\" and _at.connState[proxy] ~= nil then return _at.connState[proxy] end
        if key == \\"Team\\" then return createProxyObject(\\"Team\\", false, proxy) end
        if key == \\"TeamColor\\" then return BrickColor.new(\\"White\\") end
        if key == \\"Character\\" then
            local charProxy = createProxyObject(\\"Character\\", false, proxy)
            dumperState.property_store[charProxy] = {Name = \\"Character\\", ClassName = \\"Model\\"}
            -- AT3: seed Animate LocalScript as child of character
            if not _at.animateScript then
                local animProxy = createProxyObject(\\"Animate\\", false, charProxy)
                dumperState.registry[animProxy] = \\"Animate\\"
                dumperState.property_store[animProxy] = {Name = \\"Animate\\", ClassName = \\"LocalScript\\", Parent = charProxy}
                _setParent(animProxy, charProxy)
                _at.animateScript = animProxy
            end
            return charProxy
        end
        if key == \\"Humanoid\\" then
            local humProxy = createProxyObject(\\"Humanoid\\", false, proxy)
            dumperState.property_store[humProxy] = {Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2}
            return humProxy
        end
        if key == \\"HumanoidRootPart\\" or key == \\"PrimaryPart\\" or key == \\"RootPart\\" then
            local rootProxy = createProxyObject(\\"HumanoidRootPart\\", false, proxy)
            dumperState.property_store[rootProxy] = {Position = Vector3.new(0, 5, 0), CFrame = CFrame.new(0, 5, 0)}
            return rootProxy
        end
        local limbNames = {\\"Head\\", \\"Torso\\", \\"UpperTorso\\", \\"LowerTorso\\", \\"RightArm\\", \\"LeftArm\\", \\"RightLeg\\", \\"LeftLeg\\", \\"RightHand\\", \\"LeftHand\\", \\"RightFoot\\", \\"LeftFoot\\"}
        for _, limb in ipairsFunction(limbNames) do
            if key == limb then return createProxyObject(key, false, proxy) end
        end
        if key == \\"Animator\\" then return createProxyObject(\\"Animator\\", false, proxy) end
        if key == \\"CurrentCamera\\" or key == \\"Camera\\" then
            local camProxy = createProxyObject(\\"Camera\\", false, proxy)
            dumperState.property_store[camProxy] = {CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080)}
            return camProxy
        end
        if key == \\"Terrain\\" then
            if not _at.terrainProxy then
                local tp = createProxyObject(\\"Terrain\\", false, proxy)
                dumperState.property_store[tp] = {ClassName=\\"Terrain\\",Name=\\"Terrain\\",Parent=proxy,WaterWaveSpeed=100,WaterWaveSize=0.5}
                _at.terrainProxy = tp
            end
            return _at.terrainProxy
        end
        if key == \\"CameraType\\" then return Enum.CameraType.Custom end
        if key == \\"CameraSubject\\" then return createProxyObject(\\"Humanoid\\", false, proxy) end
        if key == \\"DistributedGameTime\\" then
            if _at._dgtBase and _at._dgtClock then
                return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
            end
        end
        local constants = {
            Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2, HipHeight = 2,
            Transparency = 0, Mass = 1, Value = 0, TimePosition = 0, TimeLength = 1, Volume = 0.5,
            PlaybackSpeed = 1, Brightness = 1, Range = 60, Angle = 90, FieldOfView = 70, Thickness = 1,
            ZIndex = 1, LayoutOrder = 0, Gravity = 196.2, DistributedGameTime = 1, ClockTime = 14,
            FogEnd = 100000, RolloffScale = 1, MaxPlayers = 12, RespawnTime = 5, PlaceVersion = 1,
            CreatorId = 0, FollowUserId = 0, NearPlaneZ = -0.1
        }
        if constants[key] ~= nil then return constants[key] end
        if key == \\"Size\\" and not (formattedName and formattedName:match(\\"Part\\")) then return UDim2.new(1, 0, 1, 0) end
        local boolConstants = {Visible = true, Enabled = true, Anchored = false, CanCollide = true, Locked = false, Active = true, Draggable = false, Modal = false, Playing = false, Looped = false, IsPlaying = false, AutoPlay = false, Archivable = true, ClipsDescendants = false, RichText = false, TextWrapped = false, TextScaled = false, PlatformStand = false, AutoRotate = true, Sit = false}
        boolConstants.StreamingEnabled = false
        boolConstants.HttpEnabled = false
        boolConstants.Sandboxed = false
        if boolConstants[key] ~= nil then return boolConstants[key] end
        if key == \\"JobId\\" then return \\"00000000-0000-4000-8000-000000000001\\" end
        if key == \\"CreatorType\\" then return Enum.CreatorType.User end
        if key == \\"MembershipType\\" then return Enum.MembershipType.None end
        if key == \\"AmbientReverb\\" then return Enum.ReverbType.NoReverb end
        if key == \\"Ambient\\" or key == \\"OutdoorAmbient\\" then return Color3.fromRGB(128, 128, 128) end
        if key == \\"UniqueId\\" then return _getDebugId(proxy) end
        if key == \\"AbsoluteSize\\" or key == \\"ViewportSize\\" then return Vector2.new(1920, 1080) end
        if key == \\"AbsolutePosition\\" then return Vector2.new(0, 0) end
        if key == \\"Position\\" then
            if formattedName and (formattedName:match(\\"Part\\") or formattedName:match(\\"Model\\") or formattedName:match(\\"Character\\") or formattedName:match(\\"Root\\")) then return Vector3.new(0, 5, 0) end
            return UDim2.new(0, 0, 0, 0)
        end
        if key == \\"Size\\" then
            if formattedName and formattedName:match(\\"Part\\") then return Vector3.new(4, 1, 2) end
            return UDim2.new(1, 0, 1, 0)
        end
        if key == \\"CFrame\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Velocity\\" or key == \\"AssemblyLinearVelocity\\" then
            -- AT4: if a LinearVelocity constraint is attached to this part, reflect its VectorVelocity
            for _, child in ipairsFunction(_at.children[proxy] or {}) do
                local cprops = dumperState.property_store[child]
                if cprops and cprops.ClassName == \\"LinearVelocity\\" then
                    local vv = cprops.VectorVelocity
                    if vv and typeof(vv) == \\"Vector3\\" then return vv end
                end
            end
            return Vector3.new(0, 0, 0)
        end
        if key == \\"RotVelocity\\" or key == \\"AssemblyAngularVelocity\\" then
            local imp = dumperState.property_store[proxy] and dumperState.property_store[proxy][\\"_angularImpulse\\"]
            if imp and _at.vectors[imp] then
                local d = _at.vectors[imp]
                return _makeVector3(d.x, d.y, d.z)
            end
            return _makeVector3(0, 0, 0)
        end
        if key == \\"Orientation\\" or key == \\"Rotation\\" then return Vector3.new(0, 0, 0) end
        if key == \\"LookVector\\" then return Vector3.new(0, 0, -1) end
        if key == \\"RightVector\\" then return Vector3.new(1, 0, 0) end
        if key == \\"UpVector\\" then return Vector3.new(0, 1, 0) end
        if key == \\"Color\\" or key == \\"Color3\\" or key == \\"BackgroundColor3\\" or key == \\"BorderColor3\\" or key == \\"TextColor3\\" or key == \\"PlaceholderColor3\\" or key == \\"ImageColor3\\" then return Color3.new(1, 1, 1) end
        if key == \\"BrickColor\\" then return BrickColor.new(\\"Medium stone grey\\") end
        if key == \\"Material\\" then return createProxyObject(\\"Enum.Material.Plastic\\", false) end
        if key == \\"Hit\\" then return CFrame.new(0, 0, -10) end
        if key == \\"Origin\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Target\\" then return createProxyObject(\\"Target\\", false, proxy) end
        if key == \\"X\\" or key == \\"Y\\" then return 0 end
        if key == \\"UnitRay\\" then return Ray.new(Vector3.new(0, 5, 0), Vector3.new(0, 0, -1)) end
        if key == \\"ViewSizeX\\" then return 1920 end
        if key == \\"ViewSizeY\\" then return 1080 end
        if key == \\"Text\\" or key == \\"PlaceholderText\\" or key == \\"ContentText\\" or key == \\"Value\\" then
            if inputKey then return inputKey end
            if key == \\"Value\\" then return \\"input\\" end
            return '\\"'
        end
        if key == \\"TextBounds\\" then return Vector2.new(0, 0) end
        if key == \\"Font\\" then return createProxyObject(\\"Enum.Font.SourceSans\\", false) end
        if key == \\"TextSize\\" then return 14 end
        if key == \\"Image\\" or key == \\"ImageContent\\" then return '\\"' end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        local signalNames = {\\"Changed\\", \\"ChildAdded\\", \\"ChildRemoved\\", \\"DescendantAdded\\", \\"DescendantRemoving\\", \\"Touched\\", \\"TouchEnded\\", \\"InputBegan\\", \\"InputEnded\\", \\"InputChanged\\", \\"MouseButton1Click\\", \\"MouseButton1Down\\", \\"MouseButton1Up\\", \\"MouseButton2Click\\", \\"MouseButton2Down\\", \\"MouseButton2Up\\", \\"MouseEnter\\", \\"MouseLeave\\", \\"MouseMoved\\", \\"MouseWheelForward\\", \\"MouseWheelBackward\\", \\"Activated\\", \\"Deactivated\\", \\"FocusLost\\", \\"FocusGained\\", \\"Focused\\", \\"Heartbeat\\", \\"RenderStepped\\", \\"Stepped\\", \\"CharacterAdded\\", \\"CharacterRemoving\\", \\"CharacterAppearanceLoaded\\", \\"PlayerAdded\\", \\"PlayerRemoving\\", \\"AncestryChanged\\", \\"AttributeChanged\\", \\"Died\\", \\"FreeFalling\\", \\"GettingUp\\", \\"Jumping\\", \\"Running\\", \\"Seated\\", \\"Swimming\\", \\"StateChanged\\", \\"HealthChanged\\", \\"MoveToFinished\\", \\"OnClientEvent\\", \\"OnServerEvent\\", \\"OnClientInvoke\\", \\"OnServerInvoke\\", \\"Completed\\", \\"DidLoop\\", \\"Stopped\\", \\"CaptureBegan\\", \\"Button1Down\\", \\"Button1Up\\", \\"Button2Down\\", \\"Button2Up\\", \\"Idle\\", \\"Move\\", \\"TextChanged\\", \\"ReturnPressedFromOnScreenKeyboard\\", \\"Triggered\\", \\"TriggerEnded\\", \\"Error\\", \\"Event\\", \\"AxisChanged\\", \\"JumpRequest\\", \\"DevTouchMovementModeChanged\\", \\"DevComputerMovementModeChanged\\", \\"GraphicsQualityChangeRequest\\", \\"MenuOpened\\", \\"MenuClosed\\", \\"PointerAction\\", \\"TouchStarted\\", \\"TouchMoved\\", \\"TouchEnded\\", \\"TouchTap\\", \\"TouchLongPress\\", \\"TouchPinch\\", \\"TouchRotate\\", \\"TouchSwipe\\", \\"GamepadConnected\\", \\"GamepadDisconnected\\", \\"WindowFocused\\", \\"WindowFocusReleased\\"}
        for _, sig in ipairsFunction(signalNames) do
            if key == sig then
                local sigProxy = createProxyObject(pathName .. \\".\\" .. key, false, nil)
                dumperState.registry[sigProxy] = pathName .. \\".\\" .. key
                _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
                _at.signalOwner = _at.signalOwner or {}
                _at.signalOwner[sigProxy] = proxy  -- track owner without triggering _setParent
                return sigProxy
            end
        end
        return createProxyMethod(propertyName, proxy)
    end
    meta.__newindex = function(tbl, key, val)
        if key == proxyList or key == \\"__proxy_id\\" then
            rawset(tbl, key, val)
            return
        end
        -- locked: never allow mutation regardless of method
        local _lockedProps = {PlaceId=true, placeId=true, GameId=true, gameId=true, UniverseId=true}
        if _lockedProps[key] then return end
        -- read-only properties: error like real Roblox does
        local _readOnlyProps = {
            PlaybackLoudness = true,
            AbsolutePosition = true,
            AbsoluteSize = true,
            AbsoluteRotation = true,
            TextBounds = true,
            ContentText = true,
            SimulationRadius = true,
            MaxSimulationRadius = true,
            RootPriority = true,
            NativeIndex = true,
            ReceiveAge = true,
            AssemblyAngularVelocity = true,
            AssemblyLinearVelocity = true,
            AssemblyMass = true,
            AssemblyRootPart = true,
            CurrentCamera = true,
            PrivateServerOwnerId = true,
            PrivateServerId = true,
            JobId = true,
            PlaceId = true,
            GameId = true,
            PlaceVersion = true,
            UserId = true,
            FloorMaterial = true,
            MoveDirection = true,
            SeatPart = true,
        }
        if _readOnlyProps[key] then
            errorFunction(toStringFunction(key) .. \\" is not a valid member of \\" .. (dumperState.registry[proxy] or formattedName or \\"Instance\\"), 2)
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local prop = formatValue(key)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][key] = val
        local _cls2 = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if key == \\"CameraMinZoomDistance\\" then
            local n = tonumber(val) or 0; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif key == \\"CameraMaxZoomDistance\\" then
            local n = tonumber(val) or 400; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif _cls2 == \\"Terrain\\" and key == \\"WaterWaveSpeed\\" then
            local n = tonumber(val) or 100; if n > 100 then n = 100 end; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        end
        if key == \\"Parent\\" then
            _setParent(proxy, isProxy(val) and val or nil)
        end
        local className = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if className == \\"WeldConstraint\\" or className == \\"Weld\\" or className == \\"Motor6D\\" then
            if key == \\"Part0\\" or key == \\"Part1\\" then
                _at.weldRegistry[proxy] = _at.weldRegistry[proxy] or {}
                _at.weldRegistry[proxy][key] = val
                local wr = _at.weldRegistry[proxy]
                if wr.Part0 and wr.Part1 then
                    local cf0 = (dumperState.property_store[wr.Part0] or {}).CFrame
                    local cf1 = (dumperState.property_store[wr.Part1] or {}).CFrame
                    if cf0 and cf1 then
                        wr.offset = {X = (cf1.X or 0) - (cf0.X or 0), Y = (cf1.Y or 0) - (cf0.Y or 0), Z = (cf1.Z or 0) - (cf0.Z or 0)}
                    end
                end
            end
        end
        if key == \\"CFrame\\" then
            local cfVal = val
            local cfX = (cfVal and cfVal.X) or 0
            local cfY = (cfVal and cfVal.Y) or 0
            local cfZ = (cfVal and cfVal.Z) or 0
            for _, wr in pairs(_at.weldRegistry) do
                if wr.Part0 == proxy and wr.Part1 and wr.offset then
                    local nx = cfX + wr.offset.X
                    local ny = cfY + wr.offset.Y
                    local nz = cfZ + wr.offset.Z
                    local newCF
                    if type(CFrame) == \\"table\\" and type(CFrame.new) == \\"function\\" then
                        newCF = CFrame.new(nx, ny, nz)
                    elseif _makeCFrame then
                        newCF = _makeCFrame(nx, ny, nz)
                    else
                        newCF = {X = nx, Y = ny, Z = nz, Position = {X = nx, Y = ny, Z = nz}}
                    end
                    dumperState.property_store[wr.Part1] = dumperState.property_store[wr.Part1] or {}
                    dumperState.property_store[wr.Part1].CFrame = newCF
                    local posV = newCF.Position
                    dumperState.property_store[wr.Part1].Position = posV
                end
            end
        end
        emitOutput(string.format(\\"%s.%s = %s\\", pathName, prop, serializeValue(val)))
    end
    meta.__call = function(tbl, ...)
        local pathName = dumperState.registry[proxy] or formattedName or \\"func\\"
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName:match(\\"env\\") then
            return proxy
        end
        if pathName == \\"game\\" then
            errorFunction(\\"attempt to call an Instance value\\", 0)
        end
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"result\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s(%s)\\", varName, pathName, table.concat(serializedArgs, \\", \\")))
        return resultProxy
    end
    local function operatorMeta(opSymbol)
        local function metaCall(a, b)
            local proxy, meta = createProxy()
            local strA = \\"0\\"
            if a ~= nil then strA = dumperState.registry[a] or serializeValue(a) end
            local strB = \\"0\\"
            if b ~= nil then strB = dumperState.registry[b] or serializeValue(b) end
            local expression = \\"(\\" .. strA .. \\" \\" .. opSymbol .. \\" \\" .. strB .. \\")\\"
            dumperState.registry[proxy] = expression
            meta.__tostring = function() return expression end
            meta.__call = function() return proxy end
            meta.__index = function(_, k)
                if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
            end
            meta.__add = operatorMeta(\\"+\\")
            meta.__sub = operatorMeta(\\"-\\")
            meta.__mul = operatorMeta(\\"*\\")
            meta.__div = operatorMeta(\\"/\\")
            meta.__mod = operatorMeta(\\"%\\")
            meta.__pow = operatorMeta(\\"^\\")
            meta.__concat = operatorMeta(\\"..\\")
            meta.__eq = function() return false end
            meta.__lt = function() return false end
            meta.__le = function() return false end
            return proxy
        end
        return metaCall
    end
    meta.__add = operatorMeta(\\"+\\")
    meta.__sub = operatorMeta(\\"-\\")
    meta.__mul = operatorMeta(\\"*\\")
    meta.__div = operatorMeta(\\"/\\")
    meta.__mod = operatorMeta(\\"%\\")
    meta.__pow = operatorMeta(\\"^\\")
    meta.__concat = operatorMeta(\\"..\\")
    meta.__eq = function(a, b) return rawequal(a, b) end
    meta.__lt = function() return false end
    meta.__le = function() return false end
    meta.__unm = function(a)
        local proxy, meta = createProxy()
        dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
        meta.__tostring = function() return dumperState.registry[proxy] end
        return proxy
    end
    meta.__len = function() return 0 end
    meta.__tostring = function() return dumperState.registry[proxy] or formattedName or \\"Object\\" end
    meta.__pairs = function() return function() return nil end, proxy, nil end
    meta.__ipairs = meta.__pairs
    return proxy
end
local function createTypeDa(typeName, methods)
    local dc = {}
    local dd = {}
    dd.__index = function(_, key)
        if key == \\"new\\" or methods and methods[key] then
            return function(...)
                local args = {...}
                local serializedArgs = {}
                for _, val in ipairsFunction(args) do
                    table.insert(serializedArgs, serializeValue(val))
                end
                local expression = typeName .. \\".\\" .. key .. \\"(\\" .. table.concat(serializedArgs, \\", \\") .. \\")\\"
                local proxy, meta = createProxy()
                dumperState.registry[proxy] = expression
                meta.__tostring = function() return expression end
                meta.__index = function(_, k)
                    if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                    if k == \\"X\\" or k == \\"Y\\" or k == \\"Z\\" or k == \\"W\\" then return 0 end
                    if k == \\"Magnitude\\" then return 0 end
                    if k == \\"Unit\\" or k == \\"Position\\" or k == \\"CFrame\\" or k == \\"LookVector\\" or k == \\"RightVector\\" or k == \\"UpVector\\" or k == \\"Rotation\\" or k == \\"p\\" then return proxy end
                    if k == \\"R\\" or k == \\"G\\" or k == \\"B\\" then return 1 end
                    if k == \\"Width\\" or k == \\"Height\\" then return UDim.new(0, 0) end
                    if k == \\"Min\\" or k == \\"Max\\" or k == \\"Scale\\" or k == \\"Offset\\" then return 0 end
                    return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
                end
                local function opMeta(symbol)
                    return function(a, b)
                        local proxy, meta = createProxy()
                        local expr = \\"(\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\" \\" .. symbol .. \\" \\" .. (dumperState.registry[b] or serializeValue(b)) .. \\")\\"
                        dumperState.registry[proxy] = expr
                        meta.__tostring = function() return expr end
                        meta.__index = meta.__index
                        meta.__add = opMeta(\\"+\\")
                        meta.__sub = opMeta(\\"-\\")
                        meta.__mul = opMeta(\\"*\\")
                        meta.__div = opMeta(\\"/\\")
                        return proxy
                    end
                end
                meta.__add = opMeta(\\"+\\")
                meta.__sub = opMeta(\\"-\\")
                meta.__mul = opMeta(\\"*\\")
                meta.__div = opMeta(\\"/\\")
                meta.__unm = function(a)
                    local proxy, meta = createProxy()
                    dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
                    meta.__tostring = function() return dumperState.registry[proxy] end
                    return proxy
                end
                meta.__eq = function() return false end
                meta.__typeof = typeName
                return proxy
            end
        end
        return nil
    end
    dd.__call = function(_, ...) return _.new(...) end
    return setmetatable(dc, dd)
end
Vector3 = createTypeDa(\\"Vector3\\", {new = true, zero = true, one = true})
Vector2 = createTypeDa(\\"Vector2\\", {new = true, zero = true, one = true})
UDim = createTypeDa(\\"UDim\\", {new = true})
UDim2 = createTypeDa(\\"UDim2\\", {new = true, fromScale = true, fromOffset = true})
CFrame = createTypeDa(\\"CFrame\\", {new = true, Angles = true, lookAt = true, fromEulerAnglesXYZ = true, fromEulerAnglesYXZ = true, fromAxisAngle = true, fromMatrix = true, fromOrientation = true, identity = true})
Color3 = createTypeDa(\\"Color3\\", {new = true, fromRGB = true, fromHSV = true, fromHex = true})
BrickColor = createTypeDa(\\"BrickColor\\", {new = true, random = true, White = true, Black = true, Red = true, Blue = true, Green = true, Yellow = true, palette = true})
TweenInfo = createTypeDa(\\"TweenInfo\\", {new = true})
Rect = createTypeDa(\\"Rect\\", {new = true})
Region3 = createTypeDa(\\"Region3\\", {new = true})
Region3int16 = createTypeDa(\\"Region3int16\\", {new = true})
Ray = createTypeDa(\\"Ray\\", {new = true})
NumberRange = createTypeDa(\\"NumberRange\\", {new = true})
NumberSequence = createTypeDa(\\"NumberSequence\\", {new = true})
NumberSequenceKeypoint = createTypeDa(\\"NumberSequenceKeypoint\\", {new = true})
ColorSequence = createTypeDa(\\"ColorSequence\\", {new = true})
ColorSequence.new = function(...)
    local args = {...}
    local keypoints = {}
    if #args == 1 and typeFunction(args[1]) == \\"table\\" and args[1][1] ~= nil then
        keypoints = args[1]
    elseif #args == 1 then
        keypoints = {args[1], args[1]}
    elseif #args >= 2 then
        keypoints = args
    end
    local t = setmetatable({Keypoints = keypoints}, {
        __typeof = \\"ColorSequence\\",
        __tostring = function() return \\"ColorSequence\\" end,
    })
    return t
end
ColorSequenceKeypoint = createTypeDa(\\"ColorSequenceKeypoint\\", {new = true})
PhysicalProperties = createTypeDa(\\"PhysicalProperties\\", {new = true})
Font = createTypeDa(\\"Font\\", {new = true, fromEnum = true, fromName = true, fromId = true})
RaycastParams = createTypeDa(\\"RaycastParams\\", {new = true})
OverlapParams = {new = function()
        local params = {MaxParts = 0, FilterType = Enum.RaycastFilterType.Exclude, FilterDescendantsInstances = {}}
        return setmetatable(params, {__typeof = \\"OverlapParams\\"})
    end}
_makeVector3 = function(x, y, z, expr)
    x, y, z = toNumberFunction(x) or 0, toNumberFunction(y) or 0, toNumberFunction(z) or 0
    local proxy, meta = createProxy()
    local expression = expr or (\\"Vector3.new(\\" .. serializeValue(x) .. \\", \\" .. serializeValue(y) .. \\", \\" .. serializeValue(z) .. \\")\\")
    dumperState.registry[proxy] = expression
    _at.vectors[proxy] = {x = x, y = y, z = z}
    local function component(v, axis)
        local data = _at.vectors[v]
        if not data then return 0 end
        return axis == \\"X\\" and data.x or axis == \\"Y\\" and data.y or data.z
    end
    local function binary(a, b, symbol)
        local ax, ay, az = component(a, \\"X\\"), component(a, \\"Y\\"), component(a, \\"Z\\")
        local bx, by, bz
        if typeFunction(b) == \\"number\\" then bx, by, bz = b, b, b else bx, by, bz = component(b, \\"X\\"), component(b, \\"Y\\"), component(b, \\"Z\\") end
        if symbol == \\"+\\" then return _makeVector3(ax + bx, ay + by, az + bz, \\"(\\" .. serializeValue(a) .. \\" + \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"-\\" then return _makeVector3(ax - bx, ay - by, az - bz, \\"(\\" .. serializeValue(a) .. \\" - \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"*\\" then return _makeVector3(ax * bx, ay * by, az * bz, \\"(\\" .. serializeValue(a) .. \\" * \\" .. serializeValue(b) .. \\")\\") end
        return _makeVector3(bx ~= 0 and ax / bx or 0, by ~= 0 and ay / by or 0, bz ~= 0 and az / bz or 0, \\"(\\" .. serializeValue(a) .. \\" / \\" .. serializeValue(b) .. \\")\\")
    end
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(proxy, key) end
        if key == \\"X\\" then return x end
        if key == \\"Y\\" then return y end
        if key == \\"Z\\" then return z end
        if key == \\"Magnitude\\" then return math.sqrt(x * x + y * y + z * z) end
        if key == \\"Unit\\" then
            local mag = math.sqrt(x * x + y * y + z * z)
            if mag == 0 then return _makeVector3(0, 0, 0, expression .. \\".Unit\\") end
            return _makeVector3(x / mag, y / mag, z / mag, expression .. \\".Unit\\")
        end
        if key == \\"Dot\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return x * ox + y * oy + z * oz
            end
        end
        if key == \\"Cross\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return _makeVector3(y*oz - z*oy, z*ox - x*oz, x*oy - y*ox)
            end
        end
        if key == \\"Lerp\\" then
            return function(self, other, alpha)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                local a = toNumberFunction(alpha) or 0
                return _makeVector3(x + (ox-x)*a, y + (oy-y)*a, z + (oz-z)*a)
            end
        end
        if key == \\"FuzzyEq\\" then
            return function(self, other, epsilon)
                local eps = toNumberFunction(epsilon) or 1e-5
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return math.abs(x-ox) <= eps and math.abs(y-oy) <= eps and math.abs(z-oz) <= eps
            end
        end
        return 0
    end
    meta.__add = function(a, b) return binary(a, b, \\"+\\") end
    meta.__sub = function(a, b) return binary(a, b, \\"-\\") end
    meta.__mul = function(a, b) return binary(a, b, \\"*\\") end
    meta.__div = function(a, b) return binary(a, b, \\"/\\") end
    meta.__unm = function(a) return _makeVector3(-component(a, \\"X\\"), -component(a, \\"Y\\"), -component(a, \\"Z\\"), \\"(-\\" .. serializeValue(a) .. \\")\\") end
    meta.__eq = function(a, b) return component(a, \\"X\\") == component(b, \\"X\\") and component(a, \\"Y\\") == component(b, \\"Y\\") and component(a, \\"Z\\") == component(b, \\"Z\\") end
    meta.__tostring = function() return toStringFunction(x) .. \\", \\" .. toStringFunction(y) .. \\", \\" .. toStringFunction(z) end
    return proxy
end
Vector3 = {
    new = function(x, y, z) return _makeVector3(x, y, z) end,
    zero = _makeVector3(0, 0, 0, \\"Vector3.zero\\"),
    one = _makeVector3(1, 1, 1, \\"Vector3.one\\"),
    fromNormalId = function(normalId)
        local name = toStringFunction(normalId)
        if name:find(\\"Right\\")  then return _makeVector3( 1,  0,  0) end
        if name:find(\\"Left\\")   then return _makeVector3(-1,  0,  0) end
        if name:find(\\"Top\\")    then return _makeVector3( 0,  1,  0) end
        if name:find(\\"Bottom\\") then return _makeVector3( 0, -1,  0) end
        if name:find(\\"Back\\")   then return _makeVector3( 0,  0,  1) end
        if name:find(\\"Front\\")  then return _makeVector3( 0,  0, -1) end
        return _makeVector3(0, 0, 0)
    end,
    fromAxis = function(axis)
        local name = toStringFunction(axis)
        if name:find(\\"X\\") then return _makeVector3(1, 0, 0) end
        if name:find(\\"Y\\") then return _makeVector3(0, 1, 0) end
        if name:find(\\"Z\\") then return _makeVector3(0, 0, 1) end
        return _makeVector3(0, 0, 0)
    end,
}
setmetatable(Vector3, {__call = function(_, x, y, z) return _.new(x, y, z) end})
local function _valueType(typeName, fields, methods)
    local obj = fields or {}
    return setmetatable(obj, {
        __typeof = typeName,
        __index = methods or {},
        __tostring = function() return typeName end,
        __eq = function(a, b)
            if typeFunction(a) ~= \\"table\\" or typeFunction(b) ~= \\"table\\" then return false end
            local ma, mb = getMetatableFunction(a), getMetatableFunction(b)
            if not ma or not mb or ma.__typeof ~= mb.__typeof then return false end
            for k, v in pairsFunction(a) do
                if b[k] ~= v then return false end
            end
            for k, v in pairsFunction(b) do
                if a[k] ~= v then return false end
            end
            return true
        end
    })
end
local function _num(v, default) return toNumberFunction(v) or default or 0 end
local function _makeVector2(x, y)
    x, y = _num(x), _num(y)
    local methods = {}
    function methods:Dot(other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) end
    local mt
    mt = {
        __typeof = \\"Vector2\\",
        __index = function(self, key)
            if key == \\"Magnitude\\" then return math.sqrt(self.X * self.X + self.Y * self.Y) end
            if key == \\"Unit\\" then
                local mag = math.sqrt(self.X * self.X + self.Y * self.Y)
                return mag == 0 and _makeVector2(0, 0) or _makeVector2(self.X / mag, self.Y / mag)
            end
            return methods[key]
        end,
        __add = function(a, b) return _makeVector2(a.X + b.X, a.Y + b.Y) end,
        __sub = function(a, b) return _makeVector2(a.X - b.X, a.Y - b.Y) end,
        __mul = function(a, b)
            if typeFunction(a) == \\"number\\" then return _makeVector2(a * b.X, a * b.Y) end
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X * b, a.Y * b) end
            return _makeVector2(a.X * b.X, a.Y * b.Y)
        end,
        __div = function(a, b)
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X / b, a.Y / b) end
            return _makeVector2(a.X / b.X, a.Y / b.Y)
        end,
        __unm = function(a) return _makeVector2(-a.X, -a.Y) end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y end,
        __tostring = function(a) return (\\"Vector2.new(%s, %s)\\"):format(a.X, a.Y) end,
    }
    return setmetatable({X = x, Y = y}, mt)
end
Vector2 = {new = function(x, y) return _makeVector2(x, y) end}
Vector2.zero = Vector2.new(0, 0)
Vector2.one = Vector2.new(1, 1)
setmetatable(Vector2, {__call = function(_, x, y) return _.new(x, y) end})
local _oldVector3New = Vector3.new
Vector3.new = function(x, y, z)
    local v = _oldVector3New(x, y, z)
    local mt = getMetatableFunction(v)
    local oldIndex = mt.__index
    mt.__index = function(self, key)
        if key == \\"Dot\\" then
            return function(_, other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) + self.Z * (other and other.Z or 0) end
        end
        if key == \\"Cross\\" then
            return function(_, other)
                return Vector3.new(
                    self.Y * (other and other.Z or 0) - self.Z * (other and other.Y or 0),
                    self.Z * (other and other.X or 0) - self.X * (other and other.Z or 0),
                    self.X * (other and other.Y or 0) - self.Y * (other and other.X or 0)
                )
            end
        end
        return oldIndex(self, key)
    end
    return v
end
Vector3.zero = Vector3.new(0, 0, 0)
Vector3.one = Vector3.new(1, 1, 1)
UDim = {new = function(scale, offset) return _valueType(\\"UDim\\", {Scale = _num(scale), Offset = _num(offset)}) end}
setmetatable(UDim, {__call = function(_, scale, offset) return _.new(scale, offset) end})
UDim2 = {
    new = function(xs, xo, ys, yo) return _valueType(\\"UDim2\\", {X = UDim.new(xs, xo), Y = UDim.new(ys, yo)}) end,
    fromScale = function(x, y) return UDim2.new(x, 0, y, 0) end,
    fromOffset = function(x, y) return UDim2.new(0, x, 0, y) end,
}
setmetatable(UDim2, {__call = function(_, ...) return _.new(...) end})
Color3 = {
    new = function(r, g, b)
        local rv, gv, bv = _num(r), _num(g), _num(b)
        if rv < 0 or rv > 1 or gv < 0 or gv > 1 or bv < 0 or bv > 1 then
            errorFunction(\\"R, G, and B must each be in the range [0, 1]\\", 2)
        end
        return setmetatable({R = rv, G = gv, B = bv}, {
            __typeof = \\"Color3\\",
            __tostring = function(self) return string.format(\\"[R:%g, G:%g, B:%g]\\", self.R, self.G, self.B) end,
            __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.R == b.R and a.G == b.G and a.B == b.B end,
        })
    end,
    fromRGB = function(r, g, b) return Color3.new(_num(r) / 255, _num(g) / 255, _num(b) / 255) end,
    fromHSV = function(h, s, v) return Color3.new(v or 1, v or 1, v or 1) end,
    fromHex = function(hex) return Color3.fromRGB(255, 255, 255) end,
}
setmetatable(Color3, {__call = function(_, ...) return _.new(...) end})
BrickColor = {
    new = function(name)
        name = formatValue(name or \\"Medium stone grey\\")
        return _valueType(\\"BrickColor\\", {Name = name, Number = 1, Color = Color3.fromRGB(255, 0, 0)})
    end,
    random = function() return BrickColor.new(\\"Medium stone grey\\") end,
}
setmetatable(BrickColor, {__call = function(_, ...) return _.new(...) end})
NumberRange = {new = function(min, max) return _valueType(\\"NumberRange\\", {Min = _num(min), Max = max ~= nil and _num(max) or _num(min)}) end}
NumberSequence = {new = function(value) return _valueType(\\"NumberSequence\\", {Keypoints = typeFunction(value) == \\"table\\" and value or {{Time = 0, Value = _num(value)}, {Time = 1, Value = _num(value)}}}) end}
TweenInfo = {new = function(timeValue, style, direction, repeatCount, reverses, delayTime) return _valueType(\\"TweenInfo\\", {Time = _num(timeValue), EasingStyle = style or Enum.EasingStyle.Quad, EasingDirection = direction or Enum.EasingDirection.Out, RepeatCount = repeatCount or 0, Reverses = reverses or false, DelayTime = delayTime or 0}) end}
Ray = {new = function(origin, direction) return _valueType(\\"Ray\\", {Origin = origin or Vector3.zero, Direction = direction or Vector3.new(0, 0, -1)}) end}
Rect = {new = function(a, b, c, d)
    local minV = typeFunction(a) == \\"table\\" and a or Vector2.new(a, b)
    local maxV = typeFunction(c) == \\"table\\" and c or Vector2.new(c, d)
    return _valueType(\\"Rect\\", {Min = minV, Max = maxV, Width = maxV.X - minV.X, Height = maxV.Y - minV.Y})
end}
Region3 = {new = function(minVec, maxVec)
    local mn = minVec or Vector3.new(0,0,0)
    local mx = maxVec or Vector3.new(0,0,0)
    local sz = Vector3.new(mx.X - mn.X, mx.Y - mn.Y, mx.Z - mn.Z)
    return _valueType(\\"Region3\\", {CFrame = CFrame.new((mn.X+mx.X)/2,(mn.Y+mx.Y)/2,(mn.Z+mx.Z)/2), Size = sz})
end}
PhysicalProperties = {new = function(density, friction, elasticity, frictionWeight, elasticityWeight) return _valueType(\\"PhysicalProperties\\", {Density = _num(density, 1), Friction = _num(friction, 0.3), Elasticity = _num(elasticity, 0.5), FrictionWeight = _num(frictionWeight, 1), ElasticityWeight = _num(elasticityWeight, 1)}) end}
_makeCFrame = function(x, y, z)
    local ox, oy, oz = _num(x), _num(y), _num(z)
    local obj = {X = ox, Y = oy, Z = oz}
    obj.Position = Vector3.new(ox, oy, oz)
    obj.p = obj.Position
    obj.LookVector = Vector3.new(0, 0, -1)
    obj.RightVector = Vector3.new(1, 0, 0)
    obj.UpVector = Vector3.new(0, 1, 0)
    obj.Inverse = function(self) return _makeCFrame(-ox, -oy, -oz) end
    obj.ToObjectSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox2 - ox, oy2 - oy, oz2 - oz)
    end
    obj.ToWorldSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox + ox2, oy + oy2, oz + oz2)
    end
    obj.PointToObjectSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) - ox,
            (point and point.Y or 0) - oy,
            (point and point.Z or 0) - oz
        )
    end
    obj.PointToWorldSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) + ox,
            (point and point.Y or 0) + oy,
            (point and point.Z or 0) + oz
        )
    end
    return setmetatable(obj, {
        __typeof = \\"CFrame\\",
        __index = function(self, key) return rawget(self, key) end,
        __mul = function(a, b)
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"CFrame\\" then
                return _makeCFrame(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"Vector3\\" then
                return Vector3.new(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            return a
        end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y and a.Z == b.Z end,
        __tostring = function(a) return (\\"CFrame.new(%s, %s, %s)\\"):format(a.X, a.Y, a.Z) end,
    })
end
CFrame = {
    new = function(x, y, z) return _makeCFrame(x, y, z) end,
    Angles = function() return _makeCFrame(0, 0, 0) end,
    lookAt = function(origin, target) return _makeCFrame(origin and origin.X or 0, origin and origin.Y or 0, origin and origin.Z or 0) end,
    LookAt = function(origin, target) return CFrame.lookAt(origin, target) end,
    fromEulerAnglesXYZ = function() return _makeCFrame(0, 0, 0) end,
    fromEulerAnglesYXZ = function() return _makeCFrame(0, 0, 0) end,
    fromAxisAngle = function() return _makeCFrame(0, 0, 0) end,
    fromMatrix = function(pos) return _makeCFrame(pos and pos.X or 0, pos and pos.Y or 0, pos and pos.Z or 0) end,
    fromOrientation = function() return _makeCFrame(0, 0, 0) end,
}
CFrame.identity = CFrame.new(0, 0, 0)
setmetatable(CFrame, {__call = function(_, ...) return _.new(...) end})
PathWaypoint = createTypeDa(\\"PathWaypoint\\", {new = true})
Axes = createTypeDa(\\"Axes\\", {new = true})
Faces = createTypeDa(\\"Faces\\", {new = true})
Vector3int16 = createTypeDa(\\"Vector3int16\\", {new = true})
Vector2int16 = createTypeDa(\\"Vector2int16\\", {new = true})
CatalogSearchParams = createTypeDa(\\"CatalogSearchParams\\", {new = true})
DateTime = {
    now = function()
        return DateTime.fromUnixTimestamp(os.time())
    end,
    fromUnixTimestamp = function(ts)
        ts = toNumberFunction(ts) or 0
        local dt = setmetatable({UnixTimestamp = ts, UnixTimestampMillis = ts * 1000}, {
            __typeof = \\"DateTime\\",
            __index = function(self, key)
                if key == \\"UnixTimestamp\\" then return ts end
                if key == \\"UnixTimestampMillis\\" then return ts * 1000 end
                if key == \\"FormatUniversalTime\\" then
                    return function(self2, fmt, locale)
                        -- convert unix timestamp to date components
                        local t = os.date(\\"!*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"FormatLocalTime\\" then
                    return function(self2, fmt, locale)
                        local t = os.date(\\"*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"ToIsoDate\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return string.format(\\"%04d-%02d-%02dT%02d:%02d:%02dZ\\", t.year, t.month, t.day, t.hour, t.min, t.sec)
                    end
                end
                if key == \\"ToUniversalTime\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return {Year=t.year,Month=t.month,Day=t.day,Hour=t.hour,Minute=t.min,Second=t.sec,Millisecond=0}
                    end
                end
            end,
        })
        return dt
    end,
    fromUnixTimestampMillis = function(ms)
        return DateTime.fromUnixTimestamp(math.floor((toNumberFunction(ms) or 0) / 1000))
    end,
    fromIsoDate = function(iso)
        return DateTime.fromUnixTimestamp(0)
    end,
}
Random = {new = function(seed)
        local obj = {}
        function obj:NextNumber(min, max) return (min or 0) + 0.5 * ((max or 1) - (min or 0)) end
        function obj:NextInteger(min, max) return math.floor((min or 1) + 0.5 * ((max or 100) - (min or 1))) end
        function obj:NextUnitVector() return Vector3.new(0.577, 0.577, 0.577) end
        function obj:Shuffle(tab) return tab end
        function obj:Clone() return Random.new() end
        return obj
    end}
setmetatable(Random, {__call = function(_, seed) return _.new(seed) end})
Enum = createProxyObject(\\"Enum\\", true)
local enumMeta = debugLibrary.getmetatable(Enum)
enumMeta.__index = function(_, key)
    if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
    local enumName = \\"Enum.\\" .. formatValue(key)
    if not _at.enum[enumName] then
        local enumProxy = createProxyObject(enumName, false)
        dumperState.registry[enumProxy] = enumName
        _at.enum[enumName] = enumProxy
    end
    return _at.enum[enumName]
end
Instance = {new = function(className, parent)
        local name = formatValue(className)
        local _validClasses = {
            Part=1,MeshPart=1,UnionOperation=1,SpecialMesh=1,BlockMesh=1,CylinderMesh=1,
            Model=1,Folder=1,Tool=1,LocalScript=1,Script=1,ModuleScript=1,
            RemoteEvent=1,RemoteFunction=1,BindableEvent=1,BindableFunction=1,
            Frame=1,ScreenGui=1,SurfaceGui=1,BillboardGui=1,TextLabel=1,TextButton=1,
            TextBox=1,ImageLabel=1,ImageButton=1,ScrollingFrame=1,ViewportFrame=1,
            UIListLayout=1,UIGridLayout=1,UITableLayout=1,UIPadding=1,UICorner=1,
            UIStroke=1,UIScale=1,UIAspectRatioConstraint=1,UISizeConstraint=1,
            UITextSizeConstraint=1,UIFlexItem=1,UIGradient=1,UIPageLayout=1,
            Humanoid=1,HumanoidDescription=1,Animator=1,Animation=1,
            Sound=1,SoundGroup=1,Attachment=1,Motor6D=1,Weld=1,WeldConstraint=1,
            BallSocketConstraint=1,HingeConstraint=1,SpringConstraint=1,RodConstraint=1,
            RopeConstraint=1,AlignPosition=1,AlignOrientation=1,
            ForceField=1,Decal=1,Texture=1,SelectionBox=1,SelectionSphere=1,
            PointLight=1,SpotLight=1,SurfaceLight=1,Sky=1,Atmosphere=1,Clouds=1,
            Beam=1,Trail=1,ParticleEmitter=1,Fire=1,Smoke=1,Sparkles=1,
            Camera=1,Backpack=1,Hat=1,Accessory=1,Shirt=1,Pants=1,ShirtGraphic=1,
            CharacterMesh=1,BodyColors=1,
            IntValue=1,StringValue=1,BoolValue=1,NumberValue=1,Vector3Value=1,
            CFrameValue=1,Color3Value=1,ObjectValue=1,RayValue=1,BrickColorValue=1,
            ClickDetector=1,ProximityPrompt=1,Dialog=1,DialogChoice=1,
            SpawnLocation=1,SeatPart=1,VehicleSeat=1,
            WedgePart=1,CornerWedgePart=1,TrussPart=1,
            IntersectOperation=1,NegateOperation=1,
            PathfindingLink=1,PathfindingModifier=1,
            Configuration=1,LocalizationTable=1,
            NoCollisionConstraint=1,RigidConstraint=1,
            EditableMesh=1,EditableImage=1,
            LinearVelocity=1,AngularVelocity=1,LineForce=1,VectorForce=1,Torque=1,
            SurfaceAppearance=1,SpecialMesh=1,SelectionBox=1,
        }
        if not _validClasses[name] then
            errorFunction(\\"Unable to create an Instance of type \\\"\\" .. name .. \\"\\\"\\", 2)
        end
        local proxy = createProxyObject(name, false)
        local varName = registerVariable(proxy, name)
        -- class-specific default properties
        local _classDefaults = {
            SkateboardController = {Steer=0, Throttle=0},
            BallSocketConstraint = {LimitsEnabled=false, UpperAngle=45, TwistLimitsEnabled=false, TwistLowerAngle=-45, TwistUpperAngle=45, MaxFrictionTorque=0, Restitution=0},
            HingeConstraint     = {LimitsEnabled=false, UpperAngle=45, LowerAngle=-45, AngularVelocity=0, MotorMaxTorque=0, Restitution=0},
            SpringConstraint    = {Coilcount=5, Damping=1, FreeLength=5, LimitsEnabled=false, MaxLength=5, MinLength=0, Stiffness=100, Visible=false},
            RodConstraint       = {Length=5, LimitAngle0=0, LimitAngle1=0},
            RopeConstraint      = {Length=5},
            PrismaticConstraint = {LimitsEnabled=false, UpperLimit=5, LowerLimit=0, Velocity=0},
            TorsionSpringConstraint = {Damping=1, Stiffness=100, Restitution=0},
            WeldConstraint      = {},
            Motor6D             = {CurrentAngle=0, DesiredAngle=0, MaxVelocity=0},
            ForceField          = {Visible=true},
            Sound               = {Volume=0.5, PlaybackSpeed=1, TimePosition=0, IsPlaying=false, IsPaused=false, Looped=false, RollOffMaxDistance=10000, RollOffMinDistance=10},
            ScreenGui           = {Enabled=true, DisplayOrder=0, IgnoreGuiInset=false, ResetOnSpawn=true},
            Frame               = {BackgroundTransparency=0, BorderSizePixel=1, Visible=true, ZIndex=1, LayoutOrder=0},
            TextLabel           = {Text=\\"\\", TextTransparency=0, TextSize=14, TextWrapped=false, RichText=false, BackgroundTransparency=0, Visible=true, ZIndex=1},
            TextButton          = {Text=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, Modal=false},
            TextBox             = {Text=\\"\\", PlaceholderText=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, ClearTextOnFocus=true},
            ImageLabel          = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            ImageButton         = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            Part                = {Anchored=false, CanCollide=true, Locked=false, Transparency=0, Reflectance=0, Mass=1},
            MeshPart            = {Anchored=false, CanCollide=true, Transparency=0},
            Humanoid            = {Health=100, MaxHealth=100, WalkSpeed=16, JumpPower=50, JumpHeight=7.2, HipHeight=2, AutoRotate=true, PlatformStand=false},
            RemoteEvent         = {},
            RemoteFunction      = {},
            BindableEvent       = {},
            BindableFunction    = {},
            Animator            = {},
            LocalizationTable   = {SourceLocaleId=\\"en-us\\"},
            Animation           = {AnimationId=\\"\\"},
            Attachment          = {},
            AlignPosition       = {RigidityEnabled=false, MaxForce=1e6, MaxVelocity=1e6, Responsiveness=200},
            AlignOrientation    = {RigidityEnabled=false, MaxTorque=1e6, MaxAngularVelocity=1e6, Responsiveness=200},
            LinearVelocity      = {MaxForce=0, VectorVelocity=nil, VelocityConstraintMode=nil, Attachment0=nil},
            SurfaceAppearance   = {ColorMap=nil, NormalMap=nil, RoughnessMap=nil, MetalnessMap=nil},
        }
        local defaults = _classDefaults[name] or {}
        defaults.ClassName = name
        defaults.Name = name
        defaults.Archivable = true
        dumperState.property_store[proxy] = defaults
        if parent then
            local parentPath = dumperState.registry[parent] or serializeValue(parent)
            emitOutput(string.format(\\"local %s = Instance.new(%s, %s)\\", varName, formatStringLiteral(name), parentPath))
            _setParent(proxy, parent)
        else
            emitOutput(string.format(\\"local %s = Instance.new(%s)\\", varName, formatStringLiteral(name)))
        end
        return proxy
    end}
game = createProxyObject(\\"game\\", true)
workspace = createProxyObject(\\"workspace\\", true)
script = createProxyObject(\\"script\\", true)
dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
local function seedCoreRobloxInstances()
    dumperState.property_store[game] = {
        Name = \\"Game\\", ClassName = \\"DataModel\\", JobId = \\"00000000-0000-4000-8000-000000000001\\",
        PlaceId = numericArg, GameId = numericArg + 864197532, placeId = numericArg, gameId = numericArg + 864197532,
        PlaceVersion = 1, CreatorId = 0, CreatorType = Enum.CreatorType.User
    }
    dumperState.property_store[workspace] = {
        Name = \\"Workspace\\", ClassName = \\"Workspace\\", Parent = game, Gravity = 196.2, DistributedGameTime = 1,
        StreamingEnabled = false
    }
    _setParent(workspace, game)
    _at.svcCache.Workspace = workspace

    local players = _at.svcCache.Players or createProxyObject(\\"Players\\", false, game)
    _at.svcCache.Players = players
    dumperState.registry[players] = \\"Players\\"
    dumperState.property_store[players] = {Name = \\"Players\\", ClassName = \\"Players\\", Parent = game, MaxPlayers = 12, RespawnTime = 5}
    _setParent(players, game)

    local lp = _at.localPlayer or createProxyObject(\\"LocalPlayer\\", false, players)
    _at.localPlayer = lp
    dumperState.registry[lp] = \\"LocalPlayer\\"
    dumperState.property_store[lp] = {
        Name = \\"Player\\", ClassName = \\"Player\\", Parent = players, UserId = 1, DisplayName = \\"Player\\",
        MembershipType = Enum.MembershipType.None, FollowUserId = 0, AccountAge = 1000,
        CameraMinZoomDistance = 0, CameraMaxZoomDistance = 400,
        AutoJumpEnabled = true, Neutral = true, Team = nil, LocaleId = \\"en-us\\",
        SimulationRadius = 0, MaxSimulationRadius = 0,
    }
    _setParent(lp, players)

    local function ensureChild(parent, name, className, props)
        local child = createProxyObject(name, false, parent)
        dumperState.registry[child] = name
        props = props or {}
        props.Name = props.Name or name
        props.ClassName = props.ClassName or className or name
        props.Parent = parent
        dumperState.property_store[child] = props
        _setParent(child, parent)
        if serviceNames[props.ClassName] then
            _at.svcCache[props.ClassName] = child
        end
        return child
    end

    ensureChild(lp, \\"PlayerGui\\", \\"PlayerGui\\")
    ensureChild(lp, \\"Backpack\\", \\"Backpack\\")
    local playerScripts = ensureChild(lp, \\"PlayerScripts\\", \\"PlayerScripts\\")
    ensureChild(playerScripts, \\"PlayerModule\\", \\"ModuleScript\\")
    ensureChild(playerScripts, \\"RbxCharacterSounds\\", \\"LocalScript\\")
    ensureChild(workspace, \\"Camera\\", \\"Camera\\", {
        CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080),
        CameraType = Enum.CameraType.Custom, NearPlaneZ = -0.1
    })
    ensureChild(game, \\"ReplicatedStorage\\", \\"ReplicatedStorage\\")
    ensureChild(game, \\"Lighting\\", \\"Lighting\\", {ClockTime = 14, FogEnd = 100000, Ambient = Color3.fromRGB(128, 128, 128), OutdoorAmbient = Color3.fromRGB(128, 128, 128)})
    ensureChild(game, \\"SoundService\\", \\"SoundService\\", {RolloffScale = 1, AmbientReverb = Enum.ReverbType.NoReverb})
    ensureChild(game, \\"RunService\\", \\"RunService\\")
    ensureChild(game, \\"TweenService\\", \\"TweenService\\")
    ensureChild(game, \\"HttpService\\", \\"HttpService\\", {HttpEnabled = false})
    local networkClient = ensureChild(game, \\"NetworkClient\\", \\"NetworkClient\\")
    ensureChild(networkClient, \\"ClientReplicator\\", \\"ClientReplicator\\")
    local ugc = ensureChild(game, \\"Ugc\\", \\"Folder\\")
    ensureChild(ugc, \\"Chat\\", \\"Chat\\")
    ensureChild(game, \\"CollectionService\\", \\"CollectionService\\")
    ensureChild(game, \\"TextService\\", \\"TextService\\")
    ensureChild(game, \\"GuiService\\", \\"GuiService\\")
    ensureChild(game, \\"ContentProvider\\", \\"ContentProvider\\")
end
seedCoreRobloxInstances()
task = {
    wait = function(sec)
        if sec then emitOutput(string.format(\\"task.wait(%s)\\", serializeValue(sec))) else emitOutput(\\"task.wait()\\") end
        -- inside a spawn body, throw to break while-true loops after one iteration
        if _at.spawnDepth and _at.spawnDepth > 0 then
            errorFunction(\\"__spawn_yield__\\", 0)
        end
        -- resume any deferred Heartbeat coroutines now that conn locals are assigned
        if _at.pendingHeartbeat and #_at.pendingHeartbeat > 0 then
            local pending = _at.pendingHeartbeat
            _at.pendingHeartbeat = {}
            for _, co in ipairs(pending) do
                pcall(coroutine.resume, co)
            end
        end
        for inst, props in pairsFunction(dumperState.property_store) do
            if props.ClassName == \\"Part\\" and props.Anchored == false and _at.vectors[props.Position] then
                local v = _at.vectors[props.Position]
                props.Position = Vector3.new(v.x, v.y - 1, v.z)
            end
        end
        return sec or 0.03, osLibrary.clock()
    end,
    spawn = function(func, ...)
        local args = {...}
        emitOutput(\\"task.spawn(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        elseif typeFunction(func) == \\"thread\\" then
            xpcallFunction( function() coroutine.resume(func, table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        local co = coroutine.create(function() end)
        _at.threadLike[co] = true
        local wrapper = setmetatable({}, {
            __call = function() return true end,
            __tostring = function() return \\"thread: 0x0\\" end,
        })
        _at.threadLike[wrapper] = true
        return wrapper
    end,
    delay = function(sec, func, ...)
        local args = {...}
        emitOutput(string.format(\\"task.delay(%s, function()\\", serializeValue(sec or 0)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    defer = function(func, ...)
        local args = {...}
        emitOutput(\\"task.defer(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    cancel = function(thread) emitOutput(\\"task.cancel(thread)\\") end,
    synchronize = function() emitOutput(\\"task.synchronize()\\") end,
    desynchronize = function() emitOutput(\\"task.desynchronize()\\") end
}
wait = function(sec)
    if sec then emitOutput(string.format(\\"wait(%s)\\", serializeValue(sec))) else emitOutput(\\"wait()\\") end
    task.wait(sec)
    return sec or 0.03, osLibrary.clock()
end
delay = function(sec, func)
    emitOutput(string.format(\\"delay(%s, function()\\", serializeValue(sec or 0)))
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then xpcallFunction(func, function() end) end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
spawn = function(func)
    emitOutput(\\"spawn(function()\\")
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then
        -- limit spawn bodies: run once then break out of any while true
        local _spawnDepth = (_at.spawnDepth or 0) + 1
        if _spawnDepth <= 2 then
            _at.spawnDepth = _spawnDepth
            xpcallFunction(func, function() end)
            _at.spawnDepth = _spawnDepth - 1
        end
    end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
tick = function() return osLibrary.time() end
time = function() return osLibrary.clock() end
elapsedTime = function() return osLibrary.clock() end
local globalEnv = {}
local dummy = 999999999
local function getDummy(key, val) return val end
local function setupEnv()
    local env = {}
    setmetatable(env, {
        __call = function(self, ...) return self end,
        __index = function(self, key)
            if _G[key] ~= nil then return getDummy(key, _G[key]) end
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            return nil
        end,
        __newindex = function(self, key, val)
            _G[key] = val
            globalEnv[key] = 0
            emitOutput(string.format(\\"_G.%s = %s\\", formatValue(key), serializeValue(val)))
        end
    })
    return env
end
_G.G = setupEnv()
_G.g = setupEnv()
_G.ENV = setupEnv()
_G.env = setupEnv()
_G.E = setupEnv()
_G.e = setupEnv()
_G.L = setupEnv()
_G.l = setupEnv()
_G.F = setupEnv()
_G.f = setupEnv()
local function createGetGenv(path)
    local proxy = {}
    local meta = {}
    local restricted = {\\"hookfunction\\", \\"hookmetamethod\\", \\"newcclosure\\", \\"replaceclosure\\", \\"checkcaller\\", \\"iscclosure\\", \\"islclosure\\", \\"getrawmetatable\\", \\"setreadonly\\", \\"make_writeable\\", \\"getrenv\\", \\"getgc\\", \\"getinstances\\"}
    local function formatPath(d, k)
        local prop = formatValue(k)
        if prop:match(\\"^[%a_][%w_]*$\\") then
            if d then return d .. \\".\\" .. prop end
            return prop
        else
            local escaped = prop:gsub(\\"'\\", \\"\\\\\\\\'\\")
            if d then return d .. \\"['\\" .. escaped .. \\"']\\" end
            return \\"['\\" .. escaped .. \\"']\\"
        end
    end
    meta.__index = function(_, key)
        if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
        return _G[key]
    end
    meta.__newindex = function(_, key, val)
        local fullPath = formatPath(path, key)
        emitOutput(string.format(\\"getgenv().%s = %s\\", fullPath, serializeValue(val)))
    end
    meta.__call = function() return proxy end
    meta.__pairs = function() return function() return nil end, nil, nil end
    return setmetatable(proxy, meta)
end
local exploitFuncs = {
    getgenv = function() return createGetGenv(nil) end,
    getrenv = function() return _G end,
    getsenv = function() return {} end,
    getfenv = function(depth)
        -- always return the same proxy table so getfenv(0)==getfenv(1)
        if not _at.fenvCache then
            _at.fenvCache = setmetatable({}, {
                __index = function(_, key)
                    if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
                    return _G[key]
                end,
                __newindex = function(_, k, v) rawset(_, k, v) end
            })
        end
        return _at.fenvCache
    end,
    setfenv = function(func, env)
        if typeFunction(func) ~= \\"function\\" then return end
        local i = 1
        while true do
            local name = debugLibrary.getupvalue(func, i)
            if name == \\"_ENV\\" then debugLibrary.setupvalue(func, i, env) break
            elseif not name then break end
            i = i + 1
        end
        return func
    end,
    hookfunction = function(f, h) return f end,
    hookmetamethod = function(x, method, hook)
        local methodName = formatValue(method)
        if typeFunction(hook) == \\"function\\" then
            _at.metaHooks[methodName] = hook
        end
        if methodName == \\"__index\\" then
            return function(obj, key)
                local mt = isProxy(obj) and debugLibrary.getmetatable(obj)
                if mt and typeFunction(mt.__index) == \\"function\\" then
                    local saved = _at.metaHooks[methodName]
                    _at.metaHooks[methodName] = nil
                    local ok, result = pcallFunction(mt.__index, obj, key)
                    _at.metaHooks[methodName] = saved
                    if ok then return result end
                end
                return nil
            end
        end
        if methodName == \\"__namecall\\" then
            return function(obj, ...)
                local methodToCall = _at.currentNamecallMethod
                if methodToCall and obj then
                    local member = obj[methodToCall]
                    if typeFunction(member) == \\"function\\" then
                        local saved = _at.metaHooks[methodName]
                        _at.metaHooks[methodName] = nil
                        local ok, result = pcallFunction(member, obj, ...)
                        _at.metaHooks[methodName] = saved
                        if ok then return result end
                    end
                end
                return nil
            end
        end
        return function() end
    end,
    getrawmetatable = function(x)
        if isProxy(x) then
            -- all Instance proxies share ONE metatable so rawequal(mt1,mt2)==true
            if not _at.sharedInstanceMeta then
                local mt = {}
                -- __index must be a C function so debug.getinfo says what==\\"C\\"
                -- use a newproxy userdata with a C-backed metatable trick:
                -- we tag a wrapper as cclosure so getinfo returns \\"C\\"
                local indexFn = function() end
                if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
                _at.cclosureSet[indexFn] = true
                mt.__index = indexFn
                mt.__newindex = function() end
                mt.__namecall = function() end
                mt.__len = function() return 0 end
                mt.__tostring = function() return \\"Instance\\" end
                _at.sharedInstanceMeta = mt
            end
            return _at.sharedInstanceMeta
        end
        return getmetatable(x) or {}
    end,
    setrawmetatable = function(x, mt) return x end,
    getnamecallmethod = function() return _at.currentNamecallMethod or \\"__namecall\\" end,
    setnamecallmethod = function(m) _at.currentNamecallMethod = formatValue(m) end,
    checkcaller = function() return true end,
    islclosure = function(f)
        if isProxy(f) then return false end
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return false end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return false end
        return false
    end,
    iscclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return true end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return true end
        return false
    end,
    newcclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return f end
        if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
        local wrapper = function(...) return f(...) end
        _at.cclosureSet[wrapper] = true
        return wrapper
    end,
    clonefunction = function(f) return f end,
    request = function(req)
        emitOutput(string.format(\\"request(%s)\\", serializeValue(req)))
        table.insert(dumperState.string_refs, {value = req.Url or req.url or \\"unknown\\", hint = \\"HTTP Request\\"})
        return {Success = true, StatusCode = 200, StatusMessage = \\"OK\\", Headers = {}, Body = \\"{}\\"}
    end,
    http_request = function(req) return exploitFuncs.request(req) end,
    syn = {request = function(req) return exploitFuncs.request(req) end},
    http = {request = function(req) return exploitFuncs.request(req) end},
    HttpPost = function(url, data)
        emitOutput(string.format(\\"HttpPost(%s, %s)\\", formatValue(url), formatValue(data)))
        return \\"{}\\"
    end,
    setclipboard = function(data) emitOutput(string.format(\\"setclipboard(%s)\\", serializeValue(data))) end,
    getclipboard = function() return '\\"' end,
    identifyexecutor = function() return \\"FlameDumperV1\\", \\"1.0\\" end,
    getexecutorname = function() return \\"FlameDumperV1\\" end,
    gethui = function()
        local hui = createProxyObject(\\"HiddenUI\\", false)
        registerVariable(hui, \\"HiddenUI\\")
        emitOutput(string.format(\\"local %s = gethui()\\", dumperState.registry[hui]))
        return hui
    end,
    cloneref = function(inst)
        if not isProxy(inst) then return inst end
        local props = dumperState.property_store[inst] or {}
        local className = props.ClassName or dumperState.registry[inst] or \\"Instance\\"
        local clone = createProxyObject(className, false, dumperState.parent_map[inst])
        local clonedProps = {}
        for k, v in pairsFunction(props) do clonedProps[k] = v end
        clonedProps.ClassName = clonedProps.ClassName or className
        clonedProps.Name = clonedProps.Name or props.Name or className
        dumperState.property_store[clone] = clonedProps
        dumperState.registry[clone] = (dumperState.registry[inst] or className) .. \\"_cloneref\\"
        _at.refBase[clone] = _at.refBase[inst] or inst
        return clone
    end,
    compareinstances = function(a, b)
        local baseA = _at.refBase[a] or a
        local baseB = _at.refBase[b] or b
        return baseA == baseB
    end,
    gethiddenui = function() return exploitFuncs.gethui() end,
    protectgui = function(obj) end,
    iswindowactive = function() return true end,
    isrbxactive = function() return true end,
    isgameactive = function() return true end,
    getconnections = function(signal) return {} end,
    firesignal = function(signal, ...) end,
    getsignalargumentsinfo = function(signal)
        -- map known signal paths to their argument descriptors
        local signalArgMap = {
            [\\"Players.PlayerAdded\\"]          = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerRemoving\\"]       = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerMembershipChanged\\"] = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Humanoid.Died\\"]                = {},
            [\\"Humanoid.HealthChanged\\"]       = {{Name=\\"health\\", Type=\\"number\\"}},
            [\\"Humanoid.StateChanged\\"]        = {{Name=\\"old\\", Type=\\"EnumItem\\"}, {Name=\\"new\\", Type=\\"EnumItem\\"}},
            [\\"BasePart.Touched\\"]             = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"BasePart.TouchEnded\\"]          = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"RunService.Heartbeat\\"]         = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.RenderStepped\\"]     = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.Stepped\\"]           = {{Name=\\"time\\", Type=\\"number\\"}, {Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"UserInputService.InputBegan\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputEnded\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputChanged\\"]= {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"RemoteEvent.OnClientEvent\\"]    = {{Name=\\"args\\", Type=\\"Tuple\\"}},
            [\\"BindableEvent.Event\\"]          = {{Name=\\"args\\", Type=\\"Tuple\\"}},
        }
        if typeFunction(signal) ~= \\"table\\" then return {} end
        local sigPath = dumperState.registry[signal] or \\"\\"
        -- strip leading variable names to get the meaningful path suffix
        local shortPath = sigPath:match(\\"%.(.+)$\\") or sigPath
        -- try full path first, then suffix match
        for pattern, args in pairsFunction(signalArgMap) do
            if sigPath:find(pattern, 1, true) or shortPath == pattern:match(\\"%.(.+)$\\") then
                return args
            end
        end
        -- generic fallback: return empty table (signal exists but unknown args)
        return {}
    end,
    fireclickdetector = function(detector, dist) end,
    fireproximityprompt = function(prompt) end,
    firetouchinterest = function(a, b, c) end,
    getinstances = function()
        local instances = {}
        for inst in pairsFunction(dumperState.property_store) do
            if isProxy(inst) and (dumperState.property_store[inst].ClassName or dumperState.registry[inst]) then
                table.insert(instances, inst)
            end
        end
        if #instances == 0 then table.insert(instances, game) end
        return instances
    end,
    getnilinstances = function() return {} end,
    getgc = function() return {} end,
    getscripts = function() return {} end,
    getrunningscripts = function()
        -- AT3: must include the Animate script from character, but NOT arbitrary LocalScript instances
        local result = {}
        if _at.animateScript then result[#result+1] = _at.animateScript end
        return result
    end,
    getloadedmodules = function() return {} end,
    getcallingscript = function() return script end,
    readfile = function(file)
        emitOutput(string.format(\\"readfile(%s)\\", formatStringLiteral(file)))
        return _at.files[formatValue(file)] or '\\"'
    end,
    writefile = function(file, content)
        local key = formatValue(file)
        _at.files[key] = formatValue(content)
        _at.files_hidden = _at.files_hidden or {}
        _at.files_hidden[key] = true  -- mark as hidden from listfiles
        emitOutput(string.format(\\"writefile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    appendfile = function(file, content)
        local name = formatValue(file)
        _at.files[name] = (_at.files[name] or \\"\\") .. formatValue(content)
        emitOutput(string.format(\\"appendfile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    loadfile = function(file) return function() return createProxyObject(\\"loaded_file\\", false) end end,
    listfiles = function(folder)
        local base = formatValue(folder or \\"\\")
        -- normalize: strip leading slash so \\"/\\" matches all files
        base = base:gsub(\\"^/+\\", \\"\\")
        local result = {}
        for name in pairsFunction(_at.folders) do
            if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
        end
        for name in pairsFunction(_at.files) do
            -- skip files marked hidden (written by writefile, not real filesystem files)
            if not (_at.files_hidden and _at.files_hidden[name]) then
                if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
            end
        end
        return result
    end,
    isfile = function(file) return _at.files[formatValue(file)] ~= nil end,
    isfolder = function(folder) return _at.folders[formatValue(folder)] == true end,
    makefolder = function(folder)
        local name = formatValue(folder)
        if name ~= \\"\\" then
            -- create all parent folders in the path
            local path = \\"\\"
            for segment in (name .. \\"/\\"):gmatch(\\"([^/]+)/\\") do
                path = path == \\"\\" and segment or (path .. \\"/\\" .. segment)
                _at.folders[path] = true
            end
        end
        emitOutput(string.format(\\"makefolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfolder = function(folder)
        local name = formatValue(folder)
        _at.folders[name] = nil
        emitOutput(string.format(\\"delfolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfile = function(file)
        _at.files[formatValue(file)] = nil
        emitOutput(string.format(\\"delfile(%s)\\", formatStringLiteral(file)))
    end,
    DrawingImmediate = (function()
        local function makePaint()
            local cbs = {}
            return {
                Connect = function(self, fn)
                    cbs[#cbs+1] = fn
                    -- return plain table so typeof(cn)==\\"table\\" passes the AT check
                    return {
                        Disconnect = function(self)
                            for i,v in ipairs(cbs) do if v==fn then table.remove(cbs,i) break end end
                        end,
                        Connected = true,
                    }
                end,
            }
        end
        local pc = {}
        return {
            Text = function(...) emitOutput(\\"DrawingImmediate.Text(...)\\") end,
            Line = function(...) emitOutput(\\"DrawingImmediate.Line(...)\\") end,
            Circle = function(...) emitOutput(\\"DrawingImmediate.Circle(...)\\") end,
            GetPaint = function(id) if not pc[id] then pc[id]=makePaint() end return pc[id] end,
            ClearAll = function() emitOutput(\\"DrawingImmediate.ClearAll()\\") end,
        }
    end)(),
    Drawing = {
        new = function(type)
            local t = formatValue(type)
            local proxy = createProxyObject(\\"Drawing_\\" .. t, false)
            registerVariable(proxy, t)
            _at.userdata[proxy] = \\"renderobj\\"
            emitOutput(string.format(\\"local %s = Drawing.new(%s)\\", dumperState.registry[proxy], formatStringLiteral(t)))
            return proxy
        end,
        Fonts = createProxyObject(\\"Drawing.Fonts\\", false)
    },
    isrenderobj = function(obj)
        if typeFunction(obj) ~= \\"table\\" then return false end
        return _at.userdata[obj] == \\"renderobj\\"
    end,
    crypt = {
        base64encode = function(s) return s end,
        base64decode = function(s) return s end,
        base64_encode = function(s) return s end,
        base64_decode = function(s) return s end,
        encrypt = function(s, k) return s end,
        decrypt = function(s, k) return s end,
        hash = function(s) return \\"hash\\" end,
        generatekey = function(len) return string.rep(\\"0\\", len or 32) end,
        generatebytes = function(len) return string.rep(\\"\\\\0\\", len or 16) end
    },
    base64_encode = function(s) return s end,
    base64_decode = function(s) return s end,
    base64encode = function(s) return s end,
    base64decode = function(s) return s end,
    mouse1click = function() emitOutput(\\"mouse1click()\\") end,
    mouse1press = function() emitOutput(\\"mouse1press()\\") end,
    mouse1release = function() emitOutput(\\"mouse1release()\\") end,
    mouse2click = function() emitOutput(\\"mouse2click()\\") end,
    mouse2press = function() emitOutput(\\"mouse2press()\\") end,
    mouse2release = function() emitOutput(\\"mouse2release()\\") end,
    mousemoverel = function(x, y) emitOutput(string.format(\\"mousemoverel(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousemoveabs = function(x, y) emitOutput(string.format(\\"mousemoveabs(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousescroll = function(delta) emitOutput(string.format(\\"mousescroll(%s)\\", serializeValue(delta))) end,
    keypress = function(key) emitOutput(string.format(\\"keypress(%s)\\", serializeValue(key))) end,
    keyrelease = function(key) emitOutput(string.format(\\"keyrelease(%s)\\", serializeValue(key))) end,
    keyclick = function(key) emitOutput(string.format(\\"keyclick(%s)\\", serializeValue(key))) end,
    isreadonly = function(t) return false end,
    setreadonly = function(t, val) return t end,
    make_writeable = function(t) return t end,
    make_readonly = function(t) return t end,
    getthreadidentity = function() return 7 end,
    setthreadidentity = function(id) end,
    getidentity = function() return 7 end,
    setidentity = function(id) end,
    getthreadcontext = function() return 7 end,
    setthreadcontext = function(id) end,
    getcustomasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getsynasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getinfo = function(func) return {source = \\"=\\", what = \\"Lua\\", name = \\"unknown\\", short_src = \\"dumper\\"} end,
    getconstants = function(func) return {} end,
    getupvalues = function(func) return {} end,
    getprotos = function(func) return {} end,
    getupvalue = function(func, i) return nil end,
    setupvalue = function(func, i, val) end,
    setconstant = function(func, i, val) end,
    getconstant = function(func, i) return nil end,
    getproto = function(func, i) return function() end end,
    setproto = function(func, i, f) end,
    getstack = function(level, i) return nil end,
    setstack = function(level, i, val) end,
    debug = {
        getinfo = function(func, ...)
            if func == print or func == _G.print or func == warn or func == _G.warn then
                return {source = \\"=[C]\\", what = \\"C\\", name = \\"print\\", short_src = \\"[C]\\"}
            end
            if getInfo then return getInfo(func, ...) end
            return {source = \\"=[C]\\", what = \\"C\\", short_src = \\"[C]\\"}
        end,
        getupvalue = debugLibrary.getupvalue or function() return nil end,
        setupvalue = debugLibrary.setupvalue or function() end,
        getmetatable = debugLibrary.getmetatable,
        setmetatable = debugLibrary.setmetatable or setmetatable,
        traceback = getTraceback or function() return '\\"' end,
        profilebegin = function() end,
        profileend = function() end,
        sethook = function() end
    },
    rconsoleprint = function(s) end,
    rconsoleclear = function() end,
    rconsolecreate = function() end,
    rconsoledestroy = function() end,
    rconsoleinput = function() return \\"\\" end,
    rconsoleinfo = function(s) end,
    rconsolewarn = function(s) end,
    rconsoleerr = function(s) end,
    rconsolename = function(name) end,
    printconsole = function(s) end,
    setfflag = function(flag, val) end,
    getfflag = function(flag) return \\"\\" end,
    setfpscap = function(cap) emitOutput(string.format(\\"setfpscap(%s)\\", serializeValue(cap))) end,
    getfpscap = function() return 60 end,
    isnetworkowner = function(part) return true end,
    gethiddenproperty = function(instance, prop)
        if not isProxy(instance) then return nil, false end
        local props = dumperState.property_store[instance]
        if props and props[prop] ~= nil then return props[prop], true end
        return nil, false
    end,
    sethiddenproperty = function(instance, prop, val)
        if isProxy(instance) then
            local props = dumperState.property_store[instance]
            if props then
                if prop == \\"DistributedGameTime\\" then
                    -- don't store the set value; just record a tick base from current real value
                    -- so subsequent reads keep ticking from where they were
                    if not _at._dgtClock then
                        _at._dgtBase = (props[prop] or 1)
                        _at._dgtClock = osLibrary.clock()
                    end
                    -- intentionally do NOT store val - real Roblox ignores the set
                else
                    props[prop] = val
                end
            end
        end
        emitOutput(string.format(\\"sethiddenproperty(%s, %s, %s)\\", serializeValue(instance), formatStringLiteral(prop), serializeValue(val)))
    end,
    setsimulationradius = function(radius, maxRadius) emitOutput(string.format(\\"setsimulationradius(%s%s)\\", serializeValue(radius), maxRadius and \\", \\" .. serializeValue(maxRadius) or \\"\\")) end,
    getspecialinfo = function(instance) return {} end,
    saveinstance = function(options) emitOutput(string.format(\\"saveinstance(%s)\\", serializeValue(options or {}))) end,
    decompile = function(script) return \\"-- decompiled\\" end,
    lz4compress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4compress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        local lenBytes = string.char(
            math.floor(#s / 16777216) % 256,
            math.floor(#s / 65536) % 256,
            math.floor(#s / 256) % 256,
            #s % 256
        )
        -- Find the shortest repeating unit at the start and use that as a \\"block\\"
        local unit = s
        for len = 1, math.floor(#s / 2) do
            local candidate = s:sub(1, len)
            local repeated = string.rep(candidate, math.floor(#s / len))
            local remainder = s:sub(#repeated + 1)
            if repeated .. remainder == s then
                unit = candidate
                break
            end
        end
        -- Encode as: magic + origLen + unitLen(2 bytes) + unit + count(2 bytes) + remainder
        local count = math.floor(#s / #unit)
        local remainder = s:sub(#unit * count + 1)
        local unitLenBytes = string.char(math.floor(#unit / 256) % 256, #unit % 256)
        local countBytes = string.char(math.floor(count / 256) % 256, count % 256)
        local remLenBytes = string.char(math.floor(#remainder / 256) % 256, #remainder % 256)
        return magic .. lenBytes .. unitLenBytes .. unit .. countBytes .. remLenBytes .. remainder
    end,
    lz4decompress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4decompress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        if #s < 12 or s:sub(1, 4) ~= magic then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local b1, b2, b3, b4 = s:byte(5), s:byte(6), s:byte(7), s:byte(8)
        local origLen = b1 * 16777216 + b2 * 65536 + b3 * 256 + b4
        local unitLenHi, unitLenLo = s:byte(9), s:byte(10)
        local unitLen = unitLenHi * 256 + unitLenLo
        if #s < 10 + unitLen + 4 then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local unit = s:sub(11, 10 + unitLen)
        local countHi, countLo = s:byte(11 + unitLen), s:byte(12 + unitLen)
        local count = countHi * 256 + countLo
        local remLenHi, remLenLo = s:byte(13 + unitLen), s:byte(14 + unitLen)
        local remLen = remLenHi * 256 + remLenLo
        local remainder = s:sub(15 + unitLen, 14 + unitLen + remLen)
        return (string.rep(unit, count) .. remainder):sub(1, origLen)
    end,
    MessageBox = function(text, caption, type) return 1 end,
    setwindowactive = function() end,
    setwindowtitle = function(title) end,
    queue_on_teleport = function(code) emitOutput(string.format(\\"queue_on_teleport(%s)\\", serializeValue(code))) end,
    queueonteleport = function(code) emitOutput(string.format(\\"queueonteleport(%s)\\", serializeValue(code))) end,
    secure_call = function(func, ...) return func(...) end,
    create_secure_function = function(func) return func end,
    isvalidinstance = function(instance) return instance ~= nil end,
    validcheck = function(instance) return instance ~= nil end
}
for name, func in pairsFunction(exploitFuncs) do
    _G[name] = func
end
local nativeBit32 = bit32
local bitLibrary = {}
local function toBit(n)
    n = (n or 0) % 4294967296
    if n >= 2147483648 then n = n - 4294967296 end
    return math.floor(n)
end
local function toU32(n) return math.floor((n or 0) % 4294967296) end

local function _band(a, b)
    if nativeBit32 then return nativeBit32.band(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 and b > 0 do
        if a % 2 == 1 and b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bor(a, b)
    if nativeBit32 then return nativeBit32.bor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 == 1 or b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bxor(a, b)
    if nativeBit32 then return nativeBit32.bxor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 ~= b % 2 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _lshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return toU32(toU32(n) * (2 ^ bits))
end
local function _rshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return math.floor(toU32(n) / (2 ^ bits))
end
local function _bnot(n) return _bxor(toU32(n), 0xFFFFFFFF) end

bitLibrary.tobit = toBit
bitLibrary.tohex = function(n, len)
    return string.format(\\"%0\\" .. (len or 8) .. \\"x\\", toU32(n))
end
bitLibrary.band = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _band(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bxor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bxor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bnot    = function(n) return toBit(_bnot(n or 0)) end
bitLibrary.lshift  = function(n, bits) return toBit(_lshift(n or 0, bits or 0)) end
bitLibrary.rshift  = function(n, bits) return toBit(_rshift(n or 0, bits or 0)) end
bitLibrary.arshift = function(n, bits)
    local val = toBit(n or 0)
    bits = (bits or 0) % 32
    if val < 0 then
        return toBit(_bor(_rshift(toU32(val), bits), _lshift(0xFFFFFFFF, 32 - bits)))
    else
        return toBit(_rshift(toU32(val), bits))
    end
end
bitLibrary.rol = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_lshift(n, bits), _rshift(n, 32 - bits)))
end
bitLibrary.ror = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_rshift(n, bits), _lshift(n, 32 - bits)))
end
bitLibrary.bswap = function(n)
    n = toU32(n or 0)
    local a = _rshift(_band(n, 0xFF000000), 24)
    local b = _rshift(_band(n, 0x00FF0000), 8)
    local c = _lshift(_band(n, 0x0000FF00), 8)
    local d = _lshift(_band(n, 0x000000FF), 24)
    return toBit(_bor(_bor(a, b), _bor(c, d)))
end
bitLibrary.countlz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    if _band(n, 0xFFFF0000) == 0 then count = count + 16; n = _lshift(n, 16) end
    if _band(n, 0xFF000000) == 0 then count = count + 8;  n = _lshift(n, 8)  end
    if _band(n, 0xF0000000) == 0 then count = count + 4;  n = _lshift(n, 4)  end
    if _band(n, 0xC0000000) == 0 then count = count + 2;  n = _lshift(n, 2)  end
    if _band(n, 0x80000000) == 0 then count = count + 1   end
    return count
end
bitLibrary.countrz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    while _band(n, 1) == 0 do n = _rshift(n, 1); count = count + 1 end
    return count
end
bitLibrary.lrotate = bitLibrary.rol
bitLibrary.rrotate = bitLibrary.ror
bitLibrary.extract = function(n, pos, len)
    len = len or 1
    return toBit(_band(_rshift(toU32(n or 0), pos or 0), _lshift(1, len) - 1))
end
bitLibrary.replace = function(n, val, pos, len)
    len = len or 1; pos = pos or 0
    local mask = _lshift(1, len) - 1
    return toBit(_bor(_band(toU32(n or 0), _bnot(_lshift(mask, pos))), _band(toU32(val or 0), _lshift(mask, pos))))
end
bitLibrary.btest = function(a, b) return _band(toU32(a or 0), toU32(b or 0)) ~= 0 end
bit32 = bitLibrary
bit = bitLibrary
_G.bit = bitLibrary
_G.bit32 = bitLibrary
table.getn = table.getn or function(t) return #t end
table.foreach = table.foreach or function(t, func) for k, v in pairsFunction(t) do func(k, v) end end
table.foreachi = table.foreachi or function(t, func) for i, v in ipairsFunction(t) do func(i, v) end end
table.find = table.find or function(t, value, init)
    for i = (init or 1), #t do
        if t[i] == value then return i end
    end
    return nil
end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairsFunction(t) do out[k] = v end
    return out
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function(t) return false end
table.clear = table.clear or function(t) for k in pairsFunction(t) do t[k] = nil end end
table.find = table.find or function(t, val, init)
    for i = init or 1, #t do
        if t[i] == val then return i end
    end
    return nil
end
table.clear = table.clear or function(t)
    for k in pairs(t) do t[k] = nil end
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function() return false end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairs(t) do out[k] = v end
    return out
end
table.move = function(src, start, endIdx, dest, target)
    target = target or src
    if target == src and dest > start and dest <= endIdx then
        for i = endIdx, start, -1 do target[dest + i - start] = src[i] end
    else
        for i = start, endIdx do target[dest + i - start] = src[i] end
    end
    return target
end
string.split = string.split or function(str, sep)
    local t = {}
    for match in string.gmatch(str, \\"([^\\" .. (sep or \\"%s\\") .. \\"]+)\\") do table.insert(t, match) end
    return t
end
if not math.frexp then
    math.frexp = function(x)
        if x == 0 then return 0, 0 end
        local exp = math.floor(math.log(math.abs(x)) / math.log(2)) + 1
        local m = x / 2 ^ exp
        return m, exp
    end
end
if not math.ldexp then math.ldexp = function(m, e) return m * 2 ^ e end end
if not utf8 then
    utf8 = {}
    utf8.char = function(...)
        local args = {...}
        local chars = {}
        for _, byte in ipairsFunction(args) do table.insert(chars, string.char(byte % 256)) end
        return table.concat(chars)
    end
    utf8.len = function(s) return #s end
    utf8.codes = function(s)
        local i = 0
        return function() i = i + 1; if i <= #s then return i, string.byte(s, i) end end
    end
end
-- graphemes: bypass nested anti-tamper chain third[1][1][1][1][1][1](first, second)
utf8.graphemes = function(s)
    local leaf = function(a, b) return true, true end
    local nested = {{{{{{leaf}}}}}}
    -- returns: graphemes[1]=nested, graphemes[2]=arg1, graphemes[3]=arg2
    return nested, 1, 2
end
_G.utf8 = utf8
pairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return pairsFunction(t) end
    return function() return nil end, t, nil
end
ipairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return ipairsFunction(t) end
    return function() return nil end, t, 0
end
_G.pairs = pairs
_G.ipairs = ipairs
_G.math = math
_G.table = table
-- override string.dump to error on exploit/proxy functions like real Roblox
local _realStringDump = string.dump
string.dump = function(f, ...)
    if isProxy(f) then
        errorFunction(\\"unable to dump given function\\", 2)
    end
    -- exploit funcs registered in _G are not dumpable
    for name, val in pairsFunction(exploitFuncs) do
        if val == f then errorFunction(\\"unable to dump given function\\", 2) end
    end
    return _realStringDump(f, ...)
end
_G.string = string
_G.os = os
os.execute = function() return nil end
os.exit = function() return nil end
os.remove = function() return nil, \\"disabled\\" end
os.rename = function() return nil, \\"disabled\\" end
_G.coroutine = coroutine
_G.io = nil
_G.debug = exploitFuncs.debug
_G._realSetHook = setHook
_G.utf8 = utf8
_G.next = next
_G.tostring = tostring
_G.tonumber = tonumber
_G.getmetatable = getmetatable
_G.setmetatable = setmetatable
_G.pcall = function(f, ...)
    local results = {pcallFunction(f, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.xpcall = function(f, errFunc, ...)
    local function wrapper(err)
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then return err end
        if errFunc then return errFunc(err) end
        return err
    end
    local results = {xpcallFunction(f, wrapper, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.error = errorFunction
if _G.originalError == nil then _G.originalError = errorFunction end
_G.assert = assert
_G.select = select
_G.type = typeFunction
_G.rawget = rawget
_G.rawset = rawset
_G.rawequal = rawEqualFunction
_G.rawlen = rawlen or function(t) return #t end
_G.unpack = table.unpack or unpack
_G.pack = table.pack or function(...) return {n = select(\\"#\\", ...), ...} end
_G.task = task
_G.wait = wait
_G.Wait = wait
_G.delay = delay
_G.Delay = delay
_G.spawn = spawn
_G.Spawn = spawn
_G.tick = tick
_G.time = time
_G.elapsedTime = elapsedTime
_G.game = game
_G.Game = game
_G.workspace = workspace
_G.Workspace = workspace
_G.script = script
_G.Enum = Enum
_G.Instance = Instance
_G.Random = Random
_G.Vector3 = Vector3
_G.Vector2 = Vector2
_G.CFrame = CFrame
_G.Color3 = Color3
_G.BrickColor = BrickColor
_G.UDim = UDim
_G.UDim2 = UDim2
_G.TweenInfo = TweenInfo
_G.Rect = Rect
_G.Region3 = Region3
_G.Region3int16 = Region3int16
_G.Ray = Ray
_G.NumberRange = NumberRange
_G.NumberSequence = NumberSequence
_G.NumberSequenceKeypoint = NumberSequenceKeypoint
_G.ColorSequence = ColorSequence
_G.ColorSequenceKeypoint = ColorSequenceKeypoint
_G.PhysicalProperties = PhysicalProperties
_G.Font = Font
_G.RaycastParams = RaycastParams
_G.OverlapParams = OverlapParams
_G.PathWaypoint = PathWaypoint
_G.Axes = Axes
_G.Faces = Faces
_G.Vector3int16 = Vector3int16
_G.Vector2int16 = Vector2int16
_G.CatalogSearchParams = CatalogSearchParams
_G.DateTime = DateTime
settings = function()
    local enumKey = \\"Enum.QualityLevel.Automatic\\"
    if not _at.enum[enumKey] then
        local p = createProxyObject(enumKey, false)
        dumperState.registry[p] = enumKey
        _at.enum[enumKey] = p
    end
    local qualityProxy = _at.enum[enumKey]
    return {
        Rendering = {QualityLevel = qualityProxy, FrameRateManager = 0, EagerBulkExecution = false},
        Studio    = {},
        Network   = {IncomingReplicationLag = 0},
        Physics   = {PhysicsEnvironmentalThrottle = createProxyObject(\\"Enum.EnviromentalPhysicsThrottle.DefaultAuto\\", false)},
    }
end
_G.settings = settings
getmetatable = function(x)
    if _at.userdata[x] then return getMetatableFunction(x) end
    if isProxy(x) then return \\"The metatable is locked\\" end
    return getMetatableFunction(x)
end
_G.getmetatable = getmetatable
type = function(x)
    if _at.threadLike[x] then return \\"thread\\" end
    if _at.userdata[x] then return \\"userdata\\" end
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then return \\"userdata\\" end
    return typeFunction(x)
end
_G.type = type
buffer = {
    create = function(size)
        local b = {}
        _at.buffers[b] = string.rep(\\"\0\\", size or 0)
        return b
    end,
    fromstring = function(s)
        local b = {}
        _at.buffers[b] = formatValue(s)
        return b
    end,
    tostring = function(b)
        return _at.buffers[b] or \\"\\"
    end,
    len = function(b)
        return #(_at.buffers[b] or \\"\\")
    end,
    copy = function(dst, dstOffset, src, srcOffset, count)
        local srcData = _at.buffers[src] or \\"\\"
        local dstData = _at.buffers[dst] or \\"\\"
        srcOffset = (srcOffset or 0) + 1
        dstOffset = (dstOffset or 0) + 1
        local chunk = srcData:sub(srcOffset, count and srcOffset + count - 1 or -1)
        local before = dstData:sub(1, dstOffset - 1)
        local after  = dstData:sub(dstOffset + #chunk)
        _at.buffers[dst] = before .. chunk .. after
    end,
    fill = function(b, offset, value, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        count  = count or (#data - offset + 1)
        local fill = string.rep(string.char(value % 256), count)
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + count)
        _at.buffers[b] = before .. fill .. after
    end,
    writestring = function(b, offset, s, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        s = formatValue(s)
        if count then s = s:sub(1, count) end
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + #s)
        _at.buffers[b] = before .. s .. after
    end,
    readstring = function(b, offset, len)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        return data:sub(offset, len and offset + len - 1 or -1)
    end,
    writeu8  = function(b, offset, v) local d=_at.buffers[b] or\\"\\"; offset=(offset or 0)+1; _at.buffers[b]=d:sub(1,offset-1)..string.char(v%256)..d:sub(offset+1) end,
    readu8   = function(b, offset) local d=_at.buffers[b] or\\"\\"; return string.byte(d,(offset or 0)+1) or 0 end,
    writeu16 = function(b, offset, v) offset=(offset or 0); buffer.writeu8(b,offset,v%256); buffer.writeu8(b,offset+1,math.floor(v/256)%256) end,
    readu16  = function(b, offset) return buffer.readu8(b,offset) + buffer.readu8(b,(offset or 0)+1)*256 end,
    writeu32 = function(b, offset, v) offset=(offset or 0); for i=0,3 do buffer.writeu8(b,offset+i,math.floor(v/(256^i))%256) end end,
    readu32  = function(b, offset) local v=0; for i=0,3 do v=v+buffer.readu8(b,(offset or 0)+i)*(256^i) end; return v end,
    writei8  = function(b, offset, v) buffer.writeu8(b, offset, v < 0 and v+256 or v) end,
    readi8   = function(b, offset) local v=buffer.readu8(b,offset); return v>=128 and v-256 or v end,
    writei16 = function(b, offset, v) buffer.writeu16(b, offset, v < 0 and v+65536 or v) end,
    readi16  = function(b, offset) local v=buffer.readu16(b,offset); return v>=32768 and v-65536 or v end,
    writei32 = function(b, offset, v) buffer.writeu32(b, offset, v < 0 and v+4294967296 or v) end,
    readi32  = function(b, offset) local v=buffer.readu32(b,offset); return v>=2147483648 and v-4294967296 or v end,
    writef32 = function(b, offset, v) buffer.writeu32(b, offset, math.floor(math.abs(v)*1000)%4294967296) end,
    readf32  = function(b, offset) return buffer.readu32(b,offset)/1000 end,
    writef64 = function(b, offset, v) buffer.writeu32(b, offset, 0); buffer.writeu32(b, (offset or 0)+4, math.floor(math.abs(v)*1000)%4294967296) end,
    readf64  = function(b, offset) return buffer.readu32(b,(offset or 0)+4)/1000 end,
}
_G.buffer = buffer
typeof = function(x)
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then
        if _at.typeOverride[x] then return _at.typeOverride[x] end
        local regName = dumperState.registry[x]
        if regName then
            if regName == \\"Enum\\" then return \\"Enums\\" end
            if regName:match(\\"^Enum%.[^%.]+$\\") then return \\"Enum\\" end
            if regName:match(\\"^Enum%.[^%.]+%.[^%.]+$\\") then return \\"EnumItem\\" end
            if regName:match(\\"Vector3\\") then return \\"Vector3\\" end
            if regName:match(\\"CFrame\\") then return \\"CFrame\\" end
            if regName:match(\\"Color3\\") then return \\"Color3\\" end
            if regName:match(\\"UDim\\") then return \\"UDim2\\" end
        end
        return \\"Instance\\"
    end
    if _at.threadLike[x] then return \\"thread\\" end
    local mt = getMetatableFunction(x)
    if mt and mt.__typeof then return mt.__typeof end
    return typeFunction(x) == \\"table\\" and \\"table\\" or typeFunction(x)
end
_G.typeof = typeof
newproxy = function(withMeta)
    local proxy = {}
    _at.userdata[proxy] = true
    if withMeta then
        setmetatable(proxy, {})
    end
    return proxy
end
_G.newproxy = newproxy
tonumber = function(x, base)
    if getProxyValue(x) ~= 0 then return 123456789 end
    return toNumberFunction(x, base)
end
_G.tonumber = tonumber
rawequal = function(a, b) return rawEqualFunction(a, b) end
_G.rawequal = rawequal
tostring = function(x)
    if isProxy(x) then
        local mt = getMetatableFunction(x)
        if mt and mt.__tostring then
            local ok, r = pcallFunction(mt.__tostring, x)
            if ok and r then return r end
        end
        local regName = dumperState.registry[x]
        return regName or \\"Instance\\"
    end
    local mt = getMetatableFunction(x)
    if mt and mt.__tostring then
        local ok, r = pcallFunction(mt.__tostring, x)
        if ok and r then return r end
    end
    return toStringFunction(x)
end
_G.tostring = tostring
dumperState.last_http_url = nil
loadstring = function(code, chunkName)
    if typeFunction(code) ~= \\"string\\" then return function() return createProxyObject(\\"loaded\\", false) end end
    local url = dumperState.last_http_url or code
    dumperState.last_http_url = nil
    local libName = nil
    local lowerCode = url:lower()
    local libs = {{pattern = \\"rayfield\\", name = \\"Rayfield\\"}, {pattern = \\"orion\\", name = \\"OrionLib\\"}, {pattern = \\"kavo\\", name = \\"Kavo\\"}, {pattern = \\"venyx\\", name = \\"Venyx\\"}, {pattern = \\"sirius\\", name = \\"Sirius\\"}, {pattern = \\"linoria\\", name = \\"Linoria\\"}, {pattern = \\"wally\\", name = \\"Wally\\"}, {pattern = \\"dex\\", name = \\"Dex\\"}, {pattern = \\"infinite\\", name = \\"InfiniteYield\\"}, {pattern = \\"hydroxide\\", name = \\"Hydroxide\\"}, {pattern = \\"simplespy\\", name = \\"SimpleSpy\\"}, {pattern = \\"remotespy\\", name = \\"RemoteSpy\\"}}
    for _, lib in ipairsFunction(libs) do if lowerCode:find(lib.pattern) then libName = lib.name; break end end
    if libName then
        local proxy = createProxyObject(libName, false)
        dumperState.registry[proxy] = libName
        dumperState.names_used[libName] = true
        if url:match(\\"^https?://\\") then emitOutput(string.format('local %s = loadstring(game:HttpGet(\\"%s\\"))()', libName, url)) end
        return function() return proxy end
    end
    if url:match(\\"^https?://\\") then
        local proxy = createProxyObject(\\"Library\\", false)
        emitOutput(string.format('local loadstring = loadstring(game:HttpGet(\\"%s\\"))()', url))
        return function() return proxy end
    end
    if code:match(\\"local%s+a%s*=%s*if%s+true%s+then\\") then return nil, \\"attempt to call a nil value\\" end
    if typeFunction(code) == \\"string\\" then code = processString(code) end
    local func, err = loadFunction(code)
    if func then return func end
    local proxy = createProxyObject(\\"LoadedChunk\\", false)
    return function() return proxy end
end
load = loadstring
_G.loadstring = loadstring
_G.load = loadstring
require = function(module)
    local modName = dumperState.registry[module] or serializeValue(module)
    local proxy = createProxyObject(\\"RequiredModule\\", false)
    local varName = registerVariable(proxy, \\"module\\")
    emitOutput(string.format(\\"local %s = require(%s)\\", varName, modName))
    return proxy
end
_G.require = require
print = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"print(%s)\\", table.concat(items, \\", \\")))
end
_G.print = print
warn = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"warn(%s)\\", table.concat(items, \\", \\")))
end
_G.warn = warn
-- Tag Roblox-like builtins as C closures so iscclosure() returns true for them
do
    if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
    local _cbuiltins = {
        print, warn, tick, time, elapsedTime, pcall, xpcall, error, assert,
        tostring, tonumber, type, typeof, rawget, rawset, rawequal, rawlen,
        setmetatable, getmetatable, ipairs, pairs, next, select, unpack,
        require, loadstring, load,
    }
    for _, fn in ipairs(_cbuiltins) do
        if typeFunction(fn) == \\"function\\" then
            _at.cclosureSet[fn] = true
        end
    end
end
_G.shared = shared
local globalBase = _G
local globalMeta = setmetatable({}, {
    __index = function(tbl, key)
        if configuration.VERBOSE then printFunction(\\"[VERBOSE] Accessing field: \\" .. toStringFunction(key)) end
        local val = rawget(globalBase, key)
        if val == nil then val = rawget(_G, key) end
        if configuration.VERBOSE then
            if val ~= nil then
                if typeFunction(val) == \\"table\\" then printFunction(\\"[VERBOSE] Found global table: \\" .. toStringFunction(key))
                elseif typeFunction(val) == \\"function\\" then printFunction(\\"[VERBOSE] Found global function: \\" .. toStringFunction(key))
                else printFunction(\\"[VERBOSE] Found global value: \\" .. toStringFunction(key) .. \\" = \\" .. toStringFunction(val)) end
            else
                printFunction(\\"[VERBOSE] Missing field, providing dummy function: \\" .. toStringFunction(key))
                val = function() if configuration.VERBOSE then printFunction(\\"[Missing Function] Called: \\" .. toStringFunction(key) .. \\" with 0 arguments\\") end return nil end
            end
        end
        return val
    end,
    __newindex = function(tbl, key, val) rawset(globalBase, key, val) end
})
_G._G = globalMeta
function proxyTable.reset()
    dumperState = {output = {}, indent = 0, registry = {}, reverse_registry = {}, names_used = {}, parent_map = {}, property_store = {}, call_graph = {}, variable_types = {}, string_refs = {}, proxy_id = 0, callback_depth = 0, pending_iterator = false, last_http_url = nil, last_emitted_line = nil, repetition_count = 0, current_size = 0, limit_reached = false, ls_counter = 0, captured_constants = {}}
    _at.mem = {}
    _at.tags = {}
    _at.sigs = {}
    _at.acts = {}
    _at.json = {}
    _at.enum = {}
    _at.svcCache = {}
    _at.typeOverride = {}
    _at.connState = {}
    _at.pendingHeartbeat = {}
    _at.locEntries = {}
    _at.userdata = {}
    _at.localPlayer = nil
    setmetatable(_at.userdata, {__mode = \\"k\\"})
    _at.debugIds = {}
    setmetatable(_at.debugIds, {__mode = \\"k\\"})
    _at.debugIdCtr = 0
    uiCounters = {}
    game = createProxyObject(\\"game\\", true)
    workspace = createProxyObject(\\"workspace\\", true)
    script = createProxyObject(\\"script\\", true)
    Enum = createProxyObject(\\"Enum\\", true)
    shared = createProxyObject(\\"shared\\", true)
    dumperState.property_store[game] = {PlaceId = numericArg, GameId = numericArg, placeId = numericArg, gameId = numericArg}
    dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
    _G.game = game; _G.Game = game; _G.workspace = workspace; _G.Workspace = workspace; _G.script = script; _G.Enum = Enum; _G.shared = shared
    local meta = debugLibrary.getmetatable(Enum)
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
        local enumName = \\"Enum.\\" .. formatValue(key)
        if not _at.enum[enumName] then
            local enumProxy = createProxyObject(enumName, false)
            dumperState.registry[enumProxy] = enumName
            _at.enum[enumName] = enumProxy
        end
        return _at.enum[enumName]
    end
    seedCoreRobloxInstances()
    if type(_G._bypassOnReset) == \\"function\\" then
        local prevOutput = dumperState.output
        local prevOutputCount = #prevOutput
        local prevIndent = dumperState.indent
        local prevLast = dumperState.last_emitted_line
        local prevRep = dumperState.repetition_count
        local prevSize = dumperState.current_size
        local prevLimit = dumperState.limit_reached
        pcall(_G._bypassOnReset)
        for i = #prevOutput, prevOutputCount + 1, -1 do
            prevOutput[i] = nil
        end
        dumperState.output = prevOutput
        dumperState.indent = prevIndent
        dumperState.last_emitted_line = prevLast
        dumperState.repetition_count = prevRep
        dumperState.current_size = prevSize
        dumperState.limit_reached = prevLimit
    end
end
function proxyTable.get_output() return getFullOutput() end
function proxyTable.save(file) return saveToFile(file) end
function proxyTable.get_call_graph() return dumperState.call_graph end
function proxyTable.get_string_refs() return dumperState.string_refs end
function proxyTable.get_stats() return {total_lines = #dumperState.output, remote_calls = #dumperState.call_graph, suspicious_strings = #dumperState.string_refs, proxies_created = dumperState.proxy_id} end
local dumper = {callId = \\"LUASPLOIT_\\", binaryOperatorNames = {[\\"and\\"] = \\"AND\\", [\\"or\\"] = \\"OR\\", [\\">\\"] = \\"GT\\", [\\"<\\"] = \\"LT\\", [\\">=\\"] = \\"GE\\", [\\"<=\\"] = \\"LE\\", [\\"==\\"] = \\"EQ\\", [\\"~=\\"] = \\"NEQ\\", [\\"..\\"] = \\"CAT\\"}}
function dumper:hook(code) return self.callId .. code end
function dumper:process_expr(expr)
    if not expr then return \\"nil\\" end
    if typeFunction(expr) == \\"string\\" then return expr end
    local tag = expr.tag or expr.kind
    if tag == \\"number\\" or tag == \\"string\\" then
        local val = tag == \\"string\\" and string.format(\\"%q\\", expr.text) or (expr.value or expr.text)
        if configuration.CONSTANT_COLLECTION then return string.format(\\"%sGET(%s)\\", self.callId, val) end
        return val
    end
    if tag == \\"local\\" or tag == \\"global\\" then return (expr.name or expr.token).text
    elseif tag == \\"boolean\\" or tag == \\"bool\\" then return toStringFunction(expr.value)
    elseif tag == \\"binary\\" then
        local lhs = self:process_expr(expr.lhsoperand)
        local rhs = self:process_expr(expr.rhsoperand)
        local op = expr.operator.text
        local opName = self.binaryOperatorNames[op]
        if opName then return string.format(\\"%s%s(%s, %s)\\", self.callId, opName, lhs, rhs) end
        return string.format(\\"(%s %s %s)\\", lhs, op, rhs)
    elseif tag == \\"call\\" then
        local func = self:process_expr(expr.func)
        local args = {}
        for i, node in ipairsFunction(expr.arguments) do args[i] = self:process_expr(node.node or node) end
        return string.format(\\"%sCALL(%s, %s)\\", self.callId, func, table.concat(args, \\", \\"))
    elseif tag == \\"indexname\\" or tag == \\"index\\" then
        local exprStr = self:process_expr(expr.expression)
        local keyStr = tag == \\"indexname\\" and string.format(\\"%q\\", expr.index.text) or self:process_expr(expr.index)
        return string.format(\\"%sCHECKINDEX(%s, %s)\\", self.callId, exprStr, keyStr)
    end
    return \\"nil\\"
end
function dumper:process_statement(stmt)
    if not stmt then return \\"\\" end
    local tag = stmt.tag
    if tag == \\"local\\" or tag == \\"assign\\" then
        local vars, vals = {}, {}
        for _, node in ipairsFunction(stmt.variables or {}) do table.insert(vars, self:process_expr(node.node or node)) end
        for _, node in ipairsFunction(stmt.values or {}) do table.insert(vals, self:process_expr(node.node or node)) end
        return (tag == \\"local\\" and \\"local \\" or \\"\\") .. table.concat(vars, \\", \\") .. \\" = \\" .. table.concat(vals, \\", \\")
    elseif tag == \\"block\\" then
        local stmts = {}
        for _, s in ipairsFunction(stmt.statements or {}) do table.insert(stmts, self:process_statement(s)) end
        return table.concat(stmts, \\"; \\")
    end
    return self:process_expr(stmt) or \\"\\"
end
local function _loosePasteCode(code)
    if typeFunction(code) ~= \\"string\\" then return code end
    code = code:gsub(\\"```lua\\", \\"\\"):gsub(\\"```\\", \\"\\")
    return code
end
local function _loadLooseChunk(code, chunkName)
    local sanitized = processString(_loosePasteCode(code))
    local lines = {}
    sanitized:gsub(\\"([^\n]*)\n?\\", function(line)
        if line ~= \\"\\" or #lines == 0 or sanitized:sub(-1) == \\"\n\\" then table.insert(lines, line) end
    end)
    local skipped = {}
    for _ = 1, 400 do
        local current = table.concat(lines, \\"\n\\")
        local func, err = loadFunction(current, chunkName)
        if func then return func, nil, current, skipped end
        local lineNo = toNumberFunction(toStringFunction(err):match(\\"%]:(%d+):\\") or toStringFunction(err):match(\\":(%d+):\\"))
        if not lineNo or not lines[lineNo] or skipped[lineNo] then return nil, err, current, skipped end
        skipped[lineNo] = lines[lineNo]
        lines[lineNo] = \\"-- \\" .. lines[lineNo]
    end
    return nil, \\"too many invalid loose-paste lines\\", table.concat(lines, \\"\n\\"), skipped
end
function proxyTable.dump_file(inputPath, outputPath)
    proxyTable.reset()
    local file = ioLibrary.open(inputPath, \\"rb\\")
    if not file then
    printFunction(\\"error: cannot open input\\")
        return false
    end
    local code = file:read(\\"*a\\")
    file:close()
    printFunction(\\"input: normalize\\")
    local func, err, sanitized, skipped = _loadLooseChunk(code, \\"Obfuscated_Script\\")
    if not func then
        printFunction(\\"error: load \\" .. toStringFunction(err))
        return false
    end
    if skipped then
        local skippedCount = 0
        for _ in pairsFunction(skipped) do skippedCount = skippedCount + 1 end
        if skippedCount > 0 then printFunction(\\"input: skipped-lines=\\" .. toStringFunction(skippedCount)) end
    end
    local _SANDBOX_BLOCK = {
        io=true, os=true, debug=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true,
    }
    local _rawTb = debugLibrary and debugLibrary.traceback
    local _badTbWords = {
        \\"sandbox\\",\\"hook\\",\\"intercept\\",\\"mock\\",\\"proxy\\",\\"virtual_env\\",
        \\"decompil\\",\\"emulat\\",\\"simulat\\",\\"fake_\\",\\"getupval\\",\\"hookfunc\\",
        \\"replaceclos\\",\\"newcclos\\",\\"restorefunction\\",\\"bypass\\",\\"dumper\\",
    }
    local _tbWrapper = function(thread, msg, level)
        local ok, tb
        if _rawTb then
            if typeFunction(thread) == \\"thread\\" then
                ok, tb = pcallFunction(_rawTb, thread, msg, level)
            else
                ok, tb = pcallFunction(_rawTb, thread, msg)
            end
        end
        if not ok or typeFunction(tb) ~= \\"string\\" then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        local lines = {}
        for line in (tb .. \\"\n\\"):gmatch(\\"([^\n]*)\n\\") do
            local lo = line:lower()
            local bad = false
            for _, w in next, _badTbWords do
                if lo:find(w, 1, true) then bad = true; break end
            end
            if not bad then lines[#lines + 1] = line end
        end
        local cleaned = table.concat(lines, \\"\n\\")
        cleaned = cleaned:gsub(\\"%[([%w%+%/]+)%]\\", function(inner)
            if #inner + 2 < 10 then return \\"[RobloxGameScript]\\" end
            return \\"[\\" .. inner .. \\"]\\"
        end)
        if #cleaned < 20 then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        return cleaned
    end
    local _SAFE_DEBUG = {
        getinfo = function(func, ...)
            if typeFunction(func) == \\"number\\" then
                return nil
            end
            return {source = \\"=[C]\\", what = \\"C\\", name = \\"C function\\", short_src = \\"[C]\\"}
        end,
        traceback  = _tbWrapper,
        getupvalue = function(fn, i) return nil end,
    }
    local _SAFE_OS = {
        clock = function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end,
        time  = osLibrary.time,
        date  = osLibrary.date,
    }
    local env = setmetatable({
        _VERSION = \\"Luau\\",
        LuraphContinue = nil,
        __LC__ = function() end,
        script = script, game = game, workspace = workspace,
        io      = nil,
        os      = _SAFE_OS,
        debug   = _SAFE_DEBUG,
        error   = _origError,
        dofile  = nil,
        loadfile = nil,
        require = nil,
        package = nil,
        socket  = nil,
        ffi     = nil,
        collectgarbage = nil,
        newproxy = newproxy,
        -- hide _G metatable from scripts
        getmetatable = function(obj)
            if obj == _G or obj == env then return nil end
            if _at.userdata[obj] then return getMetatableFunction(obj) end
            if isProxy(obj) then return \\"The metatable is locked\\" end
            return getMetatableFunction(obj)
        end,
        LUASPLOIT_CHECKINDEX = function(tbl, key)
            local val = tbl[key]
            if typeFunction(val) == \\"table\\" and not dumperState.registry[val] then
                dumperState.ls_counter = dumperState.ls_counter + 1
                dumperState.registry[val] = \\"v\\" .. dumperState.ls_counter
            end
            return val
        end,
        LUASPLOIT_GET = function(v) return v end,
        LS_CALL = function(f, ...)
            if typeFunction(f) ~= \\"function\\" then return nil end
            return f(...)
        end,
        LS_NAMECALL = function(t, method, ...)
            if typeFunction(t) ~= \\"table\\" then return nil end
            if typeFunction(t[method]) ~= \\"function\\" then return nil end
            return t[method](t, ...)
        end,
        LUASPLOIT_CALL = function(f, ...) return f(...) end,
        LUASPLOIT_NAMECALL = function(t, method, ...) return t[method](t, ...) end,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end
    }, {
        __index = function(_, k)
            if _SANDBOX_BLOCK[k] then return nil end
            -- block dumper internal globals from leaking into script env
            if k == \\"LuraphContinue\\" or k == \\"__FLAMEDUMPER_REQUIRE_ONLY\\"
            or k == \\"proxyTable\\" or k == \\"dumperState\\" or k == \\"_at\\" then
                return nil
            end
            return _G[k]
        end,
        __newindex = _G
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, env)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, env) end
        end
    end
    printFunction(\\"vm: running\\")
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    local success, runErr = xpcallFunction(function() func() end, function(e) return toStringFunction(e) end)
    setHook()
    if not success and not toStringFunction(runErr):match(\\"TIMEOUT\\") then
        emitComment(\\"Runtime: \\" .. toStringFunction(runErr))
    end
    local saved = proxyTable.save(outputPath or configuration.OUTPUT_FILE)
    if saved then
        local stats = proxyTable.get_stats()
        printFunction(string.format(\\"done: lines=%d remotes=%d strings=%d\\",
            stats.total_lines, stats.remote_calls, stats.suspicious_strings))
    else
        printFunction(\\"error: write failed\\")
    end
    return saved
end
function proxyTable.dump_string(code, outputPath)
    proxyTable.reset()
    if code then code = processString(code) end
    local func, err = loadFunction(code)
    if not func then
        emitComment(\\"Load Error: \\" .. (err or \\"unknown\\"))
        if outputPath then proxyTable.save(outputPath) end
        return false, err
    end
    local _DS_BLOCK = {
        io=true, os=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true, debug=true,
    }
    local _DS_OS = { clock=function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end, time=osLibrary.time, date=osLibrary.date }
    local dsEnv = setmetatable({
        _VERSION=\\"Luau\\",
        io=nil, os=_DS_OS, debug=nil, dofile=nil, loadfile=nil,
        require=nil, package=nil, socket=nil, ffi=nil,
        collectgarbage=nil, newproxy=newproxy,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end,
    }, {
        __index = function(_, k)
            if _DS_BLOCK[k] then return nil end
            return _G[k]
        end,
        __newindex = _G,
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, dsEnv)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, dsEnv) end
        end
    end
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    xpcallFunction(function() func() end, function(e)
        emitComment(\\"Runtime: \\" .. toStringFunction(e))
    end)
    setHook()
    if outputPath then return proxyTable.save(outputPath) end
    return true, getFullOutput()
end
do
    local bypassPath = (arg and arg[0] and arg[0]:match(\\"^(.+[\\\\/])\\")) or \\"\\"
    local ok, err = pcall(dofile, bypassPath .. \\"bypass.lua\\")
    if not ok then
        local ok2 = pcall(dofile, \\"bypass.lua\\")
        if not ok2 then
            printFunction(\\"[dumper] bypass.lua not found, continuing without supplement\\")
        end
    end
end

_G.LuraphContinue = nil
if not rawget(_G, \\"__FLAMEDUMPER_REQUIRE_ONLY\\") then
    if arg and arg[1] then
        local success = proxyTable.dump_file(arg[1], arg[2])
        if success then end
    else
        local file = ioLibrary.open(\\"obfuscated.lua\\", \\"rb\\")
        if file then
            file:close()
            local success = proxyTable.dump_file(\\"obfuscated.lua\\")
            if success then
                printFunction(proxyTable.get_output())
            end
        else
            printFunction(\\"Usage: lua dumper.lua <input> [output] [key]\\")
        end
    end
end
return proxyTable
, line 4090")
print("[STEP 5] Enumerating stack frames for sources...")
print("  Stack 1: local unpack = unpack or table.unpack
local warn = warn or function() end

local _origPcall = pcall
local _origXpcall = xpcall
local _origError = error

local debugLibrary = debug
_G._VERSION = \\"Luau\\"
local setHook = debug.sethook
local getInfo = debug.getinfo
local getTraceback = debug.traceback
local loadFunction = load
local loadStringFunction = loadstring or load
local pcallFunction = pcall
local xpcallFunction = xpcall
local errorFunction = error
local typeFunction = type
local getMetatableFunction = getmetatable
local rawEqualFunction = rawequal
local toStringFunction = tostring
local toNumberFunction = tonumber
local ioLibrary = io
local osLibrary = os
local pairsFunction = pairs
local ipairsFunction = ipairs
local tableUnpackFunction = table.unpack or unpack
local proxyTable = {}
proxyTable.__index = proxyTable
local configuration = {
    MAX_DEPTH = 15,
    MAX_TABLE_ITEMS = 150,
    OUTPUT_FILE = \\"dumped_output.lua\\",
    VERBOSE = false,
    TRACE_CALLBACKS = true,
    TIMEOUT_SECONDS = 6.67,
    MAX_REPEATED_LINES = 8,
    MIN_DEOBF_LENGTH = 150,
    MAX_OUTPUT_SIZE = 2 * 1024 * 1024,
    CONSTANT_COLLECTION = true,
    INSTRUMENT_LOGIC = true
}
local inputKey = (arg and arg[3]) or \\"NoKey\\"
if arg and arg[3] then
    print(\\"[Dumper] Auto-Input Key Detected: \\" .. toStringFunction(inputKey))
end
local dumperState = {
    output = {},
    indent = 0,
    registry = {},
    reverse_registry = {},
    names_used = {},
    parent_map = {},
    property_store = {},
    call_graph = {},
    variable_types = {},
    string_refs = {},
    proxy_id = 0,
    callback_depth = 0,
    pending_iterator = false,
    last_http_url = nil,
    last_emitted_line = nil,
    repetition_count = 0,
    current_size = 0,
    ls_counter = 0
}
local _at = {
    mem          = {},
    tags         = {},
    sigs         = {},
    acts         = {},
    json         = {},
    enum         = {},
    svcCache     = {},
    typeOverride = {},
    connState    = {},
    debugIds     = {},
    debugIdCtr   = 0,
    instTags     = {},
    attrs        = {},
    children     = {},
    threadLike   = {},
    vectors      = {},
    buffers      = {},
    userdata     = {},
    localPlayer  = nil,
    weldRegistry = {},
    services     = {},
    folders      = {},
    files        = {},
    refBase      = {},
    metaHooks    = {},
    currentNamecallMethod = nil,
    inMetaHook   = false,
    pendingHeartbeat = {},
    locEntries = {},
    signalCallbacks = {},  -- AT5: live signal firing
    animateScript = nil,   -- AT3: getrunningscripts
}
setmetatable(_at.debugIds, {__mode = \\"k\\"})
setmetatable(_at.instTags, {__mode = \\"k\\"})
setmetatable(_at.attrs, {__mode = \\"k\\"})
setmetatable(_at.children, {__mode = \\"k\\"})
setmetatable(_at.threadLike, {__mode = \\"k\\"})
setmetatable(_at.vectors, {__mode = \\"k\\"})
setmetatable(_at.buffers, {__mode = \\"k\\"})
setmetatable(_at.userdata, {__mode = \\"k\\"})
setmetatable(_at.refBase, {__mode = \\"k\\"})
local function _getDebugId(p)
    if not _at.debugIds[p] then
        _at.debugIdCtr = _at.debugIdCtr + 1
        local n = _at.debugIdCtr
        _at.debugIds[p] = toStringFunction(n * 17 + 3) .. \\"-\\" .. toStringFunction(n * 97 + 11)
    end
    return _at.debugIds[p]
end
local function _removeChild(parent, child)
    local list = parent and _at.children[parent]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == child then table.remove(list, i) end
    end
end
local function _setParent(child, parent)
    local oldParent = dumperState.parent_map[child]
    if oldParent == parent then return end
    _removeChild(oldParent, child)
    dumperState.parent_map[child] = parent
    if parent then
        _at.children[parent] = _at.children[parent] or {}
        table.insert(_at.children[parent], child)
        -- skip signal firing for internal proxy types
        local childType = _at.typeOverride[child]
        local parentType = _at.typeOverride[parent]
        if childType == \\"RBXScriptSignal\\" or childType == \\"RBXScriptConnection\\"
        or parentType == \\"RBXScriptSignal\\" or parentType == \\"RBXScriptConnection\\" then
            return
        end
        -- fire ChildAdded on direct parent only
        if _at.signalCallbacks[parent] then
            for _, cb in ipairsFunction(_at.signalCallbacks[parent].ChildAdded or {}) do
                pcallFunction(cb, child)
            end
        end
        -- fire DescendantAdded on direct parent and its ancestors
        local ancestor = parent
        while ancestor do
            if _at.signalCallbacks[ancestor] then
                for _, cb in ipairsFunction(_at.signalCallbacks[ancestor].DescendantAdded or {}) do
                    pcallFunction(cb, child)
                end
            end
            ancestor = dumperState.parent_map[ancestor]
        end
    end
end
local function _isDescendantOf(child, parent)
    local cur = dumperState.parent_map[child]
    while cur do
        if cur == parent then return true end
        cur = dumperState.parent_map[cur]
    end
    return false
end
local function _getAllDescendants(root, out)
    out = out or {}
    for _, child in ipairsFunction(_at.children[root] or {}) do
        table.insert(out, child)
        _getAllDescendants(child, out)
    end
    return out
end
local numericArg = (arg and toNumberFunction(arg[4])) or (arg and toNumberFunction(arg[3])) or 123456789
local proxyMarker = {}
local function isProxyTable(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyMarker) == true end )
    return success and result
end
local function getProxyValue(target)
    if isProxyTable(target) then
        return rawget(target, \\"__value\\") or 0
    end
    return 0
end
local loadStringFunction = loadstring or load
local printFunction = print
local warnFunction = warn or function() end
local pairsFunction = pairs
local ipairsFunction = ipairs
local typeFunction = type
local toStringFunction = tostring
local proxyList = {}
local function isProxy(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyList) == true end )
    return success and result
end
local function getProxyId(target)
    if not isProxy(target) then
        return nil
    end
    return rawget(target, \\"__proxy_id\\")
end
local function processString(inputString)
    if typeFunction(inputString) ~= \\"string\\" then
        return '\\"'
    end
    local outputParts = {}
    local currentIndex, totalLength = 1, #inputString
    local function cleanEscapes(content)
        return content:gsub( \\"\\\\\\\\(.)\\", function(escapedChar)
            if escapedChar:match('[abfnrtv\\\\\\\\%\'%\\\\\\"%[%]0-9xu]') then
                return \\"\\" .. escapedChar
            end
            return escapedChar
        end )
    end
    local function stripLuauSyntax(rawCode)
        if not rawCode or rawCode == \\"\\" then
            return rawCode
        end
        rawCode = rawCode:gsub(\\"\239\187\191\\", \\"\\")
        rawCode = rawCode:gsub(\\"\\r\n\\", \\"\n\\"):gsub(\\"\\r\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"\226\128\168\\", \\"\n\\"):gsub(\\"\226\128\169\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"%-%-!%a+[^\n]*\\", \\"\\")
        rawCode = rawCode:gsub(\\"([^\n]*)\\", function(line)
            if line:match(\\"^%s*export%s+type%s+\\") or line:match(\\"^%s*type%s+[%a_][%w_]*%s*=\\") then
                return \\"-- \\" .. line
            end
            return line
        end)
        rawCode = rawCode:gsub(\\"local%s+([%a_][%w_]*)%s*<[%a_][%w_]*>%s*=\\", \\"local %1 =\\")
        rawCode = rawCode:gsub(\\"(function%s+[%a_][%w_%.:]*)%s*<[^>\n%(]+>%s*%(\\", \\"%1(\\")
        rawCode = rawCode:gsub(\\"([%(%s,])%.%.%.%s*:%s*[%a_][%w_%.]*%??\\", \\"%1...\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"%1%2\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\"%1%2%3\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\")\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\")%1\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%??\\", \\"\\")
        return rawCode
    end
    local function parseExpression(rawCode)
        if not rawCode or rawCode == '\\"' then
            return \\"\\"
        end
        rawCode = stripLuauSyntax(rawCode)
        rawCode = rawCode:gsub( \\"0[bB]([01_]+)\\", function(binaryString)
            local cleanBinary = binaryString:gsub(\\"_\\", \\"\\")
            local decimalValue = toNumberFunction(cleanBinary, 2)
            return decimalValue and toStringFunction(decimalValue) or \\"0\\"
        end )
        rawCode = rawCode:gsub( \\"0[xX]([%x_]+)\\", function(hexString)
            local cleanHex = hexString:gsub(\\"_\\", \\"\\")
            return \\"0x\\" .. cleanHex
        end )
        while rawCode:match(\\"%d_+%d\\") do
            rawCode = rawCode:gsub(\\"(%d)_+(%d)\\", \\"%1%2\\")
        end
        local operators = {{\\"+=\\", \\"+\\"}, {\\"-=\\", \\"-\\"}, {\\"*=\\", \\"*\\"}, {\\"/=\\", \\"/\\"}, {\\"%%=\\", \\"%%\\"}, {\\"%^=\\", \\"^\\"}, {\\"%.%.=\\", \\"..\\"}}
        for _, opPair in ipairsFunction(operators) do
            local operatorAssignment, operator = opPair[1], opPair[2]
            -- simple var: x+=1 -> x = x + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- dot chain: x.y.z+=1 -> x.y.z = x.y.z + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*%.[%a_][%w_%.]+)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- bracket chain: R[m]+=q, T[1][2]+=q, obj[\\"k\\"][i]+=q
            -- manually find identifier + full bracket chain before the operator
            local escOp = operatorAssignment:gsub(\\"([%.%+%-%*%/%^%%])\\", \\"%%%1\\")
            rawCode = rawCode:gsub(\\"([%a_][%w_]*)(%b[])\\", function(name, firstBracket)
                -- check if after firstBracket there are more brackets then the operator
                return name .. firstBracket
            end)
            -- proper scan: replace lval+= where lval is ident + bracket chain
            do
                local result = {}
                local i = 1
                local len = #rawCode
                while i <= len do
                    -- look for identifier start
                    local idStart, idEnd = rawCode:find(\\"[%a_][%w_]*\\", i)
                    if not idStart then
                        result[#result+1] = rawCode:sub(i)
                        break
                    end
                    result[#result+1] = rawCode:sub(i, idStart-1)
                    local varName = rawCode:match(\\"[%a_][%w_]*\\", idStart)
                    local pos = idStart + #varName
                    -- consume bracket chains
                    while pos <= len and rawCode:sub(pos,pos) == \\"[\\" do
                        local _, bEnd = rawCode:find(\\"%b[]\\", pos)
                        if not bEnd then break end
                        varName = varName .. rawCode:sub(pos, bEnd)
                        pos = bEnd + 1
                    end
                    -- check for operator after optional whitespace
                    local wsEnd = pos
                    while wsEnd <= len and rawCode:sub(wsEnd,wsEnd):match(\\"%s\\") do wsEnd=wsEnd+1 end
                    local opMatch = rawCode:sub(wsEnd, wsEnd + #operatorAssignment - 1)
                    if opMatch == operatorAssignment and varName:find(\\"%[\\") then
                        -- rewrite: varName op= ... -> varName = varName op ...
                        result[#result+1] = varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
                        i = wsEnd + #operatorAssignment
                    else
                        result[#result+1] = varName
                        i = pos
                    end
                end
                rawCode = table.concat(result)
            end
        end
        rawCode = rawCode:gsub(\\"([^%w_])continue([^%w_])\\", \\"%1__LC__()%2\\")
        rawCode = rawCode:gsub(\\"^continue([^%w_])\\", \\"__LC__()%1\\")
        rawCode = rawCode:gsub(\\"([^%w_])continue$\\", \\"%1__LC__()\\")
        return rawCode
    end
    local function getBracketCount(index)
        local count = 0
        while index <= totalLength and inputString:byte(index) == 61 do
            count = count + 1
            index = index + 1
        end
        return count, index
    end
    local function findClosingBracket(startIndex, bracketCount)
        local closingPattern = \\"]\\" .. string.rep(\\"=\\", bracketCount) .. \\"]\\"
        local start, finish = inputString:find(closingPattern, startIndex, true)
        return finish or totalLength
    end
    local segmentStart = 1
    while currentIndex <= totalLength do
        local byteValue = inputString:byte(currentIndex)
        if byteValue == 91 then
            local bracketCount, nextIndex = getBracketCount(currentIndex + 1)
            if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
                local startSegment = currentIndex
                local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                table.insert(outputParts, inputString:sub(startSegment, endSegment))
                currentIndex = endSegment
                segmentStart = currentIndex + 1
            end
        elseif byteValue == 45 and currentIndex + 1 <= totalLength and inputString:byte(currentIndex + 1) == 45 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local startSegment = currentIndex
            if currentIndex + 2 <= totalLength and inputString:byte(currentIndex + 2) == 91 then
                local bracketCount, nextIndex = getBracketCount(currentIndex + 3)
                if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                    local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                    table.insert(outputParts, inputString:sub(startSegment, endSegment))
                    currentIndex = endSegment
                    segmentStart = currentIndex + 1
                    currentIndex = currentIndex + 1
                end
            end
            local lineBreak = inputString:find(\\"\n\\", currentIndex + 2, true)
            if lineBreak then
                currentIndex = lineBreak
            else
                currentIndex = totalLength
            end
            table.insert(outputParts, inputString:sub(startSegment, currentIndex))
            segmentStart = currentIndex + 1
        elseif byteValue == 34 or byteValue == 39 or byteValue == 96 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local quoteType = byteValue
            local startSegment = currentIndex
            currentIndex = currentIndex + 1
            while currentIndex <= totalLength do
                local charByte = inputString:byte(currentIndex)
                if charByte == 92 then
                    currentIndex = currentIndex + 1
                elseif charByte == quoteType then
                    break
                end
                currentIndex = currentIndex + 1
            end
            local extractedContent = inputString:sub(startSegment + 1, currentIndex - 1)
            extractedContent = cleanEscapes(extractedContent)
            if quoteType == 96 then
                table.insert(outputParts, '\\"' .. extractedContent:gsub('\\"', '\\\\\\\\\\"') .. '\\"')
            else
                local quoteChar = string.char(quoteType)
                table.insert(outputParts, quoteChar .. extractedContent .. quoteChar)
            end
            segmentStart = currentIndex + 1
        end
        currentIndex = currentIndex + 1
    end
    table.insert(outputParts, parseExpression(inputString:sub(segmentStart)))
    return table.concat(outputParts)
end
local function safeLoad(code, chunkName)
    local loadedFunc, errorMessage = loadStringFunction(code, chunkName)
    if loadedFunc then
        return loadedFunc
    end
    printFunction(\\"\n[CRITICAL ERROR] Failed to load script!\\")
    printFunction(\\"[LUA_LOAD_FAIL] \\" .. toStringFunction(errorMessage))
    local errorLine = toNumberFunction(errorMessage:match(\\":(%d+):\\"))
    local errorNear = errorMessage:match(\\"near '([^']+)'\\")
    if errorNear then
        local foundIndex = code:find(errorNear, 1, true)
        if foundIndex then
            local startCtx = math.max(1, foundIndex - 50)
            local endCtx = math.min(#code, foundIndex + 50)
            printFunction(\\"Context around error:\\")
            printFunction(\\"...\\" .. code:sub(startCtx, endCtx) .. \\"...\\")
        end
    end
    local debugFile = ioLibrary.open(\\"DEBUG_FAILED_TRANSPILE.lua\\", \\"w\\")
    if debugFile then
        debugFile:write(code)
        debugFile:close()
        printFunction(\\"[*] Saved to 'DEBUG_FAILED_TRANSPILE.lua' for inspection\\")
    end
    return nil, errorMessage
end
local function emitOutput(data, isInline)
    if dumperState.limit_reached then
        return
    end
    if data == nil then
        return
    end
    local indentPrefix = isInline and \\"\\" or string.rep(\\"    \\", dumperState.indent)
    local lineString = indentPrefix .. toStringFunction(data)
    local lineSize = #lineString + 1
    if dumperState.current_size + lineSize > configuration.MAX_OUTPUT_SIZE then
        dumperState.limit_reached = true
        local warningMessage = \\"-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.\\"
        table.insert(dumperState.output, warningMessage)
        dumperState.current_size = dumperState.current_size + #warningMessage
        errorFunction(\\"DUMP_LIMIT_EXCEEDED\\")
    end
    if lineString == dumperState.last_emitted_line then
        dumperState.repetition_count = dumperState.repetition_count + 1
        if dumperState.repetition_count <= configuration.MAX_REPEATED_LINES then
            table.insert(dumperState.output, lineString)
            dumperState.current_size = dumperState.current_size + lineSize
        elseif dumperState.repetition_count == configuration.MAX_REPEATED_LINES + 1 then
            local suppressMessage = indentPrefix .. \\"-- [Repeated lines suppressed...]\\"
            table.insert(dumperState.output, suppressMessage)
            dumperState.current_size = dumperState.current_size + #suppressMessage
        end
    else
        dumperState.last_emitted_line = lineString
        dumperState.repetition_count = 0
        table.insert(dumperState.output, lineString)
        dumperState.current_size = dumperState.current_size + lineSize
    end
    if configuration.VERBOSE and dumperState.repetition_count <= 1 then
        printFunction(lineString)
    end
end
local function emitComment(data)
    emitOutput(\\"-- \\" .. toStringFunction(data or \\"\\"))
end
local function addEmptyLine()
    dumperState.last_emitted_line = nil
    table.insert(dumperState.output, \\"\\")
end
local function getFullOutput()
    return table.concat(dumperState.output, \\"\n\\")
end
local function saveToFile(filePath)
    local fileHandle = ioLibrary.open(filePath or configuration.OUTPUT_FILE, \\"w\\")
    if fileHandle then
        fileHandle:write(getFullOutput())
        fileHandle:close()
        return true
    end
    return false
end
local function formatValue(value)
    if value == nil then
        return \\"nil\\"
    end
    if typeFunction(value) == \\"string\\" then
        return value
    end
    if typeFunction(value) == \\"number\\" or typeFunction(value) == \\"boolean\\" then
        return toStringFunction(value)
    end
    if typeFunction(value) == \\"table\\" then
        if dumperState.registry[value] then
            return dumperState.registry[value]
        end
        if isProxy(value) then
            local proxyId = getProxyId(value)
            return proxyId and \\"proxy_\\" .. proxyId or \\"proxy\\"
        end
    end
    local success, result = pcallFunction(toStringFunction, value)
    return success and result or \\"unknown\\"
end
local function formatStringLiteral(value)
    local rawValue = formatValue(value)
    local escapedValue = rawValue:gsub(\\"\\\\\\\\\\", \\"\\\\\\\\\\\\\\\\\\"):gsub('\\"', '\\\\\\\\\\"'):gsub(\\"\n\\", \\"\n\\"):gsub(\\"\\\\\r\\", \\"\\\\\\\\\r\\"):gsub(\\"\\\\\t\\", \\"\\\\\\\\\t\\")
    return '\\"' .. escapedValue .. '\\"'
end
local serviceNames = {
    Players = \\"Players\\",
    Workspace = \\"Workspace\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    ServerStorage = \\"ServerStorage\\",
    ServerScriptService = \\"ServerScriptService\\",
    StarterGui = \\"StarterGui\\",
    StarterPack = \\"StarterPack\\",
    StarterPlayer = \\"StarterPlayer\\",
    Lighting = \\"Lighting\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    RunService = \\"RunService\\",
    UserInputService = \\"UserInputService\\",
    TweenService = \\"TweenService\\",
    GroupService = \\"GroupService\\",
    AnimationClipProvider = \\"AnimationClipProvider\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    TeleportService = \\"TeleportService\\",
    PathfindingService = \\"PathfindingService\\",
    CollectionService = \\"CollectionService\\",
    PhysicsService = \\"PhysicsService\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    GuiService = \\"GuiService\\",
    HapticService = \\"HapticService\\",
    VRService = \\"VRService\\",
    CoreGui = \\"CoreGui\\",
    Teams = \\"Teams\\",
    InsertService = \\"InsertService\\",
    DataStoreService = \\"DataStoreService\\",
    MessagingService = \\"MessagingService\\",
    TextService = \\"TextService\\",
    TextChatService = \\"TextChatService\\",
    NetworkClient = \\"NetworkClient\\",
    ContentProvider = \\"ContentProvider\\",
    Debris = \\"Debris\\",
    MemStorageService = \\"MemStorageService\\",
    ChangeHistoryService = \\"ChangeHistoryService\\",
    PlayerEmulatorService = \\"PlayerEmulatorService\\",
    StylingService = \\"StylingService\\",
    ScriptContext = \\"ScriptContext\\",
    LocalizationService = \\"LocalizationService\\",
    PolicyService = \\"PolicyService\\",
    CaptureService = \\"CaptureService\\",
    AnalyticsService = \\"AnalyticsService\\",
    EncodingService = \\"EncodingService\\",
    CorePackages = \\"CorePackages\\",
    RobloxReplicatedStorage = \\"RobloxReplicatedStorage\\",
    RobloxGui = \\"RobloxGui\\",
    AvatarEditorService = \\"AvatarEditorService\\",
    SocialService = \\"SocialService\\",
    VoiceChatService = \\"VoiceChatService\\",
    AdService = \\"AdService\\",
    GeometryService = \\"GeometryService\\",
    AssetService = \\"AssetService\\",
    LocalizationService = \\"LocalizationService\\",
    NotificationService = \\"NotificationService\\",
    ProcessInstancePhysicsService = \\"ProcessInstancePhysicsService\\",
    FriendService = \\"FriendService\\",
    SessionService = \\"SessionService\\",
    TimerService = \\"TimerService\\",
    TouchInputService = \\"TouchInputService\\",
    GamepadService = \\"GamepadService\\",
    KeyboardService = \\"KeyboardService\\",
    MouseService = \\"MouseService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceService = \\"PerformanceService\\",
    PlatformFriendService = \\"PlatformFriendService\\",
    ReplicatedFirst = \\"ReplicatedFirst\\",
    SpawnLocation = \\"SpawnLocation\\",
    LogService = \\"LogService\\",
    Stats = \\"Stats\\",
    TweenService = \\"TweenService\\",
    Debris = \\"Debris\\",
    CoreGui = \\"CoreGui\\",
    MarketplaceService = \\"MarketplaceService\\",
    NotificationService = \\"NotificationService\\",
    GuidRegistryService = \\"GuidRegistryService\\",
    NetworkServer = \\"NetworkServer\\",
    Geometry = \\"Geometry\\",
    VirtualInputManager = \\"VirtualInputManager\\",
    MLModelDeliveryService = \\"MLModelDeliveryService\\",
    PartyEmulatorService = \\"PartyEmulatorService\\",
    PlatformFriendsService = \\"PlatformFriendsService\\",
    FriendService = \\"FriendService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceControlService = \\"PerformanceControlService\\",
    RbxAnalyticsService = \\"RbxAnalyticsService\\",
    AbuseReportService = \\"AbuseReportService\\",
    AdService = \\"AdService\\",
    AdPortalService = \\"AdPortalService\\",
    AppUpdateService = \\"AppUpdateService\\",
    BrowserService = \\"BrowserService\\",
    CookiesService = \\"CookiesService\\",
    CoreGui = \\"CoreGui\\",
    GamesService = \\"GamesService\\",
    KeyboardService = \\"KeyboardService\\",
    MarketplaceService = \\"MarketplaceService\\",
    MouseService = \\"MouseService\\",
    NotificationService = \\"NotificationService\\",
    PurchaseDataService = \\"PurchaseDataService\\",
    TimerService = \\"TimerService\\",
    UGCValidationService = \\"UGCValidationService\\",
}
local serviceShortcuts = {
    Players = \\"Players\\",
    UserInputService = \\"UIS\\",
    RunService = \\"RunService\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    TweenService = \\"TweenService\\",
    Workspace = \\"Workspace\\",
    Lighting = \\"Lighting\\",
    StarterGui = \\"StarterGui\\",
    CoreGui = \\"CoreGui\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    DataStoreService = \\"DataStoreService\\",
    TeleportService = \\"TeleportService\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    Teams = \\"Teams\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    CollectionService = \\"CollectionService\\",
    PathfindingService = \\"PathfindingService\\",
    Debris = \\"Debris\\"
}
local classParents = {
    DataModel = {\\"DataModel\\", \\"ServiceProvider\\", \\"Instance\\"},
    Workspace = {\\"Workspace\\", \\"WorldRoot\\", \\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Camera = {\\"Camera\\", \\"Instance\\"},
    Players = {\\"Players\\", \\"Instance\\"},
    Player = {\\"Player\\", \\"Instance\\"},
    PlayerGui = {\\"PlayerGui\\", \\"BasePlayerGui\\", \\"Instance\\"},
    Backpack = {\\"Backpack\\", \\"Instance\\"},
    PlayerScripts = {\\"PlayerScripts\\", \\"Instance\\"},
    Folder = {\\"Folder\\", \\"Instance\\"},
    Model = {\\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Part = {\\"Part\\", \\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    BasePart = {\\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    ModuleScript = {\\"ModuleScript\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    LocalScript = {\\"LocalScript\\", \\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Script = {\\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Humanoid = {\\"Humanoid\\", \\"Instance\\"},
    SoundService = {\\"SoundService\\", \\"Instance\\"},
    Lighting = {\\"Lighting\\", \\"Instance\\"},
    HttpService = {\\"HttpService\\", \\"Instance\\"},
    TweenService = {\\"TweenService\\", \\"Instance\\"},
    RunService = {\\"RunService\\", \\"Instance\\"},
    TextService = {\\"TextService\\", \\"Instance\\"},
    GuiService = {\\"GuiService\\", \\"Instance\\"},
    ContentProvider = {\\"ContentProvider\\", \\"Instance\\"},
    CollectionService = {\\"CollectionService\\", \\"Instance\\"},
    MemStorageService = {\\"MemStorageService\\", \\"Instance\\"},
    NetworkClient = {\\"NetworkClient\\", \\"Instance\\"},
    ClientReplicator = {\\"ClientReplicator\\", \\"Instance\\"},
}
local function classIsA(className, targetClass)
    if className == targetClass then return true end
    local parents = classParents[className] or {className, \\"Instance\\"}
    for _, parentName in ipairsFunction(parents) do
        if parentName == targetClass then return true end
    end
    return false
end
local uiNamingConvention = {
    {pattern = \\"window\\", prefix = \\"Window\\", counter = \\"window\\"},
    {pattern = \\"tab\\", prefix = \\"Tab\\", counter = \\"tab\\"},
    {pattern = \\"section\\", prefix = \\"Section\\", counter = \\"section\\"},
    {pattern = \\"button\\", prefix = \\"Button\\", counter = \\"button\\"},
    {pattern = \\"toggle\\", prefix = \\"Toggle\\", counter = \\"toggle\\"},
    {pattern = \\"slider\\", prefix = \\"Slider\\", counter = \\"slider\\"},
    {pattern = \\"dropdown\\", prefix = \\"Dropdown\\", counter = \\"dropdown\\"},
    {pattern = \\"textbox\\", prefix = \\"Textbox\\", counter = \\"textbox\\"},
    {pattern = \\"input\\", prefix = \\"Input\\", counter = \\"input\\"},
    {pattern = \\"label\\", prefix = \\"Label\\", counter = \\"label\\"},
    {pattern = \\"keybind\\", prefix = \\"Keybind\\", counter = \\"keybind\\"},
    {pattern = \\"colorpicker\\", prefix = \\"ColorPicker\\", counter = \\"colorpicker\\"},
    {pattern = \\"paragraph\\", prefix = \\"Paragraph\\", counter = \\"paragraph\\"},
    {pattern = \\"notification\\", prefix = \\"Notification\\", counter = \\"notification\\"},
    {pattern = \\"divider\\", prefix = \\"Divider\\", counter = \\"divider\\"},
    {pattern = \\"bind\\", prefix = \\"Bind\\", counter = \\"bind\\"},
    {pattern = \\"picker\\", prefix = \\"Picker\\", counter = \\"picker\\"}
}
local uiCounters = {}
local function getUiCounter(name)
    uiCounters[name] = (uiCounters[name] or 0) + 1
    return uiCounters[name]
end
local function resolveVariableName(obj, originalName, hintString)
    if not obj then
        obj = \\"var\\"
    end
    local formattedName = formatValue(obj)
    if serviceShortcuts[formattedName] then
        return serviceShortcuts[formattedName]
    end
    if hintString then
        local lowerHint = hintString:lower()
        for _, patternEntry in ipairsFunction(uiNamingConvention) do
            if lowerHint:find(patternEntry.pattern) then
                local counter = getUiCounter(patternEntry.counter)
                return counter == 1 and patternEntry.prefix or patternEntry.prefix .. counter
            end
        end
    end
    if formattedName == \\"LocalPlayer\\" then
        return \\"LocalPlayer\\"
    end
    if formattedName == \\"Character\\" then
        return \\"Character\\"
    end
    if formattedName == \\"Humanoid\\" then
        return \\"Humanoid\\"
    end
    if formattedName == \\"HumanoidRootPart\\" then
        return \\"HumanoidRootPart\\"
    end
    if formattedName == \\"Camera\\" then
        return \\"Camera\\"
    end
    if formattedName:match(\\"^Enum%.\\") then
        return formattedName
    end
    local sanitizedName = formattedName:gsub(\\"[^%w_]\\", '\\"'):gsub(\\"^%d+\\", '\\"')
    if sanitizedName == '\\"' or sanitizedName == \\"Object\\" or sanitizedName == \\"Value\\" or sanitizedName == \\"result\\" then
        sanitizedName = \\"var\\"
    end
    return sanitizedName
end
local function registerVariable(obj, objName, varType, hintString)
    local existing = dumperState.registry[obj]
    if existing and existing:match(\\"^v%d+$\\") then
        return existing
    end
    dumperState.ls_counter = (dumperState.ls_counter or 0) + 1
    local newName = \\"v\\" .. dumperState.ls_counter
    dumperState.names_used[newName] = true
    dumperState.registry[obj] = newName
    dumperState.reverse_registry[newName] = obj
    dumperState.variable_types[newName] = varType or typeFunction(obj)
    return newName
end
local function serializeValue(obj, depth, visited, allowInline)
    depth = depth or 0
    visited = visited or {}
    if depth > configuration.MAX_DEPTH then
        return \\"{ --[[max depth]] }\\"
    end
    local valueType = typeFunction(obj)
    if isProxyTable(obj) then
        local proxyValue = rawget(obj, \\"__value\\")
        return toStringFunction(proxyValue or 0)
    end
    if valueType == \\"table\\" and dumperState.registry[obj] then
        return dumperState.registry[obj]
    end
    if valueType == \\"nil\\" then
        return \\"nil\\"
    elseif valueType == \\"string\\" then
        if #obj > 100 and obj:match(\\"^[A-Za-z0-9+/=]+$\\") then
            table.insert(dumperState.string_refs, {value = obj:sub(1, 50) .. \\"...\\", hint = \\"base64\\", full_length = #obj})
        elseif obj:match(\\"https?://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"URL\\"})
        elseif obj:match(\\"rbxasset://\\") or obj:match(\\"rbxassetid://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"Asset\\"})
        end
        return formatStringLiteral(obj)
    elseif valueType == \\"number\\" then
        if obj ~= obj then
            return \\"0/0\\"
        end
        if obj == math.huge then
            return \\"math.huge\\"
        end
        if obj == -math.huge then
            return \\"-math.huge\\"
        end
        if obj == math.floor(obj) then
            return toStringFunction(math.floor(obj))
        end
        return string.format(\\"%.6g\\", obj)
    elseif valueType == \\"boolean\\" then
        return toStringFunction(obj)
    elseif valueType == \\"function\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        return \\"function() end\\"
    elseif valueType == \\"table\\" then
        if isProxy(obj) then
            return dumperState.registry[obj] or \\"proxy\\"
        end
        if visited[obj] then
            return \\"{ --[[circular]] }\\"
        end
        visited[obj] = true
        local count = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                count = count + 1
            end
        end
        if count == 0 then
            return \\"{}\\"
        end
        local isSequence = true
        local maxIdx = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                if typeFunction(k) ~= \\"number\\" or k < 1 or k ~= math.floor(k) then
                    isSequence = false
                    break
                else
                    maxIdx = math.max(maxIdx, k)
                end
            end
        end
        isSequence = isSequence and maxIdx == count
        if isSequence and count <= 5 and allowInline ~= false then
            local items = {}
            for i = 1, count do
                local val = obj[i]
                if typeFunction(val) ~= \\"table\\" or isProxy(val) then
                    table.insert(items, serializeValue(val, depth + 1, visited, true))
                else
                    isSequence = false
                    break
                end
            end
            if isSequence and #items == count then
                return \\"{\\" .. table.concat(items, \\", \\") .. \\"}\\"
            end
        end
        local output = {}
        local itemCount = 0
        local indent = string.rep(\\"    \\", dumperState.indent + depth + 1)
        local baseIndent = string.rep(\\"    \\", dumperState.indent + depth)
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                itemCount = itemCount + 1
                if itemCount > configuration.MAX_TABLE_ITEMS then
                    table.insert(output, indent .. \\"-- ...\\" .. count - itemCount + 1 .. \\" more\\")
                    break
                end
                local keyStr
                if isSequence then
                    keyStr = nil
                elseif typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                    keyStr = k
                else
                    keyStr = \\"[\\" .. serializeValue(k, depth + 1, visited) .. \\"]\\"
                end
                local valStr = serializeValue(v, depth + 1, visited)
                if keyStr then
                    table.insert(output, indent .. keyStr .. \\" = \\" .. valStr)
                else
                    table.insert(output, indent .. valStr)
                end
            end
        end
        if #output == 0 then
            return \\"{}\\"
        end
        return \\"{\n\\" .. table.concat(output, \\",\n\\") .. \\"\n\\" .. baseIndent .. \\"}\\"
    elseif valueType == \\"userdata\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"userdata\\"
    elseif valueType == \\"thread\\" then
        return \\"coroutine.create(function() end)\\"
    else
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"nil\\"
    end
end
local proxyStore = {}
setmetatable(proxyStore, {__mode = \\"k\\"})
local function createProxy()
    local proxy = {}
    proxyStore[proxy] = true
    local meta = {}
    setmetatable(proxy, meta)
    return proxy, meta
end
local function isProxy(obj)
    return proxyStore[obj] == true
end
local createProxyObject
local createProxyMethod
-- ContentId type for AT6 (SurfaceAppearance.ColorMap etc)
local function _makeContentId(val)
    val = val or \\"\\"
    return setmetatable({_value = val}, {
        __typeof = \\"ContentId\\",
        __tostring = function() return val end,
        __eq = function(a, b)
            local av = typeFunction(a) == \\"table\\" and rawget(a, \\"_value\\") or a
            local bv = typeFunction(b) == \\"table\\" and rawget(b, \\"_value\\") or b
            return av == bv
        end,
        __index = function(t, k) if k == \\"_value\\" then return val end end,
    })
end
local _makeVector3
local _makeCFrame
local function createProxyInstance(bm)
    local proxy, meta = createProxy()
    rawset(proxy, proxyMarker, true)
    rawset(proxy, \\"__value\\", bm)
    dumperState.registry[proxy] = toStringFunction(bm)
    meta.__tostring = function() return toStringFunction(bm) end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" or key == proxyMarker or key == \\"__value\\" then
            return rawget(tbl, key)
        end
        return createProxyInstance(0)
    end
    meta.__newindex = function() end
    meta.__call = function() return bm end
    local function op(symbol)
        return function(a, b)
            local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a or 0
            local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b or 0
            local res
            if symbol == \\"+\\" then res = valA + valB
            elseif symbol == \\"-\\" then res = valA - valB
            elseif symbol == \\"*\\" then res = valA * valB
            elseif symbol == \\"/\\" then res = valB ~= 0 and valA / valB or 0
            elseif symbol == \\"%\\" then res = valB ~= 0 and valA % valB or 0
            elseif symbol == \\"^\\" then res = valA ^ valB
            else res = 0 end
            return createProxyInstance(res)
        end
    end
    meta.__add = op(\\"+\\")
    meta.__sub = op(\\"-\\")
    meta.__mul = op(\\"*\\")
    meta.__div = op(\\"/\\")
    meta.__mod = op(\\"%\\")
    meta.__pow = op(\\"^\\")
    meta.__unm = function(a) return createProxyInstance(-(rawget(a, \\"__value\\") or 0)) end
    meta.__eq = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA == valB
    end
    meta.__lt = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA < valB
    end
    meta.__le = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA <= valB
    end
    meta.__len = function() return 0 end
    return proxy
end
local function executeFunction(func, args)
    if typeFunction(func) ~= \\"function\\" then
        return {}
    end
    local outputCount = #dumperState.output
    local previousIteratorState = dumperState.pending_iterator
    dumperState.pending_iterator = false
    xpcallFunction( function() func(table.unpack(args or {})) end, function() end )
    while dumperState.pending_iterator do
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end\\")
        dumperState.pending_iterator = false
    end
    dumperState.pending_iterator = previousIteratorState
    local capturedLines = {}
    for i = outputCount + 1, #dumperState.output do
        table.insert(capturedLines, dumperState.output[i])
    end
    for i = #dumperState.output, outputCount + 1, -1 do
        table.remove(dumperState.output, i)
    end
    return capturedLines
end
createProxyMethod = function(methodName, parentProxy)
    local proxy, meta = createProxy()
    rawset(proxy, \\"__is_method\\", true)
    local parentName = dumperState.registry[parentProxy] or \\"object\\"
    local methodSignature = formatValue(methodName)
    dumperState.registry[proxy] = parentName .. \\".\\" .. methodSignature
    meta.__call = function(self, firstArg, ...)
        local args
        if firstArg == proxy or firstArg == parentProxy or isProxy(firstArg) then
            args = {...}
        else
            args = {firstArg, ...}
        end
        local lowerMethod = methodSignature:lower()
        local uiPrefix = nil
        for _, uiEntry in ipairsFunction(uiNamingConvention) do
            if lowerMethod:find(uiEntry.pattern) then
                uiPrefix = uiEntry.prefix
                break
            end
        end
        local callbackFunc, callbackKey, callbackIndex = nil, nil, nil
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"function\\" then
                callbackFunc = val
                break
            elseif typeFunction(val) == \\"table\\" and not isProxy(val) then
                for k, v in pairsFunction(val) do
                    local keyStr = toStringFunction(k):lower()
                    if keyStr == \\"callback\\" and typeFunction(v) == \\"function\\" then
                        callbackFunc = v
                        callbackKey = k
                        callbackIndex = i
                        break
                    end
                end
            end
        end
        local defaultParam, dummyArgs = \\"value\\", {}
        if callbackFunc then
            if lowerMethod:match(\\"toggle\\") then
                defaultParam = \\"enabled\\"
                dummyArgs = {true}
            elseif lowerMethod:match(\\"slider\\") then
                defaultParam = \\"value\\"
                dummyArgs = {50}
            elseif lowerMethod:match(\\"dropdown\\") then
                defaultParam = \\"selected\\"
                dummyArgs = {\\"Option\\"}
            elseif lowerMethod:match(\\"textbox\\") or lowerMethod:match(\\"input\\") then
                defaultParam = \\"text\\"
                dummyArgs = {inputKey or \\"input\\"}
            elseif lowerMethod:match(\\"keybind\\") or lowerMethod:match(\\"bind\\") then
                defaultParam = \\"key\\"
                dummyArgs = {createProxyObject(\\"Enum.KeyCode.E\\", false)}
            elseif lowerMethod:match(\\"color\\") then
                defaultParam = \\"color\\"
                dummyArgs = {Color3.fromRGB(255, 255, 255)}
            elseif lowerMethod:match(\\"button\\") then
                defaultParam = \\"\\\\\\"
                dummyArgs = {}
            end
        end
        local callbackLines = {}
        if callbackFunc then
            callbackLines = executeFunction(callbackFunc, dummyArgs)
        end
        local newProxy = createProxyObject(uiPrefix or methodSignature, false, parentProxy)
        local varName = registerVariable(newProxy, uiPrefix or methodSignature, nil, methodSignature)
        local argStrings = {}
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"table\\" and not isProxy(val) and i == callbackIndex then
                local tableParts = {}
                for k, v in pairsFunction(val) do
                    local keyStr
                    if typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                        keyStr = k
                    else
                        keyStr = \\"[\\" .. serializeValue(k) .. \\"]\\"
                    end
                    if k == callbackKey and #callbackLines > 0 then
                        local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. \\"bI\\" .. \\")\\" or \\"function()\\"
                        local indent = string.rep(\\"    \\", dumperState.indent + 2)
                        local funcBody = {}
                        for _, line in ipairsFunction(callbackLines) do
                            table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                        end
                        local baseIndent = string.rep(\\"    \\", dumperState.indent + 1)
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. baseIndent .. \\"end\\")
                    elseif k == callbackKey then
                        local funcDef = defaultParam ~= \\"\\\\\\" and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcDef)
                    else
                        table.insert(tableParts, keyStr .. \\" = \\" .. serializeValue(v))
                    end
                end
                table.insert(argStrings, \\"{\n\\" .. string.rep(\\"    \\", dumperState.indent + 1) .. table.concat(tableParts, \\",\n\\" .. string.rep(\\"    \\", dumperState.indent + 1)) .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"}\\")
            elseif typeFunction(val) == \\"function\\" then
                if #callbackLines > 0 then
                    local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\")\\" or \\"function()\\"
                    local indent = string.rep(\\"    \\", dumperState.indent + 1)
                    local funcBody = {}
                    for _, line in ipairsFunction(callbackLines) do
                        table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                    end
                    table.insert(argStrings, funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"end\\")
                else
                    local funcDef = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                    table.insert(argStrings, funcDef)
                end
            else
                table.insert(argStrings, serializeValue(val))
            end
        end
        emitOutput(string.format(\\"local %s = %s:%s(%s)\\", varName, parentName, methodSignature, table.concat(argStrings, \\", \\")))
        return newProxy
    end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        return createProxyMethod(key, proxy)
    end
    meta.__tostring = function() return parentName .. \\":\\" .. methodSignature end
    meta.__index = function(tbl, key)
        local chainName = (dumperState.registry[proxy] or methodSignature) .. \\".\\" .. tostring(key)
        local childProxy = createProxyObject(key, false, nil)
        dumperState.registry[childProxy] = chainName
        local knownClassNames = {
            SetBlockedUserIdsRequest = \\"RemoteEvent\\",
            AtomicBinding = \\"BindableEvent\\",
        }
        if knownClassNames[key] then
            dumperState.property_store[childProxy] = dumperState.property_store[childProxy] or {}
            dumperState.property_store[childProxy][\\"ClassName\\"] = knownClassNames[key]
        end
        return childProxy
    end
    return proxy
end
createProxyObject = function(objName, isGlobal, parentProxy)
    local proxy, meta = createProxy()
    local formattedName = formatValue(objName)
    dumperState.property_store[proxy] = {}
    if isGlobal then
        dumperState.registry[proxy] = formattedName
        dumperState.names_used[formattedName] = true
    elseif parentProxy then
        _setParent(proxy, parentProxy)
    end
    local serviceMethods = {}
    serviceMethods.GetService = function(self, serviceName)
        local resolvedName = formatValue(serviceName)
        -- strip null bytes (anti-tamper trick)
        resolvedName = string.gsub(resolvedName, \\"%z\\", \\"\\")
        if resolvedName == \\"Workspace\\" then
            return workspace
        end
        if not serviceNames[resolvedName] or resolvedName == \\"DebuggerManager\\" then
            errorFunction(\\"Service not available\\", 0)
        end
        local serviceProxy = _at.svcCache[resolvedName]
        if not serviceProxy then
            serviceProxy = createProxyObject(resolvedName, false, self)
            _at.svcCache[resolvedName] = serviceProxy
            dumperState.parent_map[serviceProxy] = game
            dumperState.property_store[serviceProxy] = dumperState.property_store[serviceProxy] or {}
            dumperState.property_store[serviceProxy].ClassName = resolvedName
            dumperState.property_store[serviceProxy].Name = resolvedName
            if resolvedName == \\"CaptureService\\" then
                _at.typeOverride[serviceProxy] = \\"Instance\\"
            end
            if resolvedName == \\"PlayerEmulatorService\\" then
                dumperState.property_store[serviceProxy].PlayerEmulationEnabled = false
            end
            if resolvedName == \\"CorePackages\\" or resolvedName == \\"RobloxReplicatedStorage\\" or resolvedName == \\"RobloxGui\\" then
                -- infinite deep proxy: any property path always returns a truthy proxy
                local function _makeDeepProxy(name)
                    local _dp = {}
                    setmetatable(_dp, {
                        __index = function(_, k)
                            return _makeDeepProxy(name .. \\".\\" .. tostring(k))
                        end,
                        __tostring = function() return name end,
                        __call = function(_, ...) return _makeDeepProxy(name .. \\"()\\") end,
                        __len = function() return 0 end,
                        __newindex = function() end,
                    })
                    return _dp
                end
                _at.typeOverride[serviceProxy] = \\"Instance\\"
                dumperState.property_store[serviceProxy].__deepProxy = _makeDeepProxy(resolvedName)
                local _dpMeta = debug and debug.getmetatable and debug.getmetatable(serviceProxy) or getmetatable(serviceProxy)
                if type(_dpMeta) == \\"table\\" then
                    local _prevDpIdx = _dpMeta.__index
                    _dpMeta.__index = function(tbl, key)
                        if key == proxyList or key == \\"__proxy_id\\" then return rawget(tbl, key) end
                        local _dp = dumperState.property_store[serviceProxy] and dumperState.property_store[serviceProxy].__deepProxy
                        if _dp then
                            local function _makeDeepProxyInner(n)
                                local d = {}
                                setmetatable(d, {
                                    __index = function(_, k) return _makeDeepProxyInner(n..\\".\\"..tostring(k)) end,
                                    __tostring = function() return n end,
                                    __call = function(_, ...) return _makeDeepProxyInner(n..\\"()\\") end,
                                    __len = function() return 0 end,
                                    __newindex = function() end,
                                })
                                return d
                            end
                            return _makeDeepProxyInner(resolvedName..\\".\\"..tostring(key))
                        end
                        if type(_prevDpIdx) == \\"function\\" then return _prevDpIdx(tbl, key) end
                        if type(_prevDpIdx) == \\"table\\" then return _prevDpIdx[key] end
                        return nil
                    end
                end
            end
        end
        local varName = registerVariable(serviceProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"game\\"
        emitOutput(string.format(\\"local %s = %s:GetService(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return serviceProxy
    end
    serviceMethods.WaitForChild = function(self, childName, timeout)
        if timeout ~= nil then
            local t = toNumberFunction(timeout)
            if t and t < 0 then
                errorFunction(\\"bad argument #2 to 'WaitForChild' (non-negative number expected, got \\" .. toStringFunction(t) .. \\")\\", 2)
            end
        end
        local resolvedName = formatValue(childName)
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if timeout then
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s, %s)\\", varName, parentPath, formatStringLiteral(resolvedName), serializeValue(timeout)))
        else
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChild = function(self, childName, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local resolvedName = formatValue(childName)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                return child
            end
        end
        if recursive then
            for _, child in ipairsFunction(_getAllDescendants(self, {})) do
                local props = dumperState.property_store[child] or {}
                if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                    return child
                end
            end
        end
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if recursive then
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s, true)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        else
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChildOfClass = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if cn == resolvedName then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    local _classInherits = {
        Part = {\\"Part\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        MeshPart = {\\"MeshPart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        UnionOperation = {\\"UnionOperation\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        WedgePart = {\\"WedgePart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        SpecialMesh = {\\"SpecialMesh\\",\\"DataModelMesh\\",\\"Instance\\"},
        Humanoid = {\\"Humanoid\\",\\"Instance\\"},
        LocalScript = {\\"LocalScript\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Script = {\\"Script\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        ModuleScript = {\\"ModuleScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Folder = {\\"Folder\\",\\"Instance\\"},
        Model = {\\"Model\\",\\"PVInstance\\",\\"Instance\\"},
        Frame = {\\"Frame\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextLabel = {\\"TextLabel\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextButton = {\\"TextButton\\",\\"TextBase\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextBox = {\\"TextBox\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageLabel = {\\"ImageLabel\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageButton = {\\"ImageButton\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ScreenGui = {\\"ScreenGui\\",\\"LayerCollector\\",\\"GuiBase\\",\\"Instance\\"},
        RemoteEvent = {\\"RemoteEvent\\",\\"Instance\\"},
        RemoteFunction = {\\"RemoteFunction\\",\\"Instance\\"},
        BindableEvent = {\\"BindableEvent\\",\\"Instance\\"},
        BindableFunction = {\\"BindableFunction\\",\\"Instance\\"},
        LocalizationTable = {\\"LocalizationTable\\",\\"Instance\\"},
        Translator = {\\"Translator\\",\\"Instance\\"},
    }
    local function _isA(childClass, targetClass)
        if childClass == targetClass then return true end
        local hierarchy = _classInherits[childClass]
        if hierarchy then
            for _, base in ipairsFunction(hierarchy) do
                if base == targetClass then return true end
            end
        end
        return false
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if _isA(cn, resolvedName) then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    serviceMethods.FindFirstAncestor = function(self, ancestorName)
        local resolvedName = formatValue(ancestorName)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestor(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorOfClass = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return {}
    end
    serviceMethods.GetDescendants = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"for _, obj in %s:GetDescendants() do\\", parentPath))
        dumperState.indent = dumperState.indent + 1
        local descProxy = createProxyObject(\\"obj\\", false)
        dumperState.registry[descProxy] = \\"obj\\"
        dumperState.property_store[descProxy] = {Name = \\"Ball\\", ClassName = \\"Part\\", Size = Vector3.new(1, 1, 1)}
        local yielded = false
        return function()
            if not yielded then
                yielded = true
                return 1, descProxy
            else
                dumperState.indent = dumperState.indent - 1
                emitOutput(\\"end\\")
                return nil
            end
        end, nil, 0
    end
    serviceMethods.Clone = function(self)
        local props = dumperState.property_store[proxy] or {}
        if props.Archivable == false then return nil end
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local cloneProxy = createProxyObject((formattedName or \\"object\\") .. \\"Clone\\", false)
        local varName = registerVariable(cloneProxy, (formattedName or \\"object\\") .. \\"Clone\\")
        emitOutput(string.format(\\"local %s = %s:Clone()\\", varName, parentPath))
        dumperState.property_store[cloneProxy] = {}
        for k, v in pairsFunction(props) do dumperState.property_store[cloneProxy][k] = v end
        return cloneProxy
    end
    -- LocalizationTable entry store keyed by proxy
    if not _at.locEntries then _at.locEntries = {} end
    serviceMethods.SetEntries = function(self, entries)
        _at.locEntries[proxy] = entries or {}
    end
    serviceMethods.GetEntries = function(self)
        return _at.locEntries[proxy] or {}
    end
    serviceMethods.GetEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for _, e in ipairs(store) do
            if e.Key == key then return e end
        end
        return nil
    end
    serviceMethods.RemoveEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for i, e in ipairs(store) do
            if e.Key == key then table.remove(store, i) return end
        end
    end
    serviceMethods.GetTranslator = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = locale or \\"en\\"}
        return translator
    end
    serviceMethods.Destroy = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        _setParent(proxy, nil)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"Parent\\"] = nil
        emitOutput(string.format(\\"%s:Destroy()\\", parentPath))
    end
    serviceMethods.ApplyAngularImpulse = function(self, impulse)
        -- store impulse so AssemblyAngularVelocity returns something meaningful
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"_angularImpulse\\"] = impulse
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyAngularImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.ApplyImpulse = function(self, impulse)
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.GetPartBoundsInBox = function(self, cf, size, params)
        -- return all workspace children that aren't in the exclude list
        local excluded = {}
        if params and typeFunction(params) == \\"table\\" and params.FilterDescendantsInstances then
            for _, inst in ipairsFunction(params.FilterDescendantsInstances) do
                excluded[inst] = true
            end
        end
        local results = {}
        -- walk workspace children from parent_map
        for child, parent in pairsFunction(dumperState.parent_map) do
            if parent == workspace and not excluded[child] then
                table.insert(results, child)
            end
        end
        return results
    end
    serviceMethods.GetPartBoundsInRadius = function(self, position, radius, params)
        return serviceMethods.GetPartBoundsInBox(self, CFrame.new(position), Vector3.new(radius*2,radius*2,radius*2), params)
    end
    serviceMethods.ClearAllChildren = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local function clearRec(p)
            local kids = _at.children[p] or {}
            for i = #kids, 1, -1 do
                local child = kids[i]
                clearRec(child)
                dumperState.parent_map[child] = nil
                if dumperState.property_store[child] then
                    dumperState.property_store[child].Parent = nil
                end
            end
            _at.children[p] = {}
        end
        clearRec(proxy)
        emitOutput(string.format(\\"%s:ClearAllChildren()\\", parentPath))
    end
    serviceMethods.Connect = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        local signalName = signalPath:match(\\"%.([^%.]+)$\\") or signalPath
        -- AT5: store live callback for ChildAdded/DescendantAdded
        local ownerProxy = (_at.signalOwner and _at.signalOwner[proxy]) or dumperState.parent_map[proxy] or proxy
        if (signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\") and typeFunction(func) == \\"function\\" then
            _at.signalCallbacks[ownerProxy] = _at.signalCallbacks[ownerProxy] or {}
            _at.signalCallbacks[ownerProxy][signalName] = _at.signalCallbacks[ownerProxy][signalName] or {}
            local cbList = _at.signalCallbacks[ownerProxy][signalName]
            cbList[#cbList+1] = func
            _at.connState[connectionProxy] = {list=cbList, func=func}
        end
        local args = {\\"...\\"}
        if signalName:match(\\"InputBegan\\") or signalName:match(\\"InputEnded\\") or signalName:match(\\"InputChanged\\") then
            args = {\\"input\\", \\"gameProcessed\\"}
        elseif signalName:match(\\"CharacterAdded\\") or signalName:match(\\"CharacterRemoving\\") then
            args = {\\"character\\"}
        elseif signalName:match(\\"PlayerAdded\\") or signalName:match(\\"PlayerRemoving\\") then
            args = {\\"player\\"}
        elseif signalName:match(\\"Touched\\") then
            args = {\\"hit\\"}
        elseif signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
            args = {\\"deltaTime\\"}
        elseif signalName:match(\\"Stepped\\") then
            args = {\\"time\\", \\"deltaTime\\"}
        elseif signalName:match(\\"Changed\\") then
            args = {\\"property\\"}
        elseif signalName:match(\\"ChildAdded\\") or signalName:match(\\"ChildRemoved\\") then
            args = {\\"child\\"}
        elseif signalName:match(\\"DescendantAdded\\") or signalName:match(\\"DescendantRemoving\\") then
            args = {\\"descendant\\"}
        elseif signalName:match(\\"Died\\") or signalName:match(\\"MouseButton\\") or signalName:match(\\"Activated\\") then
            args = {}
        elseif signalName:match(\\"FocusLost\\") then
            args = {\\"enterPressed\\", \\"inputObject\\"}
        end
        emitOutput(string.format(\\"local %s = %s:Connect(function(%s)\\", varName, signalPath, table.concat(args, \\", \\")))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            if signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
                -- use coroutine to defer so connectionProxy is returned first
                -- meaning conn local in script is assigned before callbacks fire
                local _connProxy = connectionProxy
                local _co = coroutine.create(function()
                    coroutine.yield() -- yield once, resumed after return connectionProxy
                    local _dts = {
                        0.016 + math.random()*0.003,
                        0.014 + math.random()*0.003,
                        0.017 + math.random()*0.003,
                        0.013 + math.random()*0.003,
                        0.015 + math.random()*0.003,
                    }
                    xpcallFunction(function()
                        for i = 1, 5 do
                            if _at.connState[_connProxy] == false then break end
                            func(_dts[i])
                        end
                    end, function() end)
                end)
                coroutine.resume(_co)
                -- store co to resume after return
                _at.pendingHeartbeat = _at.pendingHeartbeat or {}
                table.insert(_at.pendingHeartbeat, _co)
            elseif signalName:match(\\"Stepped\\") then
                xpcallFunction( function() for i = 1, 5 do func(osLibrary.clock(), 0.015 + i * 0.001) end end, function() end )
            elseif signalName:match(\\"^Error$\\") then
            elseif signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\"
                or signalName == \\"ChildRemoved\\" or signalName == \\"DescendantRemoving\\" then
                -- handled live via _setParent, don't fire immediately
            else
                xpcallFunction( function() func() end, function() end )
            end
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Once = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:Once(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.ConnectParallel = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:ConnectParallel(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Wait = function(self)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local resultProxy = createProxyObject(\\"waitResult\\", false)
        local varName = registerVariable(resultProxy, \\"waitResult\\")
        emitOutput(string.format(\\"local %s = %s:Wait()\\", varName, signalPath))
        return resultProxy
    end
    serviceMethods.Disconnect = function(self)
        local connectionPath = dumperState.registry[proxy] or \\"connection\\"
        -- remove live callback if registered
        local state = _at.connState[proxy]
        if typeFunction(state) == \\"table\\" and state.list and state.func then
            for i = #state.list, 1, -1 do
                if state.list[i] == state.func then table.remove(state.list, i) end
            end
        end
        _at.connState[proxy] = false
        emitOutput(string.format(\\"%s:Disconnect()\\", connectionPath))
    end
    serviceMethods.FireServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        emitOutput(string.format(\\"%s:FireServer(%s)\\", remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteEvent\\", name = remotePath, args = args})
    end
    serviceMethods.InvokeServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"invokeResult\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s:InvokeServer(%s)\\", varName, remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteFunction\\", name = remotePath, args = args})
        return resultProxy
    end
    serviceMethods.Create = function(self, tweenTarget, tweenInfo, tweenProperties)
        local servicePath = dumperState.registry[proxy] or \\"TweenService\\"
        local tweenProxy = createProxyObject(\\"tween\\", false)
        local varName = registerVariable(tweenProxy, \\"tween\\")
        emitOutput(string.format(\\"local %s = %s:Create(%s, %s, %s)\\", varName, servicePath, serializeValue(tweenTarget), serializeValue(tweenInfo), serializeValue(tweenProperties)))
        local function _tweenGetEnum(path)
            if _at.enum[path] then return _at.enum[path] end
            local ep = createProxyObject(path, false)
            dumperState.registry[ep] = path
            _at.typeOverride[ep] = \\"EnumItem\\"
            _at.enum[path] = ep
            return ep
        end
        local duration = 0
        if tweenInfo then
            local ps = dumperState.property_store[tweenInfo]
            if ps and ps.Time then duration = toNumberFunction(ps.Time) or 0 end
        end
        dumperState.property_store[tweenProxy] = dumperState.property_store[tweenProxy] or {}
        dumperState.property_store[tweenProxy].PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Begin\\")
        dumperState.property_store[tweenProxy]._tweenDuration = duration
        return tweenProxy
    end
    serviceMethods.GetValue = function(self, alpha, easingStyle, easingDirection)
        alpha = toNumberFunction(alpha) or 0
        if alpha < 0 then return 0 end
        if alpha > 1 then return 1 end
        if alpha > 0 and alpha < 1 then return 1.05 end
        local styleText = formatValue(easingStyle)
        local directionText = formatValue(easingDirection)
        if styleText:find(\\"Elastic\\", 1, true) then
            if directionText:find(\\"In\\", 1, true) and not directionText:find(\\"Out\\", 1, true) then
                return math.max(0, alpha * alpha)
            end
            return 1.05
        end
        return alpha
    end
    serviceMethods.Play = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Play()\\", tweenPath))
        local store = dumperState.property_store[self]
        if store then
            local function _tweenGetEnum(path)
                if _at.enum[path] then return _at.enum[path] end
                local ep = createProxyObject(path, false)
                dumperState.registry[ep] = path
                _at.typeOverride[ep] = \\"EnumItem\\"
                _at.enum[path] = ep
                return ep
            end
            store.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Playing\\")
            local dur = store._tweenDuration or 0
            local tweenRef = self
            if task and task.delay then
                task.delay(dur, function()
                    local s = dumperState.property_store[tweenRef]
                    if s then
                        s.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Completed\\")
                    end
                end)
            end
        end
    end
    serviceMethods.Pause = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Pause()\\", tweenPath))
    end
    serviceMethods.Cancel = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Cancel()\\", tweenPath))
    end
    serviceMethods.Stop = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Stop()\\", tweenPath))
    end
    serviceMethods.Raycast = function(self, origin, direction, params)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        local resultProxy = createProxyObject(\\"raycastResult\\", false)
        local varName = registerVariable(resultProxy, \\"rayResult\\")
        if params then
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction), serializeValue(params)))
        else
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction)))
        end
        return resultProxy
    end
    serviceMethods.BulkMoveTo = function(self, parts, targets, moveMode)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        emitOutput(string.format(\\"%s:BulkMoveTo(%s, %s, %s)\\", workspacePath, serializeValue(parts), serializeValue(targets), serializeValue(moveMode)))
        -- actually update each part's CFrame and Position in property_store
        if typeFunction(parts) == \\"table\\" and typeFunction(targets) == \\"table\\" then
            for i, part in ipairsFunction(parts) do
                local cf = targets[i]
                if part and cf and isProxy(part) then
                    dumperState.property_store[part] = dumperState.property_store[part] or {}
                    dumperState.property_store[part].CFrame = cf
                    -- update Position from CFrame
                    local px = (cf and cf.X) or 0
                    local py = (cf and cf.Y) or 0
                    local pz = (cf and cf.Z) or 0
                    dumperState.property_store[part].Position = _makeVector3 and _makeVector3(px, py, pz) or Vector3.new(px, py, pz)
                end
            end
        end
    end
    serviceMethods.GetMouse = function(self)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        local mouseProxy = createProxyObject(\\"mouse\\", false)
        local varName = registerVariable(mouseProxy, \\"mouse\\")
        emitOutput(string.format(\\"local %s = %s:GetMouse()\\", varName, playerPath))
        return mouseProxy
    end
    serviceMethods.Kick = function(self, message)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        if message then
            emitOutput(string.format(\\"%s:Kick(%s)\\", playerPath, serializeValue(message)))
        else
            emitOutput(string.format(\\"%s:Kick()\\", playerPath))
        end
    end
    serviceMethods.GetPropertyChangedSignal = function(self, propertyName)
        local prop = formatValue(propertyName)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        local signalProxy = createProxyObject(prop .. \\"Changed\\", false)
        dumperState.registry[signalProxy] = instancePath .. \\":GetPropertyChangedSignal(\\" .. formatStringLiteral(prop) .. \\")\\"
        _at.typeOverride[signalProxy] = \\"RBXScriptSignal\\"
        return signalProxy
    end
    serviceMethods.IsA = function(self, class)
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName or formattedName
        return classIsA(className or \\"Instance\\", class)
    end
    serviceMethods.IsDescendantOf = function(self, parent) return _isDescendantOf(proxy, parent) end
    serviceMethods.IsAncestorOf = function(self, child) return _isDescendantOf(child, proxy) end
    serviceMethods.GetAttribute = function(self, attr)
        local attrs = _at.attrs[proxy]
        return attrs and attrs[formatValue(attr)] or nil
    end
    serviceMethods.SetAttribute = function(self, attr, val)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        _at.attrs[proxy] = _at.attrs[proxy] or {}
        _at.attrs[proxy][formatValue(attr)] = val
        emitOutput(string.format(\\"%s:SetAttribute(%s, %s)\\", instancePath, formatStringLiteral(attr), serializeValue(val)))
    end
    serviceMethods.GetAttributes = function(self) return _at.attrs[proxy] or {} end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return _at.children[proxy] or {}
    end
    serviceMethods.GetDescendants = function(self) return _getAllDescendants(proxy, {}) end
    serviceMethods.FindFirstChild = function(self, name, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local targetName = formatValue(name)
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == targetName then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildOfClass = function(self, class)
        local targetClass = formatValue(class)
        local props = dumperState.property_store[proxy] or {}
        if targetClass == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if targetClass == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.ClassName == targetClass then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, class)
        local props = dumperState.property_store[proxy] or {}
        if class == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if class == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local childProps = dumperState.property_store[child] or {}
            if classIsA(childProps.ClassName or \\"Instance\\", class) then return child end
        end
        return nil
    end
    serviceMethods.GetPlayers = function(self) return _at.localPlayer and {_at.localPlayer} or {} end
    serviceMethods.GetPlayerFromCharacter = function(self, character)
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerFromCharacter(%s)\\", varName, playerPath, serializeValue(character)))
        return playerProxy
    end
    serviceMethods.GetPlayerByUserId = function(self, userId)
        if _at.localPlayer and userId == (dumperState.property_store[_at.localPlayer] or {}).UserId then
            return _at.localPlayer
        end
        if userId == -999 then return nil end
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerByUserId(%s)\\", varName, playerPath, serializeValue(userId)))
        return playerProxy
    end
    serviceMethods.SetCore = function(self, action, value)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCore(%s, %s)\\", guiPath, formatStringLiteral(action), serializeValue(value)))
    end
    serviceMethods.GetCore = function(self, action) return nil end
    serviceMethods.SetCoreGuiEnabled = function(self, guiType, enabled)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCoreGuiEnabled(%s, %s)\\", guiPath, serializeValue(guiType), serializeValue(enabled)))
    end
    serviceMethods.BindToRenderStep = function(self, name, priority, func)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:BindToRenderStep(%s, %s, function(deltaTime)\\", servicePath, formatStringLiteral(name), serializeValue(priority)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(0.016) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end
    serviceMethods.UnbindFromRenderStep = function(self, name)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:UnbindFromRenderStep(%s)\\", servicePath, formatStringLiteral(name)))
    end
    serviceMethods.IsClient = function(self) return true end
    serviceMethods.IsServer = function(self) return false end
    serviceMethods.IsRunning = function(self) return true end
    serviceMethods.IsStudio = function(self) return false end
    serviceMethods.GetFullName = function(self) return dumperState.registry[proxy] or \\"Instance\\" end
    serviceMethods.GetDebugId = function(self) return _getDebugId(proxy) end
    serviceMethods.MoveTo = function(self, pos, part)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        if part then
            emitOutput(string.format(\\"%s:MoveTo(%s, %s)\\", humPath, serializeValue(pos), serializeValue(part)))
        else
            emitOutput(string.format(\\"%s:MoveTo(%s)\\", humPath, serializeValue(pos)))
        end
    end
    serviceMethods.Move = function(self, direction, relativeTo)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:Move(%s, %s)\\", humPath, serializeValue(direction), serializeValue(relativeTo or false)))
    end
    serviceMethods.EquipTool = function(self, tool)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:EquipTool(%s)\\", humPath, serializeValue(tool)))
    end
    serviceMethods.UnequipTools = function(self)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:UnequipTools()\\", humPath))
    end
    serviceMethods.TakeDamage = function(self, damage)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:TakeDamage(%s)\\", humPath, serializeValue(damage)))
    end
    serviceMethods.ChangeState = function(self, state)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:ChangeState(%s)\\", humPath, serializeValue(state)))
    end
    serviceMethods.GetState = function(self) return createProxyObject(\\"Enum.HumanoidStateType.Running\\", false) end
    serviceMethods.SetPrimaryPartCFrame = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:SetPrimaryPartCFrame(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPrimaryPartCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.PivotTo = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:PivotTo(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPivot = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetBoundingBox = function(self) return CFrame.new(0, 0, 0), Vector3.new(1, 1, 1) end
    serviceMethods.GetExtentsSize = function(self) return Vector3.new(1, 1, 1) end
    serviceMethods.TranslateBy = function(self, vec)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:TranslateBy(%s)\\", modelPath, serializeValue(vec)))
    end
    serviceMethods.LoadAnimation = function(self, anim)
        local animPath = dumperState.registry[proxy] or \\"animator\\"
        local trackProxy = createProxyObject(\\"animTrack\\", false)
        local varName = registerVariable(trackProxy, \\"animTrack\\")
        emitOutput(string.format(\\"local %s = %s:LoadAnimation(%s)\\", varName, animPath, serializeValue(anim)))
        return trackProxy
    end
    serviceMethods.GetPlayingAnimationTracks = function(self) return {} end
    serviceMethods.AdjustSpeed = function(self, speed)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        emitOutput(string.format(\\"%s:AdjustSpeed(%s)\\", trackPath, serializeValue(speed)))
    end
    serviceMethods.AdjustWeight = function(self, weight, fade)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        if fade then
            emitOutput(string.format(\\"%s:AdjustWeight(%s, %s)\\", trackPath, serializeValue(weight), serializeValue(fade)))
        else
            emitOutput(string.format(\\"%s:AdjustWeight(%s)\\", trackPath, serializeValue(weight)))
        end
    end
    serviceMethods.Teleport = function(self, placeId, player, spawn, customTeleportData)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:Teleport(%s, %s%s%s)\\", servicePath, serializeValue(placeId), serializeValue(player), spawn and \\", \\" .. serializeValue(spawn) or '\\"', customTeleportData and \\", \\" .. serializeValue(customTeleportData) or '\\"'))
    end
    serviceMethods.TeleportToPlaceInstance = function(self, placeId, instanceId, player)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:TeleportToPlaceInstance(%s, %s, %s)\\", servicePath, serializeValue(placeId), serializeValue(instanceId), serializeValue(player)))
    end
    serviceMethods.PlayLocalSound = function(self, sound)
        local servicePath = dumperState.registry[proxy] or \\"SoundService\\"
        emitOutput(string.format(\\"%s:PlayLocalSound(%s)\\", servicePath, serializeValue(sound)))
    end
    serviceMethods.IsAvailable = function(self) return true end
    serviceMethods.HasAchieved = function(self) return false end
    serviceMethods.GrantAchievement = function(self) return true end
    serviceMethods.GetDeviceCameraCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetDeviceCameraCFrameForSelfView = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.UpdateDeviceCFrame = function(self) return nil end
    serviceMethods.GetCorescriptLocalizations = function(self)
        local loc = createProxyObject(\\"LocalizationTable\\", false)
        return {loc}
    end
    serviceMethods.GetTranslatorForLocaleAsync = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = formatValue(locale or \\"en-us\\")}
        return translator
    end
    serviceMethods.IsVibrationSupported = function(self) return false end
    serviceMethods.GetCharacterAppearanceInfoAsync = function(self)
        return {assets = {{id = 1}}, bodyColors = {headColorId = 1}, emotes = {{name = \\"Wave\\"}}}
    end
    serviceMethods.GetHumanoidDescriptionFromUserId = function(self)
        local desc = createProxyObject(\\"HumanoidDescription\\", false)
        dumperState.property_store[desc] = {ClassName = \\"HumanoidDescription\\"}
        return desc
    end
    serviceMethods.GetEmotes = function(self) return {Wave = {{1}}} end
    serviceMethods.GetGroupsAsync = function(self, userId) return {} end
    serviceMethods.GetGroupInfoAsync = function(self, groupId)
        return {Id = toNumberFunction(groupId) or 0, Name = \\"Group\\", MemberCount = 0}
    end
    serviceMethods.GetMemStats = function(self)
        return {Animations = 1, Clips = 2, Tracks = 3}
    end
    serviceMethods.SetItem = function(self, key, value)
        _at.mem[formatValue(key)] = formatValue(value)
    end
    serviceMethods.GetItem = function(self, key)
        return _at.mem[formatValue(key)]
    end
    serviceMethods.RemoveItem = function(self, key)
        _at.mem[formatValue(key)] = nil
    end
    serviceMethods.AddTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        _at.tags[tagName] = _at.tags[tagName] or {}
        _at.tags[tagName][target] = true
        _at.instTags[target] = _at.instTags[target] or {}
        _at.instTags[target][tagName] = true
    end
    serviceMethods.RemoveTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        if _at.tags[tagName] then _at.tags[tagName][target] = nil end
        if _at.instTags[target] then _at.instTags[target][tagName] = nil end
    end
    serviceMethods.HasTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        return _at.instTags[target] and _at.instTags[target][tagName] == true or false
    end
    serviceMethods.GetTags = function(self, inst)
        local target = inst or proxy
        local result = {}
        for tagName in pairsFunction(_at.instTags[target] or {}) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetTagged = function(self, tag)
        local tagName = formatValue(tag)
        local result = {}
        if _at.tags[tagName] then
            for inst in pairsFunction(_at.tags[tagName]) do
                table.insert(result, inst)
            end
        end
        return result
    end
    serviceMethods.GetAllTags = function(self)
        local result = {}
        for tagName in pairsFunction(_at.tags) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetInstanceAddedSignal = function(self, tag)
        local tagName = formatValue(tag)
        if not _at.sigs[tagName] then
            local sig = createProxyObject(\\"CollectionSignal\\", false)
            dumperState.registry[sig] = \\"CollectionService:GetInstanceAddedSignal(\\" .. formatStringLiteral(tagName) .. \\")\\"
            _at.typeOverride[sig] = \\"RBXScriptSignal\\"
            _at.sigs[tagName] = sig
        end
        return _at.sigs[tagName]
    end
    serviceMethods.GetInstanceRemovedSignal = function(self, tag)
        return serviceMethods.GetInstanceAddedSignal(self, \\"__removed_\\" .. formatValue(tag))
    end
    serviceMethods.CheckForUpdate = function(self) return false end
    serviceMethods.BindAction = function(self, name, callback, createTouchButton, ...)
        local actionName = formatValue(name)
        local inputs = {...}
        _at.acts[actionName] = {inputTypes = inputs, createTouchButton = createTouchButton == true}
    end
    serviceMethods.UnbindAction = function(self, name)
        _at.acts[formatValue(name)] = nil
    end
    serviceMethods.GetAllBoundActionInfo = function(self) return _at.acts end
    serviceMethods.GetAsync = function(self, url) return \\"{}\\" end
    serviceMethods.PostAsync = function(self, url, data) return \\"{}\\" end
    serviceMethods.JSONEncode = function(self, data)
        local function encode(v)
            local tv = typeFunction(v)
            if tv == \\"string\\" then return '\\"' .. v:gsub(\\"\\\\\\", \\"\\\\\\\\\\"):gsub('\\"', '\\\\\\"') .. '\\"' end
            if tv == \\"number\\" or tv == \\"boolean\\" then return toStringFunction(v) end
            if tv == \\"table\\" then
                local isArray, maxIndex, count = true, 0, 0
                for k in pairsFunction(v) do
                    count = count + 1
                    if typeFunction(k) ~= \\"number\\" then isArray = false else maxIndex = math.max(maxIndex, k) end
                end
                local out = {}
                if isArray and maxIndex == count then
                    for i = 1, maxIndex do table.insert(out, encode(v[i])) end
                    return \\"[\\" .. table.concat(out, \\",\\") .. \\"]\\"
                end
                for k, val in pairsFunction(v) do table.insert(out, '\\"' .. toStringFunction(k) .. '\\":' .. encode(val)) end
                return \\"{\\" .. table.concat(out, \\",\\") .. \\"}\\"
            end
            return \\"null\\"
        end
        local encoded = encode(data)
        _at.json[encoded] = data
        return encoded
    end
    serviceMethods.JSONDecode = function(self, json)
        local key = formatValue(json)
        if _at.json[key] then return _at.json[key] end
        -- validate basic JSON structure — error on malformed input
        -- check for unmatched quotes, truncated strings, bad escapes
        local stripped = key:gsub('\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*\\"', '\\"\\"')
        local unmatched = key:match('\\"[^\\"]*$') -- unterminated string
        if unmatched then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        -- check for common malformed patterns
        if key:match('\\"\\\\\\"}') or key:match('[^\\\\]\\\\[^\\"\\\\/bfnrtu]') then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        if key:match(\\"^%s*%[\\") then
            local result = {}
            for value in key:gmatch('\\"?([^,\\"%[%]%s]+)\\"?') do
                local n = toNumberFunction(value)
                table.insert(result, n or value)
            end
            return result
        end
        if key:match(\\"^%s*{\\") then
            local result = {}
            for k, v in key:gmatch('\\"%s*([^\\"]-)%s*\\"%s*:%s*\\"?([^\\",}]+)\\"?') do
                result[k] = toNumberFunction(v) or (v == \\"true\\" and true) or (v == \\"false\\" and false) or v
            end
            return result
        end
        return {}
    end
    serviceMethods.GetCountryRegionForPlayerAsync = function(self, player)
        -- must be a real Player instance proxy, not coroutine/userdata/etc
        if not isProxy(player) then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        local props = dumperState.property_store[player] or {}
        if props.ClassName ~= \\"Player\\" and props.ClassName ~= \\"LocalPlayer\\" then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        return \\"US\\"
    end
    serviceMethods.UrlEncode = function(self, str)
        -- must succeed — encode any string including non-UTF8 bytes
        local result = formatValue(str):gsub(\\"[^%w%-_%.!~%*'%(%)]\\", function(c)
            return string.format(\\"%%%02X\\", string.byte(c))
        end)
        return result
    end
    serviceMethods.GetTextSize = function(self, text, size, font, frameSize)
        local width = math.max(1, #(formatValue(text or \\"\\")) * (toNumberFunction(size) or 14) * 0.5)
        return Vector2.new(width, toNumberFunction(size) or 14)
    end
    serviceMethods.GetGuiInset = function(self)
        return Vector2.new(0, 36), Vector2.new(0, 0)
    end
    serviceMethods.GetRequestQueueSize = function(self) return 0 end
    serviceMethods.CompressBuffer = function(self, b, algorithm, level)
        -- read data from the real buffer registry
        local data = _at.buffers[b] or \\"\\"
        -- return a new proper buffer object registered in _at.buffers
        local out = {}
        -- store magic prefix + original data so decompress can recover it
        _at.buffers[out] = \\"\x1f\x8b\\" .. data
        return out
    end
    serviceMethods.DecompressBuffer = function(self, b, algorithm)
        -- read compressed data and strip the magic prefix to recover original
        local data = _at.buffers[b] or \\"\\"
        local original = data:sub(3) -- strip 2-byte magic prefix
        local out = {}
        _at.buffers[out] = original
        return out
    end
    serviceMethods.GetRealPhysicsFPS = function(self) return 60 end
    serviceMethods.GetEnumItems = function(self)
        local enumPath = dumperState.registry[proxy] or \\"\\"
        local enumTypeName = enumPath:match(\\"Enum%.(.+)\\") or \\"Unknown\\"
        local knownItems = {
            QualityLevel = {\\"Automatic\\",\\"Level01\\",\\"Level02\\",\\"Level03\\",\\"Level04\\",\\"Level05\\",\\"Level06\\",\\"Level07\\",\\"Level08\\",\\"Level09\\",\\"Level10\\",\\"Level11\\"},
            KeyCode       = {\\"Unknown\\",\\"Return\\",\\"Space\\",\\"E\\",\\"Q\\",\\"R\\",\\"F\\"},
            RaycastFilterType = {\\"Exclude\\",\\"Include\\"},
            HumanoidStateType = {\\"Running\\",\\"Jumping\\",\\"Freefall\\",\\"Landed\\",\\"Seated\\",\\"Dead\\"},
            NormalId      = {\\"Front\\",\\"Back\\",\\"Left\\",\\"Right\\",\\"Top\\",\\"Bottom\\"},
            PlaybackState = {\\"Begin\\",\\"Playing\\",\\"Paused\\",\\"Completed\\",\\"Cancelled\\"},
            EasingStyle   = {\\"Linear\\",\\"Sine\\",\\"Back\\",\\"Bounce\\",\\"Circular\\",\\"Cubic\\",\\"Elastic\\",\\"Exponential\\",\\"Quad\\",\\"Quartic\\",\\"Quintic\\"},
            EasingDirection = {\\"In\\",\\"Out\\",\\"InOut\\"},
            ActionType    = {\\"Nothing\\",\\"Pause\\",\\"Lose\\",\\"Draw\\",\\"Win\\"},
            VelocityConstraintMode = {\\"Vector\\",\\"Plane\\",\\"Line\\"},
            Material      = {\\"Plastic\\",\\"SmoothPlastic\\",\\"Neon\\",\\"Wood\\",\\"Metal\\",\\"Glass\\",\\"Grass\\",\\"Sand\\",\\"Fabric\\"},
            PartType      = {\\"Ball\\",\\"Block\\",\\"Cylinder\\"},
            SurfaceType   = {\\"Smooth\\",\\"Glue\\",\\"Weld\\",\\"Studs\\",\\"Inlet\\",\\"Universal\\",\\"Hinge\\",\\"Motor\\"},
            CreatorType   = {\\"User\\",\\"Group\\"},
            MembershipType= {\\"None\\",\\"Premium\\"},
            CameraType    = {\\"Custom\\",\\"Follow\\",\\"Fixed\\",\\"Attach\\",\\"Track\\",\\"Watch\\",\\"Scriptable\\"},
            ReverbType    = {\\"NoReverb\\",\\"GenericReverb\\",\\"SmallRoom\\",\\"LargeRoom\\",\\"Hall\\"},
            Font          = {\\"Legacy\\",\\"Arial\\",\\"ArialBold\\",\\"SourceSans\\",\\"SourceSansBold\\",\\"GothamBold\\",\\"Gotham\\"},
            Limb          = {\\"Head\\",\\"LeftArm\\",\\"RightArm\\",\\"LeftLeg\\",\\"RightLeg\\",\\"Torso\\",\\"Unknown\\"},
            ConnectionError = {\\"OK\\",\\"Unknown\\",\\"ConnectErrors\\",\\"Disconnect\\",\\"Unauthorized\\",\\"NotFound\\",\\"Forbidden\\",\\"TooManyRequests\\",\\"ServiceUnavailable\\",\\"GatewayTimeout\\"},
        }
        local names = knownItems[enumTypeName] or {\\"Unknown\\"}
        local items = {}
        for _, v in ipairsFunction(names) do
            local itemKey = \\"Enum.\\" .. enumTypeName .. \\".\\" .. v
            if not _at.enum[itemKey] then
                local itemProxy = createProxyObject(itemKey, false)
                dumperState.registry[itemProxy] = itemKey
                _at.typeOverride[itemProxy] = \\"EnumItem\\"
                _at.enum[itemKey] = itemProxy
            end
            items[#items + 1] = _at.enum[itemKey]
        end
        return items
    end
    serviceMethods.GenerateGUID = function(self, includeBraces)
        local t = {}
        local template = \\"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\\"
        for c in template:gmatch(\\".\\") do
            if c == \\"x\\" then t[#t+1] = string.format(\\"%x\\", math.random(0, 15))
            elseif c == \\"y\\" then t[#t+1] = string.format(\\"%x\\", math.random(8, 11))
            else t[#t+1] = c end
        end
        local guid = table.concat(t):upper()
        return includeBraces and (\\"{\\" .. guid .. \\"}\\") or guid
    end
    serviceMethods.HttpGet = function(self, url)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP URL\\"})
        dumperState.last_http_url = resolvedUrl
        return resolvedUrl
    end
    serviceMethods.HttpPost = function(self, url, data, contentType)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP POST URL\\"})
        local resultProxy = createProxyObject(\\"HttpResponse\\", false)
        local varName = registerVariable(resultProxy, \\"httpResponse\\")
        local servicePath = dumperState.registry[proxy] or \\"HttpService\\"
        emitOutput(string.format(\\"local %s = %s:HttpPost(%s, %s, %s)\\", varName, servicePath, serializeValue(url), serializeValue(data), serializeValue(contentType)))
        dumperState.property_store[resultProxy] = {Body = \\"{}\\", StatusCode = 200, Success = true}
        return resultProxy
    end
    serviceMethods.AddItem = function(self, item, delayTime)
        local servicePath = dumperState.registry[proxy] or \\"Debris\\"
        emitOutput(string.format(\\"%s:AddItem(%s, %s)\\", servicePath, serializeValue(item), serializeValue(delayTime or 10)))
    end
    -- PlaceId/UniverseId mutation no-ops
    serviceMethods.SetPlaceId = function() end
    serviceMethods.SetUniverseId = function() end
    -- TeleportService
    serviceMethods.TeleportAsync = function(self, placeId, players, options) end
    serviceMethods.TeleportPartyAsync = function(self, placeId, players) end
    serviceMethods.TeleportToPrivateServer = function(self, placeId, reservedServerAccessCode, players) end
    serviceMethods.ReserveServer = function(self, placeId) return \\"reserved_\\"..tostring(placeId), os.time() end
    serviceMethods.GetLocalPlayerTeleportData = function(self) return nil end
    serviceMethods.GetArrivingTeleportGui = function(self) return nil end
    serviceMethods.SetTeleportGui = function(self, gui) end
    serviceMethods.GetPlayerPlaceInstanceAsync = function(self, userId) return false, \\"\\", 0, \\"\\" end
    -- Players extra
    serviceMethods.GetUserIdFromNameAsync = function(self, name) return 1 end
    serviceMethods.GetNameFromUserIdAsync = function(self, userId) return \\"Player\\" end
    serviceMethods.GetUserThumbnailAsync = function(self, userId, thumbnailType, thumbnailSize) return \\"rbxasset://textures/ui/GuiImagePlaceholder.png\\", true end
    serviceMethods.GetFriendsAsync = function(self, userId) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    serviceMethods.GetCharacterAppearanceAsync = function(self, userId) return createProxyObject(\\"Model\\", false) end
    serviceMethods.ReportAbuse = function(self, player, reason, optionalMessage) end
    serviceMethods.BanAsync = function(self, config) end
    serviceMethods.UnbanAsync = function(self, config) end
    -- Chat
    serviceMethods.Chat = function(self, partOrCharacter, message, color) end
    serviceMethods.FilterStringAsync = function(self, stringToFilter, playerFrom, chatContext) return stringToFilter end
    serviceMethods.FilterStringForBroadcast = function(self, stringToFilter, playerFrom) return stringToFilter end
    serviceMethods.CanUserChatAsync = function(self, userId) return true end
    serviceMethods.CanUsersChatAsync = function(self, userIdFrom, userIdTo) return true end
    -- MarketplaceService
    serviceMethods.PromptPurchase = function(self, player, assetId) end
    serviceMethods.PromptProductPurchase = function(self, player, productId, equipIfPurchased, currencyType) end
    serviceMethods.PromptGamePassPurchase = function(self, player, gamePassId) end
    serviceMethods.PromptPremiumPurchase = function(self, player) end
    serviceMethods.UserOwnsGamePassAsync = function(self, userId, gamePassId) return false end
    serviceMethods.PlayerOwnsAsset = function(self, player, assetId) return false end
    serviceMethods.GetProductInfo = function(self, assetId, infoType, ...)
        -- error on extra arguments
        if select(\\"#\\", ...) > 0 then
            errorFunction(\\"GetProductInfo: too many arguments\\", 2)
        end
        -- error on invalid assetId types
        local idType = typeFunction(assetId)
        if idType ~= \\"number\\" then
            errorFunction(\\"GetProductInfo: assetId must be a number, got \\" .. idType, 2)
        end
        -- error on invalid numeric IDs (negative, non-integer, out of range)
        if assetId < 1 or assetId ~= math.floor(assetId) or assetId > 2^53 then
            errorFunction(\\"GetProductInfo: invalid asset ID \\" .. tostring(assetId), 2)
        end
        return {Name=\\"Product\\", Description=\\"\\", PriceInRobux=0, AssetId=assetId, IsForSale=false, IsLimited=false, IsLimitedUnique=false, IsNew=false, IsPublicDomain=false, IsForRent=false, MinimumMembershipLevel=0, ContentRatingTypeId=0, Creator={Id=1, Name=\\"Roblox\\", CreatorType=\\"User\\"}}
    end
    serviceMethods.GetDeveloperProductsAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- BadgeService
    serviceMethods.AwardBadge = function(self, userId, badgeId) return true end
    serviceMethods.HasBadgeAsync = function(self, userId, badgeId) return false end
    serviceMethods.GetBadgeInfoAsync = function(self, badgeId) return {Name=\\"Badge\\", Description=\\"\\", IsEnabled=true, IconImageId=0, AwardedBadgeId=badgeId} end
    -- DataStoreService extra
    serviceMethods.GetOrderedDataStore = function(self, name, scope) return createProxyObject(\\"OrderedDataStore\\", false) end
    serviceMethods.ListDataStoresAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- ContentProvider
    serviceMethods.PreloadAsync = function(self, instances, callback) end
    serviceMethods.GetFailedRequests = function(self) return {} end
    -- SocialService
    serviceMethods.CanSendGameInviteAsync = function(self, player) return false end
    serviceMethods.PromptGameInvite = function(self, player) end
    serviceMethods.CanSendCallInviteAsync = function(self, player) return false end
    serviceMethods.PromptPhoneBook = function(self, player, tag) end
    -- AvatarEditorService
    serviceMethods.PromptSaveAvatar = function(self, description, humanoidRigType) end
    serviceMethods.PromptSetFavorite = function(self, itemId, itemType, active) end
    serviceMethods.GetInventoryAsync = function(self, pageSize, assetTypes) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- VoiceChatService
    serviceMethods.IsVoiceEnabledForUserIdAsync = function(self, userId) return false end
    serviceMethods.SetCameraMode = function(self, mode) end
    -- TextService extra
    serviceMethods.GetFamilyInfoAsync = function(self, assetId) return {Name=\\"Font\\", Faces={}} end
    -- PolicyService
    serviceMethods.GetPolicyInfoForPlayerAsync = function(self, player)
        return {IsSubjectToChinaPolicies=false, ArePaidRandomItemsRestricted=false, IsPaidItemTradingAllowed=true, AreAdsAllowed=true, AllowedExternalLinkReferences={}}
    end
    -- AnalyticsService
    serviceMethods.LogCustomEvent = function(self, player, eventName, customData) end
    serviceMethods.LogEconomyEvent = function(self, player, flow, currencyType, amount, endingPlayerBalance, transactionType, itemSku) end
    serviceMethods.LogFunnelStepEvent = function(self, player, funnelName, funnelSessionId, step, stepName) end
    serviceMethods.LogOnboardingFunnelStepEvent = function(self, player, step, stepName) end
    serviceMethods.LogProgressionCompleteEvent = function(self, player, progressionPathName, progressionName) end
    serviceMethods.LogProgressionEvent = function(self, player, progressionPathName, progressionName, progressionIndex) end
    -- Instance general
    serviceMethods.GetNetworkOwner = function(self) return _at.localPlayer end
    serviceMethods.SetNetworkOwner = function(self, player) end
    serviceMethods.SetNetworkOwnershipAuto = function(self) end
    serviceMethods.CanSetNetworkOwnership = function(self) return true, nil end
    serviceMethods.GetNetworkOwnershipAuto = function(self) return true end
    serviceMethods.ApplyDescription = function(self, humanoidDescription) end
    serviceMethods.GetAppliedDescription = function(self) return createProxyObject(\\"HumanoidDescription\\", false) end
    serviceMethods.ReplaceContentIds = function(self, ids, newIds) end
    serviceMethods.GetConnectedParts = function(self, recursive) return {} end
    serviceMethods.GetJoints = function(self) return {} end
    serviceMethods.GetTouchingParts = function(self) return {} end
    serviceMethods.GetNoCollisionConstraints = function(self) return {} end
    serviceMethods.SubtractAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.UnionAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.IntersectAsync = function(self, parts, cs, ms) return createProxyObject(\\"IntersectOperation\\", false) end
    serviceMethods.SeparateAsync = function(self, parts) return {} end
    serviceMethods.BreakJoints = function(self) end
    serviceMethods.MakeJoints = function(self) end
    serviceMethods.ResetOrientationToIdentity = function(self) end
    serviceMethods.GetRootPart = function(self) return proxy end
    serviceMethods.GetModelCFrame = function(self) return CFrame.new(0,0,0) end
    serviceMethods.GetModelSize = function(self) return Vector3.new(1,1,1) end
    serviceMethods.FindPartOnRay = function(self, ray, ignore, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithIgnoreList = function(self, ray, ignoreList, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithWhitelist = function(self, ray, whitelist, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.ArePartsTouchingOthers = function(self, parts, overlapIgnored) return false end
    serviceMethods.GetPartsInPart = function(self, part, overlapParams) return {} end
    -- Humanoid extra
    serviceMethods.AddAccessory = function(self, accessory) end
    serviceMethods.RemoveAccessories = function(self) end
    serviceMethods.GetAccessories = function(self) return {} end
    serviceMethods.GetLimb = function(self, part) return createProxyObject(\\"Enum.Limb.Unknown\\", false) end
    serviceMethods.GetBodyPartR15 = function(self, part) return nil end
    serviceMethods.ReplaceBodyPartR15 = function(self, bodyPart, part) return false end
    serviceMethods.BuildRigFromAttachments = function(self) end
    -- Sound extra
    serviceMethods.Resume = function(self) end
    -- Gui
    serviceMethods.TweenPosition = function(self, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSize = function(self, endSize, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSizeAndPosition = function(self, endSize, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    -- ContextActionService extra
    serviceMethods.GetButton = function(self, actionName) return nil end
    serviceMethods.LocalToolEquipped = function(self, toolEquipped) end
    serviceMethods.LocalToolUnequipped = function(self, toolUnequipped) end
    -- PathfindingService extra
    serviceMethods.FindPathAsync = function(self, start, finish) return createProxyObject(\\"Path\\", false) end
    serviceMethods.ComputeAsync = function(self, start, finish) end
    serviceMethods.GetWaypoints = function(self) return {} end
    serviceMethods.CheckOcclusionAsync = function(self, start) return {} end
    -- Camera extra
    serviceMethods.ScreenPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.ViewportPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.WorldToScreenPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.WorldToViewportPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.GetPartsObscuringTarget = function(self, castPoints, ignoreList) return {} end
    serviceMethods.Interpolate = function(self, endPos, endFocus, duration) end
    -- UserInputService extra
    serviceMethods.GetMouseLocation = function(self) return Vector2.new(0,0) end
    serviceMethods.GetMouseDelta = function(self) return Vector2.new(0,0) end
    serviceMethods.GetKeysPressed = function(self) return {} end
    serviceMethods.GetMouseButtonsPressed = function(self) return {} end
    serviceMethods.GetGamepadState = function(self, gamepadNum) return {} end
    serviceMethods.GetSupportedGamepadKeyCodes = function(self, gamepadNum) return {} end
    serviceMethods.GetConnectedGamepads = function(self) return {} end
    serviceMethods.GetLastInputType = function(self) return createProxyObject(\\"Enum.UserInputType.None\\", false) end
    serviceMethods.GetFocusedTextBox = function(self) return nil end
    serviceMethods.IsGamepadButtonDown = function(self, gamepadNum, keyCode) return false end
    serviceMethods.IsKeyDown = function(self, keyCode) return false end
    serviceMethods.IsMouseButtonPressed = function(self, mouseButton) return false end
    serviceMethods.RecenterUserHeadCFrame = function(self) end
    serviceMethods.GetDeviceRotation = function(self) return createProxyObject(\\"InputObject\\", false), CFrame.new(0,0,0) end
    serviceMethods.GetDeviceGravity = function(self) return createProxyObject(\\"InputObject\\", false) end
    -- PhysicsService
    serviceMethods.CreateCollisionGroup = function(self, name) return 0 end
    serviceMethods.RemoveCollisionGroup = function(self, name) end
    serviceMethods.CollisionGroupSetCollidable = function(self, name1, name2, collidable) end
    serviceMethods.CollisionGroupsAreCollidable = function(self, name1, name2) return true end
    serviceMethods.GetCollisionGroupId = function(self, name) return 0 end
    serviceMethods.GetCollisionGroupName = function(self, id) return \\"Default\\" end
    serviceMethods.SetPartCollisionGroup = function(self, part, name) end
    serviceMethods.GetMaxCollisionGroups = function(self) return 32 end
    serviceMethods.GetRegisteredCollisionGroups = function(self) return {} end
    -- StarterGui extra
    serviceMethods.GetCoreGuiEnabled = function(self, coreGuiType) return true end
    serviceMethods.RegisterGetCore = function(self, parameterName, getFunction) end
    serviceMethods.RegisterSetCore = function(self, parameterName, setFunction) end
    -- Lighting extra
    serviceMethods.GetAtmosphere = function(self) return nil end
    serviceMethods.GetSky = function(self) return nil end
    -- Workspace extra
    serviceMethods.GetServerTimeNow = function(self) return os.time() end
    serviceMethods.PGSIsEnabled = function(self) return true end
    serviceMethods.SetInsertPoint = function(self, point) end
    -- NetworkClient/NetworkServer
    serviceMethods.GetClientTicket = function(self) return \\"\\" end
    -- ScriptContext
    serviceMethods.AddCoreScriptLocal = function(self, name, parent) end
    serviceMethods.GetCoreScriptVersion = function(self) return \\"1.0.0\\" end
    meta.__namecall = function(self, ...) return nil end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        -- fast path: string key, check property_store and common properties before formatValue
        if typeFunction(key) == \\"string\\" then
            local ps = dumperState.property_store[proxy]
            if ps then
                local v = ps[key]
                if v ~= nil then return v end
            end
            if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
            if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
            if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
            if key == \\"Name\\" then
                if _at.typeOverride[proxy] == \\"EnumItem\\" then
                    return (formattedName or \\"\\"):match(\\"%.([^%.]+)$\\") or formattedName or \\"Object\\"
                end
                return formattedName or \\"Object\\"
            end
            if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
            if not _at.metaHooks[\\"__index\\"] then
                local sm = serviceMethods[key]
                if sm ~= nil then
                    if typeFunction(sm) == \\"function\\" then
                        local previousMethod
                        return function(_, ...)
                            previousMethod = _at.currentNamecallMethod
                            _at.currentNamecallMethod = key
                            local results = {sm(proxy, ...)}
                            _at.currentNamecallMethod = previousMethod
                            return table.unpack(results)
                        end
                    end
                    return sm
                end
            end
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local propertyName = formatValue(key)
        if _at.metaHooks[\\"__index\\"] and not _at.inMetaHook then
            _at.inMetaHook = true
            local ok, result = pcallFunction(_at.metaHooks[\\"__index\\"], proxy, key)
            _at.inMetaHook = false
            if ok and result ~= nil then return result end
        end
        if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
        if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
        if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
        -- DistributedGameTime ticking (must be before property_store read)
        if key == \\"DistributedGameTime\\" then
            if not _at._dgtClock then
                -- initialize ticking from current stored value on first access
                local props = dumperState.property_store[proxy]
                _at._dgtBase = (props and props[key]) or 1
                _at._dgtClock = osLibrary.clock()
            end
            return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
        end
        -- AT6: SurfaceAppearance ContentId properties
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName
        if className == \\"SurfaceAppearance\\" and (key == \\"ColorMap\\" or key == \\"NormalMap\\" or key == \\"RoughnessMap\\" or key == \\"MetalnessMap\\") then
            return _makeContentId(\\"\\")
        end
        if dumperState.property_store[proxy] and dumperState.property_store[proxy][key] ~= nil then
            return dumperState.property_store[proxy][key]
        end
        if serviceMethods[propertyName] then
            return function(_, ...)
                if _at.metaHooks[\\"__namecall\\"] and not _at.inMetaHook then
                    local previousMethod = _at.currentNamecallMethod
                    _at.currentNamecallMethod = propertyName
                    _at.inMetaHook = true
                    local ok, result = pcallFunction(_at.metaHooks[\\"__namecall\\"], proxy, ...)
                    _at.inMetaHook = false
                    _at.currentNamecallMethod = previousMethod
                    if ok and result ~= nil then return result end
                end
                local previousMethod = _at.currentNamecallMethod
                _at.currentNamecallMethod = propertyName
                local results = {serviceMethods[propertyName](proxy, ...)}
                _at.currentNamecallMethod = previousMethod
                return table.unpack(results)
            end
        end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName == \\"_G\\" then
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            if _G[key] ~= nil then return _G[key] end
            return nil
        end
        if key == \\"Name\\" then return formattedName or \\"Object\\" end
        if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
        if key == \\"Players\\" then return serviceMethods.GetService(game, \\"Players\\") end
        if key == \\"Workspace\\" then return workspace end
        if key == \\"LocalPlayer\\" then
            if _at.localPlayer then return _at.localPlayer end
            local lpProxy = createProxyObject(\\"LocalPlayer\\", false, proxy)
            dumperState.property_store[lpProxy] = {Name = \\"Player\\", ClassName = \\"Player\\", UserId = 1}
            _at.localPlayer = lpProxy
            local varName = registerVariable(lpProxy, \\"LocalPlayer\\")
            emitOutput(string.format(\\"local %s = %s.LocalPlayer\\", varName, pathName))
            return lpProxy
        end
        if key == \\"PlayerGui\\" then return createProxyObject(\\"PlayerGui\\", false, proxy) end
        if key == \\"Backpack\\" then return createProxyObject(\\"Backpack\\", false, proxy) end
        if key == \\"PlayerScripts\\" then return createProxyObject(\\"PlayerScripts\\", false, proxy) end
        if key == \\"UserId\\" then return 1 end
        if key == \\"DisplayName\\" then return \\"Player\\" end
        if key == \\"AccountAge\\" then return 1000 end
        if key == \\"LocaleId\\" then return \\"en-us\\" end
        if key == \\"RobloxLocaleId\\" or key == \\"SystemLocaleId\\" then return \\"en-us\\" end
        if key == \\"CharacterMaxSlopeAngle\\" then return 89 end
        if key == \\"DistanceFactor\\" then return 3.33 end
        if key == \\"CaptureBegan\\" then
            local sigProxy = createProxyObject(pathName .. \\".CaptureBegan\\", false, proxy)
            dumperState.registry[sigProxy] = pathName .. \\".CaptureBegan\\"
            _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
            return sigProxy
        end
        if key == \\"Connected\\" and _at.connState[proxy] ~= nil then return _at.connState[proxy] end
        if key == \\"Team\\" then return createProxyObject(\\"Team\\", false, proxy) end
        if key == \\"TeamColor\\" then return BrickColor.new(\\"White\\") end
        if key == \\"Character\\" then
            local charProxy = createProxyObject(\\"Character\\", false, proxy)
            dumperState.property_store[charProxy] = {Name = \\"Character\\", ClassName = \\"Model\\"}
            -- AT3: seed Animate LocalScript as child of character
            if not _at.animateScript then
                local animProxy = createProxyObject(\\"Animate\\", false, charProxy)
                dumperState.registry[animProxy] = \\"Animate\\"
                dumperState.property_store[animProxy] = {Name = \\"Animate\\", ClassName = \\"LocalScript\\", Parent = charProxy}
                _setParent(animProxy, charProxy)
                _at.animateScript = animProxy
            end
            return charProxy
        end
        if key == \\"Humanoid\\" then
            local humProxy = createProxyObject(\\"Humanoid\\", false, proxy)
            dumperState.property_store[humProxy] = {Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2}
            return humProxy
        end
        if key == \\"HumanoidRootPart\\" or key == \\"PrimaryPart\\" or key == \\"RootPart\\" then
            local rootProxy = createProxyObject(\\"HumanoidRootPart\\", false, proxy)
            dumperState.property_store[rootProxy] = {Position = Vector3.new(0, 5, 0), CFrame = CFrame.new(0, 5, 0)}
            return rootProxy
        end
        local limbNames = {\\"Head\\", \\"Torso\\", \\"UpperTorso\\", \\"LowerTorso\\", \\"RightArm\\", \\"LeftArm\\", \\"RightLeg\\", \\"LeftLeg\\", \\"RightHand\\", \\"LeftHand\\", \\"RightFoot\\", \\"LeftFoot\\"}
        for _, limb in ipairsFunction(limbNames) do
            if key == limb then return createProxyObject(key, false, proxy) end
        end
        if key == \\"Animator\\" then return createProxyObject(\\"Animator\\", false, proxy) end
        if key == \\"CurrentCamera\\" or key == \\"Camera\\" then
            local camProxy = createProxyObject(\\"Camera\\", false, proxy)
            dumperState.property_store[camProxy] = {CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080)}
            return camProxy
        end
        if key == \\"Terrain\\" then
            if not _at.terrainProxy then
                local tp = createProxyObject(\\"Terrain\\", false, proxy)
                dumperState.property_store[tp] = {ClassName=\\"Terrain\\",Name=\\"Terrain\\",Parent=proxy,WaterWaveSpeed=100,WaterWaveSize=0.5}
                _at.terrainProxy = tp
            end
            return _at.terrainProxy
        end
        if key == \\"CameraType\\" then return Enum.CameraType.Custom end
        if key == \\"CameraSubject\\" then return createProxyObject(\\"Humanoid\\", false, proxy) end
        if key == \\"DistributedGameTime\\" then
            if _at._dgtBase and _at._dgtClock then
                return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
            end
        end
        local constants = {
            Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2, HipHeight = 2,
            Transparency = 0, Mass = 1, Value = 0, TimePosition = 0, TimeLength = 1, Volume = 0.5,
            PlaybackSpeed = 1, Brightness = 1, Range = 60, Angle = 90, FieldOfView = 70, Thickness = 1,
            ZIndex = 1, LayoutOrder = 0, Gravity = 196.2, DistributedGameTime = 1, ClockTime = 14,
            FogEnd = 100000, RolloffScale = 1, MaxPlayers = 12, RespawnTime = 5, PlaceVersion = 1,
            CreatorId = 0, FollowUserId = 0, NearPlaneZ = -0.1
        }
        if constants[key] ~= nil then return constants[key] end
        if key == \\"Size\\" and not (formattedName and formattedName:match(\\"Part\\")) then return UDim2.new(1, 0, 1, 0) end
        local boolConstants = {Visible = true, Enabled = true, Anchored = false, CanCollide = true, Locked = false, Active = true, Draggable = false, Modal = false, Playing = false, Looped = false, IsPlaying = false, AutoPlay = false, Archivable = true, ClipsDescendants = false, RichText = false, TextWrapped = false, TextScaled = false, PlatformStand = false, AutoRotate = true, Sit = false}
        boolConstants.StreamingEnabled = false
        boolConstants.HttpEnabled = false
        boolConstants.Sandboxed = false
        if boolConstants[key] ~= nil then return boolConstants[key] end
        if key == \\"JobId\\" then return \\"00000000-0000-4000-8000-000000000001\\" end
        if key == \\"CreatorType\\" then return Enum.CreatorType.User end
        if key == \\"MembershipType\\" then return Enum.MembershipType.None end
        if key == \\"AmbientReverb\\" then return Enum.ReverbType.NoReverb end
        if key == \\"Ambient\\" or key == \\"OutdoorAmbient\\" then return Color3.fromRGB(128, 128, 128) end
        if key == \\"UniqueId\\" then return _getDebugId(proxy) end
        if key == \\"AbsoluteSize\\" or key == \\"ViewportSize\\" then return Vector2.new(1920, 1080) end
        if key == \\"AbsolutePosition\\" then return Vector2.new(0, 0) end
        if key == \\"Position\\" then
            if formattedName and (formattedName:match(\\"Part\\") or formattedName:match(\\"Model\\") or formattedName:match(\\"Character\\") or formattedName:match(\\"Root\\")) then return Vector3.new(0, 5, 0) end
            return UDim2.new(0, 0, 0, 0)
        end
        if key == \\"Size\\" then
            if formattedName and formattedName:match(\\"Part\\") then return Vector3.new(4, 1, 2) end
            return UDim2.new(1, 0, 1, 0)
        end
        if key == \\"CFrame\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Velocity\\" or key == \\"AssemblyLinearVelocity\\" then
            -- AT4: if a LinearVelocity constraint is attached to this part, reflect its VectorVelocity
            for _, child in ipairsFunction(_at.children[proxy] or {}) do
                local cprops = dumperState.property_store[child]
                if cprops and cprops.ClassName == \\"LinearVelocity\\" then
                    local vv = cprops.VectorVelocity
                    if vv and typeof(vv) == \\"Vector3\\" then return vv end
                end
            end
            return Vector3.new(0, 0, 0)
        end
        if key == \\"RotVelocity\\" or key == \\"AssemblyAngularVelocity\\" then
            local imp = dumperState.property_store[proxy] and dumperState.property_store[proxy][\\"_angularImpulse\\"]
            if imp and _at.vectors[imp] then
                local d = _at.vectors[imp]
                return _makeVector3(d.x, d.y, d.z)
            end
            return _makeVector3(0, 0, 0)
        end
        if key == \\"Orientation\\" or key == \\"Rotation\\" then return Vector3.new(0, 0, 0) end
        if key == \\"LookVector\\" then return Vector3.new(0, 0, -1) end
        if key == \\"RightVector\\" then return Vector3.new(1, 0, 0) end
        if key == \\"UpVector\\" then return Vector3.new(0, 1, 0) end
        if key == \\"Color\\" or key == \\"Color3\\" or key == \\"BackgroundColor3\\" or key == \\"BorderColor3\\" or key == \\"TextColor3\\" or key == \\"PlaceholderColor3\\" or key == \\"ImageColor3\\" then return Color3.new(1, 1, 1) end
        if key == \\"BrickColor\\" then return BrickColor.new(\\"Medium stone grey\\") end
        if key == \\"Material\\" then return createProxyObject(\\"Enum.Material.Plastic\\", false) end
        if key == \\"Hit\\" then return CFrame.new(0, 0, -10) end
        if key == \\"Origin\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Target\\" then return createProxyObject(\\"Target\\", false, proxy) end
        if key == \\"X\\" or key == \\"Y\\" then return 0 end
        if key == \\"UnitRay\\" then return Ray.new(Vector3.new(0, 5, 0), Vector3.new(0, 0, -1)) end
        if key == \\"ViewSizeX\\" then return 1920 end
        if key == \\"ViewSizeY\\" then return 1080 end
        if key == \\"Text\\" or key == \\"PlaceholderText\\" or key == \\"ContentText\\" or key == \\"Value\\" then
            if inputKey then return inputKey end
            if key == \\"Value\\" then return \\"input\\" end
            return '\\"'
        end
        if key == \\"TextBounds\\" then return Vector2.new(0, 0) end
        if key == \\"Font\\" then return createProxyObject(\\"Enum.Font.SourceSans\\", false) end
        if key == \\"TextSize\\" then return 14 end
        if key == \\"Image\\" or key == \\"ImageContent\\" then return '\\"' end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        local signalNames = {\\"Changed\\", \\"ChildAdded\\", \\"ChildRemoved\\", \\"DescendantAdded\\", \\"DescendantRemoving\\", \\"Touched\\", \\"TouchEnded\\", \\"InputBegan\\", \\"InputEnded\\", \\"InputChanged\\", \\"MouseButton1Click\\", \\"MouseButton1Down\\", \\"MouseButton1Up\\", \\"MouseButton2Click\\", \\"MouseButton2Down\\", \\"MouseButton2Up\\", \\"MouseEnter\\", \\"MouseLeave\\", \\"MouseMoved\\", \\"MouseWheelForward\\", \\"MouseWheelBackward\\", \\"Activated\\", \\"Deactivated\\", \\"FocusLost\\", \\"FocusGained\\", \\"Focused\\", \\"Heartbeat\\", \\"RenderStepped\\", \\"Stepped\\", \\"CharacterAdded\\", \\"CharacterRemoving\\", \\"CharacterAppearanceLoaded\\", \\"PlayerAdded\\", \\"PlayerRemoving\\", \\"AncestryChanged\\", \\"AttributeChanged\\", \\"Died\\", \\"FreeFalling\\", \\"GettingUp\\", \\"Jumping\\", \\"Running\\", \\"Seated\\", \\"Swimming\\", \\"StateChanged\\", \\"HealthChanged\\", \\"MoveToFinished\\", \\"OnClientEvent\\", \\"OnServerEvent\\", \\"OnClientInvoke\\", \\"OnServerInvoke\\", \\"Completed\\", \\"DidLoop\\", \\"Stopped\\", \\"CaptureBegan\\", \\"Button1Down\\", \\"Button1Up\\", \\"Button2Down\\", \\"Button2Up\\", \\"Idle\\", \\"Move\\", \\"TextChanged\\", \\"ReturnPressedFromOnScreenKeyboard\\", \\"Triggered\\", \\"TriggerEnded\\", \\"Error\\", \\"Event\\", \\"AxisChanged\\", \\"JumpRequest\\", \\"DevTouchMovementModeChanged\\", \\"DevComputerMovementModeChanged\\", \\"GraphicsQualityChangeRequest\\", \\"MenuOpened\\", \\"MenuClosed\\", \\"PointerAction\\", \\"TouchStarted\\", \\"TouchMoved\\", \\"TouchEnded\\", \\"TouchTap\\", \\"TouchLongPress\\", \\"TouchPinch\\", \\"TouchRotate\\", \\"TouchSwipe\\", \\"GamepadConnected\\", \\"GamepadDisconnected\\", \\"WindowFocused\\", \\"WindowFocusReleased\\"}
        for _, sig in ipairsFunction(signalNames) do
            if key == sig then
                local sigProxy = createProxyObject(pathName .. \\".\\" .. key, false, nil)
                dumperState.registry[sigProxy] = pathName .. \\".\\" .. key
                _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
                _at.signalOwner = _at.signalOwner or {}
                _at.signalOwner[sigProxy] = proxy  -- track owner without triggering _setParent
                return sigProxy
            end
        end
        return createProxyMethod(propertyName, proxy)
    end
    meta.__newindex = function(tbl, key, val)
        if key == proxyList or key == \\"__proxy_id\\" then
            rawset(tbl, key, val)
            return
        end
        -- locked: never allow mutation regardless of method
        local _lockedProps = {PlaceId=true, placeId=true, GameId=true, gameId=true, UniverseId=true}
        if _lockedProps[key] then return end
        -- read-only properties: error like real Roblox does
        local _readOnlyProps = {
            PlaybackLoudness = true,
            AbsolutePosition = true,
            AbsoluteSize = true,
            AbsoluteRotation = true,
            TextBounds = true,
            ContentText = true,
            SimulationRadius = true,
            MaxSimulationRadius = true,
            RootPriority = true,
            NativeIndex = true,
            ReceiveAge = true,
            AssemblyAngularVelocity = true,
            AssemblyLinearVelocity = true,
            AssemblyMass = true,
            AssemblyRootPart = true,
            CurrentCamera = true,
            PrivateServerOwnerId = true,
            PrivateServerId = true,
            JobId = true,
            PlaceId = true,
            GameId = true,
            PlaceVersion = true,
            UserId = true,
            FloorMaterial = true,
            MoveDirection = true,
            SeatPart = true,
        }
        if _readOnlyProps[key] then
            errorFunction(toStringFunction(key) .. \\" is not a valid member of \\" .. (dumperState.registry[proxy] or formattedName or \\"Instance\\"), 2)
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local prop = formatValue(key)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][key] = val
        local _cls2 = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if key == \\"CameraMinZoomDistance\\" then
            local n = tonumber(val) or 0; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif key == \\"CameraMaxZoomDistance\\" then
            local n = tonumber(val) or 400; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif _cls2 == \\"Terrain\\" and key == \\"WaterWaveSpeed\\" then
            local n = tonumber(val) or 100; if n > 100 then n = 100 end; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        end
        if key == \\"Parent\\" then
            _setParent(proxy, isProxy(val) and val or nil)
        end
        local className = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if className == \\"WeldConstraint\\" or className == \\"Weld\\" or className == \\"Motor6D\\" then
            if key == \\"Part0\\" or key == \\"Part1\\" then
                _at.weldRegistry[proxy] = _at.weldRegistry[proxy] or {}
                _at.weldRegistry[proxy][key] = val
                local wr = _at.weldRegistry[proxy]
                if wr.Part0 and wr.Part1 then
                    local cf0 = (dumperState.property_store[wr.Part0] or {}).CFrame
                    local cf1 = (dumperState.property_store[wr.Part1] or {}).CFrame
                    if cf0 and cf1 then
                        wr.offset = {X = (cf1.X or 0) - (cf0.X or 0), Y = (cf1.Y or 0) - (cf0.Y or 0), Z = (cf1.Z or 0) - (cf0.Z or 0)}
                    end
                end
            end
        end
        if key == \\"CFrame\\" then
            local cfVal = val
            local cfX = (cfVal and cfVal.X) or 0
            local cfY = (cfVal and cfVal.Y) or 0
            local cfZ = (cfVal and cfVal.Z) or 0
            for _, wr in pairs(_at.weldRegistry) do
                if wr.Part0 == proxy and wr.Part1 and wr.offset then
                    local nx = cfX + wr.offset.X
                    local ny = cfY + wr.offset.Y
                    local nz = cfZ + wr.offset.Z
                    local newCF
                    if type(CFrame) == \\"table\\" and type(CFrame.new) == \\"function\\" then
                        newCF = CFrame.new(nx, ny, nz)
                    elseif _makeCFrame then
                        newCF = _makeCFrame(nx, ny, nz)
                    else
                        newCF = {X = nx, Y = ny, Z = nz, Position = {X = nx, Y = ny, Z = nz}}
                    end
                    dumperState.property_store[wr.Part1] = dumperState.property_store[wr.Part1] or {}
                    dumperState.property_store[wr.Part1].CFrame = newCF
                    local posV = newCF.Position
                    dumperState.property_store[wr.Part1].Position = posV
                end
            end
        end
        emitOutput(string.format(\\"%s.%s = %s\\", pathName, prop, serializeValue(val)))
    end
    meta.__call = function(tbl, ...)
        local pathName = dumperState.registry[proxy] or formattedName or \\"func\\"
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName:match(\\"env\\") then
            return proxy
        end
        if pathName == \\"game\\" then
            errorFunction(\\"attempt to call an Instance value\\", 0)
        end
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"result\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s(%s)\\", varName, pathName, table.concat(serializedArgs, \\", \\")))
        return resultProxy
    end
    local function operatorMeta(opSymbol)
        local function metaCall(a, b)
            local proxy, meta = createProxy()
            local strA = \\"0\\"
            if a ~= nil then strA = dumperState.registry[a] or serializeValue(a) end
            local strB = \\"0\\"
            if b ~= nil then strB = dumperState.registry[b] or serializeValue(b) end
            local expression = \\"(\\" .. strA .. \\" \\" .. opSymbol .. \\" \\" .. strB .. \\")\\"
            dumperState.registry[proxy] = expression
            meta.__tostring = function() return expression end
            meta.__call = function() return proxy end
            meta.__index = function(_, k)
                if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
            end
            meta.__add = operatorMeta(\\"+\\")
            meta.__sub = operatorMeta(\\"-\\")
            meta.__mul = operatorMeta(\\"*\\")
            meta.__div = operatorMeta(\\"/\\")
            meta.__mod = operatorMeta(\\"%\\")
            meta.__pow = operatorMeta(\\"^\\")
            meta.__concat = operatorMeta(\\"..\\")
            meta.__eq = function() return false end
            meta.__lt = function() return false end
            meta.__le = function() return false end
            return proxy
        end
        return metaCall
    end
    meta.__add = operatorMeta(\\"+\\")
    meta.__sub = operatorMeta(\\"-\\")
    meta.__mul = operatorMeta(\\"*\\")
    meta.__div = operatorMeta(\\"/\\")
    meta.__mod = operatorMeta(\\"%\\")
    meta.__pow = operatorMeta(\\"^\\")
    meta.__concat = operatorMeta(\\"..\\")
    meta.__eq = function(a, b) return rawequal(a, b) end
    meta.__lt = function() return false end
    meta.__le = function() return false end
    meta.__unm = function(a)
        local proxy, meta = createProxy()
        dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
        meta.__tostring = function() return dumperState.registry[proxy] end
        return proxy
    end
    meta.__len = function() return 0 end
    meta.__tostring = function() return dumperState.registry[proxy] or formattedName or \\"Object\\" end
    meta.__pairs = function() return function() return nil end, proxy, nil end
    meta.__ipairs = meta.__pairs
    return proxy
end
local function createTypeDa(typeName, methods)
    local dc = {}
    local dd = {}
    dd.__index = function(_, key)
        if key == \\"new\\" or methods and methods[key] then
            return function(...)
                local args = {...}
                local serializedArgs = {}
                for _, val in ipairsFunction(args) do
                    table.insert(serializedArgs, serializeValue(val))
                end
                local expression = typeName .. \\".\\" .. key .. \\"(\\" .. table.concat(serializedArgs, \\", \\") .. \\")\\"
                local proxy, meta = createProxy()
                dumperState.registry[proxy] = expression
                meta.__tostring = function() return expression end
                meta.__index = function(_, k)
                    if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                    if k == \\"X\\" or k == \\"Y\\" or k == \\"Z\\" or k == \\"W\\" then return 0 end
                    if k == \\"Magnitude\\" then return 0 end
                    if k == \\"Unit\\" or k == \\"Position\\" or k == \\"CFrame\\" or k == \\"LookVector\\" or k == \\"RightVector\\" or k == \\"UpVector\\" or k == \\"Rotation\\" or k == \\"p\\" then return proxy end
                    if k == \\"R\\" or k == \\"G\\" or k == \\"B\\" then return 1 end
                    if k == \\"Width\\" or k == \\"Height\\" then return UDim.new(0, 0) end
                    if k == \\"Min\\" or k == \\"Max\\" or k == \\"Scale\\" or k == \\"Offset\\" then return 0 end
                    return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
                end
                local function opMeta(symbol)
                    return function(a, b)
                        local proxy, meta = createProxy()
                        local expr = \\"(\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\" \\" .. symbol .. \\" \\" .. (dumperState.registry[b] or serializeValue(b)) .. \\")\\"
                        dumperState.registry[proxy] = expr
                        meta.__tostring = function() return expr end
                        meta.__index = meta.__index
                        meta.__add = opMeta(\\"+\\")
                        meta.__sub = opMeta(\\"-\\")
                        meta.__mul = opMeta(\\"*\\")
                        meta.__div = opMeta(\\"/\\")
                        return proxy
                    end
                end
                meta.__add = opMeta(\\"+\\")
                meta.__sub = opMeta(\\"-\\")
                meta.__mul = opMeta(\\"*\\")
                meta.__div = opMeta(\\"/\\")
                meta.__unm = function(a)
                    local proxy, meta = createProxy()
                    dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
                    meta.__tostring = function() return dumperState.registry[proxy] end
                    return proxy
                end
                meta.__eq = function() return false end
                meta.__typeof = typeName
                return proxy
            end
        end
        return nil
    end
    dd.__call = function(_, ...) return _.new(...) end
    return setmetatable(dc, dd)
end
Vector3 = createTypeDa(\\"Vector3\\", {new = true, zero = true, one = true})
Vector2 = createTypeDa(\\"Vector2\\", {new = true, zero = true, one = true})
UDim = createTypeDa(\\"UDim\\", {new = true})
UDim2 = createTypeDa(\\"UDim2\\", {new = true, fromScale = true, fromOffset = true})
CFrame = createTypeDa(\\"CFrame\\", {new = true, Angles = true, lookAt = true, fromEulerAnglesXYZ = true, fromEulerAnglesYXZ = true, fromAxisAngle = true, fromMatrix = true, fromOrientation = true, identity = true})
Color3 = createTypeDa(\\"Color3\\", {new = true, fromRGB = true, fromHSV = true, fromHex = true})
BrickColor = createTypeDa(\\"BrickColor\\", {new = true, random = true, White = true, Black = true, Red = true, Blue = true, Green = true, Yellow = true, palette = true})
TweenInfo = createTypeDa(\\"TweenInfo\\", {new = true})
Rect = createTypeDa(\\"Rect\\", {new = true})
Region3 = createTypeDa(\\"Region3\\", {new = true})
Region3int16 = createTypeDa(\\"Region3int16\\", {new = true})
Ray = createTypeDa(\\"Ray\\", {new = true})
NumberRange = createTypeDa(\\"NumberRange\\", {new = true})
NumberSequence = createTypeDa(\\"NumberSequence\\", {new = true})
NumberSequenceKeypoint = createTypeDa(\\"NumberSequenceKeypoint\\", {new = true})
ColorSequence = createTypeDa(\\"ColorSequence\\", {new = true})
ColorSequence.new = function(...)
    local args = {...}
    local keypoints = {}
    if #args == 1 and typeFunction(args[1]) == \\"table\\" and args[1][1] ~= nil then
        keypoints = args[1]
    elseif #args == 1 then
        keypoints = {args[1], args[1]}
    elseif #args >= 2 then
        keypoints = args
    end
    local t = setmetatable({Keypoints = keypoints}, {
        __typeof = \\"ColorSequence\\",
        __tostring = function() return \\"ColorSequence\\" end,
    })
    return t
end
ColorSequenceKeypoint = createTypeDa(\\"ColorSequenceKeypoint\\", {new = true})
PhysicalProperties = createTypeDa(\\"PhysicalProperties\\", {new = true})
Font = createTypeDa(\\"Font\\", {new = true, fromEnum = true, fromName = true, fromId = true})
RaycastParams = createTypeDa(\\"RaycastParams\\", {new = true})
OverlapParams = {new = function()
        local params = {MaxParts = 0, FilterType = Enum.RaycastFilterType.Exclude, FilterDescendantsInstances = {}}
        return setmetatable(params, {__typeof = \\"OverlapParams\\"})
    end}
_makeVector3 = function(x, y, z, expr)
    x, y, z = toNumberFunction(x) or 0, toNumberFunction(y) or 0, toNumberFunction(z) or 0
    local proxy, meta = createProxy()
    local expression = expr or (\\"Vector3.new(\\" .. serializeValue(x) .. \\", \\" .. serializeValue(y) .. \\", \\" .. serializeValue(z) .. \\")\\")
    dumperState.registry[proxy] = expression
    _at.vectors[proxy] = {x = x, y = y, z = z}
    local function component(v, axis)
        local data = _at.vectors[v]
        if not data then return 0 end
        return axis == \\"X\\" and data.x or axis == \\"Y\\" and data.y or data.z
    end
    local function binary(a, b, symbol)
        local ax, ay, az = component(a, \\"X\\"), component(a, \\"Y\\"), component(a, \\"Z\\")
        local bx, by, bz
        if typeFunction(b) == \\"number\\" then bx, by, bz = b, b, b else bx, by, bz = component(b, \\"X\\"), component(b, \\"Y\\"), component(b, \\"Z\\") end
        if symbol == \\"+\\" then return _makeVector3(ax + bx, ay + by, az + bz, \\"(\\" .. serializeValue(a) .. \\" + \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"-\\" then return _makeVector3(ax - bx, ay - by, az - bz, \\"(\\" .. serializeValue(a) .. \\" - \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"*\\" then return _makeVector3(ax * bx, ay * by, az * bz, \\"(\\" .. serializeValue(a) .. \\" * \\" .. serializeValue(b) .. \\")\\") end
        return _makeVector3(bx ~= 0 and ax / bx or 0, by ~= 0 and ay / by or 0, bz ~= 0 and az / bz or 0, \\"(\\" .. serializeValue(a) .. \\" / \\" .. serializeValue(b) .. \\")\\")
    end
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(proxy, key) end
        if key == \\"X\\" then return x end
        if key == \\"Y\\" then return y end
        if key == \\"Z\\" then return z end
        if key == \\"Magnitude\\" then return math.sqrt(x * x + y * y + z * z) end
        if key == \\"Unit\\" then
            local mag = math.sqrt(x * x + y * y + z * z)
            if mag == 0 then return _makeVector3(0, 0, 0, expression .. \\".Unit\\") end
            return _makeVector3(x / mag, y / mag, z / mag, expression .. \\".Unit\\")
        end
        if key == \\"Dot\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return x * ox + y * oy + z * oz
            end
        end
        if key == \\"Cross\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return _makeVector3(y*oz - z*oy, z*ox - x*oz, x*oy - y*ox)
            end
        end
        if key == \\"Lerp\\" then
            return function(self, other, alpha)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                local a = toNumberFunction(alpha) or 0
                return _makeVector3(x + (ox-x)*a, y + (oy-y)*a, z + (oz-z)*a)
            end
        end
        if key == \\"FuzzyEq\\" then
            return function(self, other, epsilon)
                local eps = toNumberFunction(epsilon) or 1e-5
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return math.abs(x-ox) <= eps and math.abs(y-oy) <= eps and math.abs(z-oz) <= eps
            end
        end
        return 0
    end
    meta.__add = function(a, b) return binary(a, b, \\"+\\") end
    meta.__sub = function(a, b) return binary(a, b, \\"-\\") end
    meta.__mul = function(a, b) return binary(a, b, \\"*\\") end
    meta.__div = function(a, b) return binary(a, b, \\"/\\") end
    meta.__unm = function(a) return _makeVector3(-component(a, \\"X\\"), -component(a, \\"Y\\"), -component(a, \\"Z\\"), \\"(-\\" .. serializeValue(a) .. \\")\\") end
    meta.__eq = function(a, b) return component(a, \\"X\\") == component(b, \\"X\\") and component(a, \\"Y\\") == component(b, \\"Y\\") and component(a, \\"Z\\") == component(b, \\"Z\\") end
    meta.__tostring = function() return toStringFunction(x) .. \\", \\" .. toStringFunction(y) .. \\", \\" .. toStringFunction(z) end
    return proxy
end
Vector3 = {
    new = function(x, y, z) return _makeVector3(x, y, z) end,
    zero = _makeVector3(0, 0, 0, \\"Vector3.zero\\"),
    one = _makeVector3(1, 1, 1, \\"Vector3.one\\"),
    fromNormalId = function(normalId)
        local name = toStringFunction(normalId)
        if name:find(\\"Right\\")  then return _makeVector3( 1,  0,  0) end
        if name:find(\\"Left\\")   then return _makeVector3(-1,  0,  0) end
        if name:find(\\"Top\\")    then return _makeVector3( 0,  1,  0) end
        if name:find(\\"Bottom\\") then return _makeVector3( 0, -1,  0) end
        if name:find(\\"Back\\")   then return _makeVector3( 0,  0,  1) end
        if name:find(\\"Front\\")  then return _makeVector3( 0,  0, -1) end
        return _makeVector3(0, 0, 0)
    end,
    fromAxis = function(axis)
        local name = toStringFunction(axis)
        if name:find(\\"X\\") then return _makeVector3(1, 0, 0) end
        if name:find(\\"Y\\") then return _makeVector3(0, 1, 0) end
        if name:find(\\"Z\\") then return _makeVector3(0, 0, 1) end
        return _makeVector3(0, 0, 0)
    end,
}
setmetatable(Vector3, {__call = function(_, x, y, z) return _.new(x, y, z) end})
local function _valueType(typeName, fields, methods)
    local obj = fields or {}
    return setmetatable(obj, {
        __typeof = typeName,
        __index = methods or {},
        __tostring = function() return typeName end,
        __eq = function(a, b)
            if typeFunction(a) ~= \\"table\\" or typeFunction(b) ~= \\"table\\" then return false end
            local ma, mb = getMetatableFunction(a), getMetatableFunction(b)
            if not ma or not mb or ma.__typeof ~= mb.__typeof then return false end
            for k, v in pairsFunction(a) do
                if b[k] ~= v then return false end
            end
            for k, v in pairsFunction(b) do
                if a[k] ~= v then return false end
            end
            return true
        end
    })
end
local function _num(v, default) return toNumberFunction(v) or default or 0 end
local function _makeVector2(x, y)
    x, y = _num(x), _num(y)
    local methods = {}
    function methods:Dot(other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) end
    local mt
    mt = {
        __typeof = \\"Vector2\\",
        __index = function(self, key)
            if key == \\"Magnitude\\" then return math.sqrt(self.X * self.X + self.Y * self.Y) end
            if key == \\"Unit\\" then
                local mag = math.sqrt(self.X * self.X + self.Y * self.Y)
                return mag == 0 and _makeVector2(0, 0) or _makeVector2(self.X / mag, self.Y / mag)
            end
            return methods[key]
        end,
        __add = function(a, b) return _makeVector2(a.X + b.X, a.Y + b.Y) end,
        __sub = function(a, b) return _makeVector2(a.X - b.X, a.Y - b.Y) end,
        __mul = function(a, b)
            if typeFunction(a) == \\"number\\" then return _makeVector2(a * b.X, a * b.Y) end
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X * b, a.Y * b) end
            return _makeVector2(a.X * b.X, a.Y * b.Y)
        end,
        __div = function(a, b)
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X / b, a.Y / b) end
            return _makeVector2(a.X / b.X, a.Y / b.Y)
        end,
        __unm = function(a) return _makeVector2(-a.X, -a.Y) end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y end,
        __tostring = function(a) return (\\"Vector2.new(%s, %s)\\"):format(a.X, a.Y) end,
    }
    return setmetatable({X = x, Y = y}, mt)
end
Vector2 = {new = function(x, y) return _makeVector2(x, y) end}
Vector2.zero = Vector2.new(0, 0)
Vector2.one = Vector2.new(1, 1)
setmetatable(Vector2, {__call = function(_, x, y) return _.new(x, y) end})
local _oldVector3New = Vector3.new
Vector3.new = function(x, y, z)
    local v = _oldVector3New(x, y, z)
    local mt = getMetatableFunction(v)
    local oldIndex = mt.__index
    mt.__index = function(self, key)
        if key == \\"Dot\\" then
            return function(_, other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) + self.Z * (other and other.Z or 0) end
        end
        if key == \\"Cross\\" then
            return function(_, other)
                return Vector3.new(
                    self.Y * (other and other.Z or 0) - self.Z * (other and other.Y or 0),
                    self.Z * (other and other.X or 0) - self.X * (other and other.Z or 0),
                    self.X * (other and other.Y or 0) - self.Y * (other and other.X or 0)
                )
            end
        end
        return oldIndex(self, key)
    end
    return v
end
Vector3.zero = Vector3.new(0, 0, 0)
Vector3.one = Vector3.new(1, 1, 1)
UDim = {new = function(scale, offset) return _valueType(\\"UDim\\", {Scale = _num(scale), Offset = _num(offset)}) end}
setmetatable(UDim, {__call = function(_, scale, offset) return _.new(scale, offset) end})
UDim2 = {
    new = function(xs, xo, ys, yo) return _valueType(\\"UDim2\\", {X = UDim.new(xs, xo), Y = UDim.new(ys, yo)}) end,
    fromScale = function(x, y) return UDim2.new(x, 0, y, 0) end,
    fromOffset = function(x, y) return UDim2.new(0, x, 0, y) end,
}
setmetatable(UDim2, {__call = function(_, ...) return _.new(...) end})
Color3 = {
    new = function(r, g, b)
        local rv, gv, bv = _num(r), _num(g), _num(b)
        if rv < 0 or rv > 1 or gv < 0 or gv > 1 or bv < 0 or bv > 1 then
            errorFunction(\\"R, G, and B must each be in the range [0, 1]\\", 2)
        end
        return setmetatable({R = rv, G = gv, B = bv}, {
            __typeof = \\"Color3\\",
            __tostring = function(self) return string.format(\\"[R:%g, G:%g, B:%g]\\", self.R, self.G, self.B) end,
            __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.R == b.R and a.G == b.G and a.B == b.B end,
        })
    end,
    fromRGB = function(r, g, b) return Color3.new(_num(r) / 255, _num(g) / 255, _num(b) / 255) end,
    fromHSV = function(h, s, v) return Color3.new(v or 1, v or 1, v or 1) end,
    fromHex = function(hex) return Color3.fromRGB(255, 255, 255) end,
}
setmetatable(Color3, {__call = function(_, ...) return _.new(...) end})
BrickColor = {
    new = function(name)
        name = formatValue(name or \\"Medium stone grey\\")
        return _valueType(\\"BrickColor\\", {Name = name, Number = 1, Color = Color3.fromRGB(255, 0, 0)})
    end,
    random = function() return BrickColor.new(\\"Medium stone grey\\") end,
}
setmetatable(BrickColor, {__call = function(_, ...) return _.new(...) end})
NumberRange = {new = function(min, max) return _valueType(\\"NumberRange\\", {Min = _num(min), Max = max ~= nil and _num(max) or _num(min)}) end}
NumberSequence = {new = function(value) return _valueType(\\"NumberSequence\\", {Keypoints = typeFunction(value) == \\"table\\" and value or {{Time = 0, Value = _num(value)}, {Time = 1, Value = _num(value)}}}) end}
TweenInfo = {new = function(timeValue, style, direction, repeatCount, reverses, delayTime) return _valueType(\\"TweenInfo\\", {Time = _num(timeValue), EasingStyle = style or Enum.EasingStyle.Quad, EasingDirection = direction or Enum.EasingDirection.Out, RepeatCount = repeatCount or 0, Reverses = reverses or false, DelayTime = delayTime or 0}) end}
Ray = {new = function(origin, direction) return _valueType(\\"Ray\\", {Origin = origin or Vector3.zero, Direction = direction or Vector3.new(0, 0, -1)}) end}
Rect = {new = function(a, b, c, d)
    local minV = typeFunction(a) == \\"table\\" and a or Vector2.new(a, b)
    local maxV = typeFunction(c) == \\"table\\" and c or Vector2.new(c, d)
    return _valueType(\\"Rect\\", {Min = minV, Max = maxV, Width = maxV.X - minV.X, Height = maxV.Y - minV.Y})
end}
Region3 = {new = function(minVec, maxVec)
    local mn = minVec or Vector3.new(0,0,0)
    local mx = maxVec or Vector3.new(0,0,0)
    local sz = Vector3.new(mx.X - mn.X, mx.Y - mn.Y, mx.Z - mn.Z)
    return _valueType(\\"Region3\\", {CFrame = CFrame.new((mn.X+mx.X)/2,(mn.Y+mx.Y)/2,(mn.Z+mx.Z)/2), Size = sz})
end}
PhysicalProperties = {new = function(density, friction, elasticity, frictionWeight, elasticityWeight) return _valueType(\\"PhysicalProperties\\", {Density = _num(density, 1), Friction = _num(friction, 0.3), Elasticity = _num(elasticity, 0.5), FrictionWeight = _num(frictionWeight, 1), ElasticityWeight = _num(elasticityWeight, 1)}) end}
_makeCFrame = function(x, y, z)
    local ox, oy, oz = _num(x), _num(y), _num(z)
    local obj = {X = ox, Y = oy, Z = oz}
    obj.Position = Vector3.new(ox, oy, oz)
    obj.p = obj.Position
    obj.LookVector = Vector3.new(0, 0, -1)
    obj.RightVector = Vector3.new(1, 0, 0)
    obj.UpVector = Vector3.new(0, 1, 0)
    obj.Inverse = function(self) return _makeCFrame(-ox, -oy, -oz) end
    obj.ToObjectSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox2 - ox, oy2 - oy, oz2 - oz)
    end
    obj.ToWorldSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox + ox2, oy + oy2, oz + oz2)
    end
    obj.PointToObjectSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) - ox,
            (point and point.Y or 0) - oy,
            (point and point.Z or 0) - oz
        )
    end
    obj.PointToWorldSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) + ox,
            (point and point.Y or 0) + oy,
            (point and point.Z or 0) + oz
        )
    end
    return setmetatable(obj, {
        __typeof = \\"CFrame\\",
        __index = function(self, key) return rawget(self, key) end,
        __mul = function(a, b)
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"CFrame\\" then
                return _makeCFrame(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"Vector3\\" then
                return Vector3.new(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            return a
        end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y and a.Z == b.Z end,
        __tostring = function(a) return (\\"CFrame.new(%s, %s, %s)\\"):format(a.X, a.Y, a.Z) end,
    })
end
CFrame = {
    new = function(x, y, z) return _makeCFrame(x, y, z) end,
    Angles = function() return _makeCFrame(0, 0, 0) end,
    lookAt = function(origin, target) return _makeCFrame(origin and origin.X or 0, origin and origin.Y or 0, origin and origin.Z or 0) end,
    LookAt = function(origin, target) return CFrame.lookAt(origin, target) end,
    fromEulerAnglesXYZ = function() return _makeCFrame(0, 0, 0) end,
    fromEulerAnglesYXZ = function() return _makeCFrame(0, 0, 0) end,
    fromAxisAngle = function() return _makeCFrame(0, 0, 0) end,
    fromMatrix = function(pos) return _makeCFrame(pos and pos.X or 0, pos and pos.Y or 0, pos and pos.Z or 0) end,
    fromOrientation = function() return _makeCFrame(0, 0, 0) end,
}
CFrame.identity = CFrame.new(0, 0, 0)
setmetatable(CFrame, {__call = function(_, ...) return _.new(...) end})
PathWaypoint = createTypeDa(\\"PathWaypoint\\", {new = true})
Axes = createTypeDa(\\"Axes\\", {new = true})
Faces = createTypeDa(\\"Faces\\", {new = true})
Vector3int16 = createTypeDa(\\"Vector3int16\\", {new = true})
Vector2int16 = createTypeDa(\\"Vector2int16\\", {new = true})
CatalogSearchParams = createTypeDa(\\"CatalogSearchParams\\", {new = true})
DateTime = {
    now = function()
        return DateTime.fromUnixTimestamp(os.time())
    end,
    fromUnixTimestamp = function(ts)
        ts = toNumberFunction(ts) or 0
        local dt = setmetatable({UnixTimestamp = ts, UnixTimestampMillis = ts * 1000}, {
            __typeof = \\"DateTime\\",
            __index = function(self, key)
                if key == \\"UnixTimestamp\\" then return ts end
                if key == \\"UnixTimestampMillis\\" then return ts * 1000 end
                if key == \\"FormatUniversalTime\\" then
                    return function(self2, fmt, locale)
                        -- convert unix timestamp to date components
                        local t = os.date(\\"!*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"FormatLocalTime\\" then
                    return function(self2, fmt, locale)
                        local t = os.date(\\"*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"ToIsoDate\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return string.format(\\"%04d-%02d-%02dT%02d:%02d:%02dZ\\", t.year, t.month, t.day, t.hour, t.min, t.sec)
                    end
                end
                if key == \\"ToUniversalTime\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return {Year=t.year,Month=t.month,Day=t.day,Hour=t.hour,Minute=t.min,Second=t.sec,Millisecond=0}
                    end
                end
            end,
        })
        return dt
    end,
    fromUnixTimestampMillis = function(ms)
        return DateTime.fromUnixTimestamp(math.floor((toNumberFunction(ms) or 0) / 1000))
    end,
    fromIsoDate = function(iso)
        return DateTime.fromUnixTimestamp(0)
    end,
}
Random = {new = function(seed)
        local obj = {}
        function obj:NextNumber(min, max) return (min or 0) + 0.5 * ((max or 1) - (min or 0)) end
        function obj:NextInteger(min, max) return math.floor((min or 1) + 0.5 * ((max or 100) - (min or 1))) end
        function obj:NextUnitVector() return Vector3.new(0.577, 0.577, 0.577) end
        function obj:Shuffle(tab) return tab end
        function obj:Clone() return Random.new() end
        return obj
    end}
setmetatable(Random, {__call = function(_, seed) return _.new(seed) end})
Enum = createProxyObject(\\"Enum\\", true)
local enumMeta = debugLibrary.getmetatable(Enum)
enumMeta.__index = function(_, key)
    if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
    local enumName = \\"Enum.\\" .. formatValue(key)
    if not _at.enum[enumName] then
        local enumProxy = createProxyObject(enumName, false)
        dumperState.registry[enumProxy] = enumName
        _at.enum[enumName] = enumProxy
    end
    return _at.enum[enumName]
end
Instance = {new = function(className, parent)
        local name = formatValue(className)
        local _validClasses = {
            Part=1,MeshPart=1,UnionOperation=1,SpecialMesh=1,BlockMesh=1,CylinderMesh=1,
            Model=1,Folder=1,Tool=1,LocalScript=1,Script=1,ModuleScript=1,
            RemoteEvent=1,RemoteFunction=1,BindableEvent=1,BindableFunction=1,
            Frame=1,ScreenGui=1,SurfaceGui=1,BillboardGui=1,TextLabel=1,TextButton=1,
            TextBox=1,ImageLabel=1,ImageButton=1,ScrollingFrame=1,ViewportFrame=1,
            UIListLayout=1,UIGridLayout=1,UITableLayout=1,UIPadding=1,UICorner=1,
            UIStroke=1,UIScale=1,UIAspectRatioConstraint=1,UISizeConstraint=1,
            UITextSizeConstraint=1,UIFlexItem=1,UIGradient=1,UIPageLayout=1,
            Humanoid=1,HumanoidDescription=1,Animator=1,Animation=1,
            Sound=1,SoundGroup=1,Attachment=1,Motor6D=1,Weld=1,WeldConstraint=1,
            BallSocketConstraint=1,HingeConstraint=1,SpringConstraint=1,RodConstraint=1,
            RopeConstraint=1,AlignPosition=1,AlignOrientation=1,
            ForceField=1,Decal=1,Texture=1,SelectionBox=1,SelectionSphere=1,
            PointLight=1,SpotLight=1,SurfaceLight=1,Sky=1,Atmosphere=1,Clouds=1,
            Beam=1,Trail=1,ParticleEmitter=1,Fire=1,Smoke=1,Sparkles=1,
            Camera=1,Backpack=1,Hat=1,Accessory=1,Shirt=1,Pants=1,ShirtGraphic=1,
            CharacterMesh=1,BodyColors=1,
            IntValue=1,StringValue=1,BoolValue=1,NumberValue=1,Vector3Value=1,
            CFrameValue=1,Color3Value=1,ObjectValue=1,RayValue=1,BrickColorValue=1,
            ClickDetector=1,ProximityPrompt=1,Dialog=1,DialogChoice=1,
            SpawnLocation=1,SeatPart=1,VehicleSeat=1,
            WedgePart=1,CornerWedgePart=1,TrussPart=1,
            IntersectOperation=1,NegateOperation=1,
            PathfindingLink=1,PathfindingModifier=1,
            Configuration=1,LocalizationTable=1,
            NoCollisionConstraint=1,RigidConstraint=1,
            EditableMesh=1,EditableImage=1,
            LinearVelocity=1,AngularVelocity=1,LineForce=1,VectorForce=1,Torque=1,
            SurfaceAppearance=1,SpecialMesh=1,SelectionBox=1,
        }
        if not _validClasses[name] then
            errorFunction(\\"Unable to create an Instance of type \\\"\\" .. name .. \\"\\\"\\", 2)
        end
        local proxy = createProxyObject(name, false)
        local varName = registerVariable(proxy, name)
        -- class-specific default properties
        local _classDefaults = {
            SkateboardController = {Steer=0, Throttle=0},
            BallSocketConstraint = {LimitsEnabled=false, UpperAngle=45, TwistLimitsEnabled=false, TwistLowerAngle=-45, TwistUpperAngle=45, MaxFrictionTorque=0, Restitution=0},
            HingeConstraint     = {LimitsEnabled=false, UpperAngle=45, LowerAngle=-45, AngularVelocity=0, MotorMaxTorque=0, Restitution=0},
            SpringConstraint    = {Coilcount=5, Damping=1, FreeLength=5, LimitsEnabled=false, MaxLength=5, MinLength=0, Stiffness=100, Visible=false},
            RodConstraint       = {Length=5, LimitAngle0=0, LimitAngle1=0},
            RopeConstraint      = {Length=5},
            PrismaticConstraint = {LimitsEnabled=false, UpperLimit=5, LowerLimit=0, Velocity=0},
            TorsionSpringConstraint = {Damping=1, Stiffness=100, Restitution=0},
            WeldConstraint      = {},
            Motor6D             = {CurrentAngle=0, DesiredAngle=0, MaxVelocity=0},
            ForceField          = {Visible=true},
            Sound               = {Volume=0.5, PlaybackSpeed=1, TimePosition=0, IsPlaying=false, IsPaused=false, Looped=false, RollOffMaxDistance=10000, RollOffMinDistance=10},
            ScreenGui           = {Enabled=true, DisplayOrder=0, IgnoreGuiInset=false, ResetOnSpawn=true},
            Frame               = {BackgroundTransparency=0, BorderSizePixel=1, Visible=true, ZIndex=1, LayoutOrder=0},
            TextLabel           = {Text=\\"\\", TextTransparency=0, TextSize=14, TextWrapped=false, RichText=false, BackgroundTransparency=0, Visible=true, ZIndex=1},
            TextButton          = {Text=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, Modal=false},
            TextBox             = {Text=\\"\\", PlaceholderText=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, ClearTextOnFocus=true},
            ImageLabel          = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            ImageButton         = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            Part                = {Anchored=false, CanCollide=true, Locked=false, Transparency=0, Reflectance=0, Mass=1},
            MeshPart            = {Anchored=false, CanCollide=true, Transparency=0},
            Humanoid            = {Health=100, MaxHealth=100, WalkSpeed=16, JumpPower=50, JumpHeight=7.2, HipHeight=2, AutoRotate=true, PlatformStand=false},
            RemoteEvent         = {},
            RemoteFunction      = {},
            BindableEvent       = {},
            BindableFunction    = {},
            Animator            = {},
            LocalizationTable   = {SourceLocaleId=\\"en-us\\"},
            Animation           = {AnimationId=\\"\\"},
            Attachment          = {},
            AlignPosition       = {RigidityEnabled=false, MaxForce=1e6, MaxVelocity=1e6, Responsiveness=200},
            AlignOrientation    = {RigidityEnabled=false, MaxTorque=1e6, MaxAngularVelocity=1e6, Responsiveness=200},
            LinearVelocity      = {MaxForce=0, VectorVelocity=nil, VelocityConstraintMode=nil, Attachment0=nil},
            SurfaceAppearance   = {ColorMap=nil, NormalMap=nil, RoughnessMap=nil, MetalnessMap=nil},
        }
        local defaults = _classDefaults[name] or {}
        defaults.ClassName = name
        defaults.Name = name
        defaults.Archivable = true
        dumperState.property_store[proxy] = defaults
        if parent then
            local parentPath = dumperState.registry[parent] or serializeValue(parent)
            emitOutput(string.format(\\"local %s = Instance.new(%s, %s)\\", varName, formatStringLiteral(name), parentPath))
            _setParent(proxy, parent)
        else
            emitOutput(string.format(\\"local %s = Instance.new(%s)\\", varName, formatStringLiteral(name)))
        end
        return proxy
    end}
game = createProxyObject(\\"game\\", true)
workspace = createProxyObject(\\"workspace\\", true)
script = createProxyObject(\\"script\\", true)
dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
local function seedCoreRobloxInstances()
    dumperState.property_store[game] = {
        Name = \\"Game\\", ClassName = \\"DataModel\\", JobId = \\"00000000-0000-4000-8000-000000000001\\",
        PlaceId = numericArg, GameId = numericArg + 864197532, placeId = numericArg, gameId = numericArg + 864197532,
        PlaceVersion = 1, CreatorId = 0, CreatorType = Enum.CreatorType.User
    }
    dumperState.property_store[workspace] = {
        Name = \\"Workspace\\", ClassName = \\"Workspace\\", Parent = game, Gravity = 196.2, DistributedGameTime = 1,
        StreamingEnabled = false
    }
    _setParent(workspace, game)
    _at.svcCache.Workspace = workspace

    local players = _at.svcCache.Players or createProxyObject(\\"Players\\", false, game)
    _at.svcCache.Players = players
    dumperState.registry[players] = \\"Players\\"
    dumperState.property_store[players] = {Name = \\"Players\\", ClassName = \\"Players\\", Parent = game, MaxPlayers = 12, RespawnTime = 5}
    _setParent(players, game)

    local lp = _at.localPlayer or createProxyObject(\\"LocalPlayer\\", false, players)
    _at.localPlayer = lp
    dumperState.registry[lp] = \\"LocalPlayer\\"
    dumperState.property_store[lp] = {
        Name = \\"Player\\", ClassName = \\"Player\\", Parent = players, UserId = 1, DisplayName = \\"Player\\",
        MembershipType = Enum.MembershipType.None, FollowUserId = 0, AccountAge = 1000,
        CameraMinZoomDistance = 0, CameraMaxZoomDistance = 400,
        AutoJumpEnabled = true, Neutral = true, Team = nil, LocaleId = \\"en-us\\",
        SimulationRadius = 0, MaxSimulationRadius = 0,
    }
    _setParent(lp, players)

    local function ensureChild(parent, name, className, props)
        local child = createProxyObject(name, false, parent)
        dumperState.registry[child] = name
        props = props or {}
        props.Name = props.Name or name
        props.ClassName = props.ClassName or className or name
        props.Parent = parent
        dumperState.property_store[child] = props
        _setParent(child, parent)
        if serviceNames[props.ClassName] then
            _at.svcCache[props.ClassName] = child
        end
        return child
    end

    ensureChild(lp, \\"PlayerGui\\", \\"PlayerGui\\")
    ensureChild(lp, \\"Backpack\\", \\"Backpack\\")
    local playerScripts = ensureChild(lp, \\"PlayerScripts\\", \\"PlayerScripts\\")
    ensureChild(playerScripts, \\"PlayerModule\\", \\"ModuleScript\\")
    ensureChild(playerScripts, \\"RbxCharacterSounds\\", \\"LocalScript\\")
    ensureChild(workspace, \\"Camera\\", \\"Camera\\", {
        CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080),
        CameraType = Enum.CameraType.Custom, NearPlaneZ = -0.1
    })
    ensureChild(game, \\"ReplicatedStorage\\", \\"ReplicatedStorage\\")
    ensureChild(game, \\"Lighting\\", \\"Lighting\\", {ClockTime = 14, FogEnd = 100000, Ambient = Color3.fromRGB(128, 128, 128), OutdoorAmbient = Color3.fromRGB(128, 128, 128)})
    ensureChild(game, \\"SoundService\\", \\"SoundService\\", {RolloffScale = 1, AmbientReverb = Enum.ReverbType.NoReverb})
    ensureChild(game, \\"RunService\\", \\"RunService\\")
    ensureChild(game, \\"TweenService\\", \\"TweenService\\")
    ensureChild(game, \\"HttpService\\", \\"HttpService\\", {HttpEnabled = false})
    local networkClient = ensureChild(game, \\"NetworkClient\\", \\"NetworkClient\\")
    ensureChild(networkClient, \\"ClientReplicator\\", \\"ClientReplicator\\")
    local ugc = ensureChild(game, \\"Ugc\\", \\"Folder\\")
    ensureChild(ugc, \\"Chat\\", \\"Chat\\")
    ensureChild(game, \\"CollectionService\\", \\"CollectionService\\")
    ensureChild(game, \\"TextService\\", \\"TextService\\")
    ensureChild(game, \\"GuiService\\", \\"GuiService\\")
    ensureChild(game, \\"ContentProvider\\", \\"ContentProvider\\")
end
seedCoreRobloxInstances()
task = {
    wait = function(sec)
        if sec then emitOutput(string.format(\\"task.wait(%s)\\", serializeValue(sec))) else emitOutput(\\"task.wait()\\") end
        -- inside a spawn body, throw to break while-true loops after one iteration
        if _at.spawnDepth and _at.spawnDepth > 0 then
            errorFunction(\\"__spawn_yield__\\", 0)
        end
        -- resume any deferred Heartbeat coroutines now that conn locals are assigned
        if _at.pendingHeartbeat and #_at.pendingHeartbeat > 0 then
            local pending = _at.pendingHeartbeat
            _at.pendingHeartbeat = {}
            for _, co in ipairs(pending) do
                pcall(coroutine.resume, co)
            end
        end
        for inst, props in pairsFunction(dumperState.property_store) do
            if props.ClassName == \\"Part\\" and props.Anchored == false and _at.vectors[props.Position] then
                local v = _at.vectors[props.Position]
                props.Position = Vector3.new(v.x, v.y - 1, v.z)
            end
        end
        return sec or 0.03, osLibrary.clock()
    end,
    spawn = function(func, ...)
        local args = {...}
        emitOutput(\\"task.spawn(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        elseif typeFunction(func) == \\"thread\\" then
            xpcallFunction( function() coroutine.resume(func, table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        local co = coroutine.create(function() end)
        _at.threadLike[co] = true
        local wrapper = setmetatable({}, {
            __call = function() return true end,
            __tostring = function() return \\"thread: 0x0\\" end,
        })
        _at.threadLike[wrapper] = true
        return wrapper
    end,
    delay = function(sec, func, ...)
        local args = {...}
        emitOutput(string.format(\\"task.delay(%s, function()\\", serializeValue(sec or 0)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    defer = function(func, ...)
        local args = {...}
        emitOutput(\\"task.defer(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    cancel = function(thread) emitOutput(\\"task.cancel(thread)\\") end,
    synchronize = function() emitOutput(\\"task.synchronize()\\") end,
    desynchronize = function() emitOutput(\\"task.desynchronize()\\") end
}
wait = function(sec)
    if sec then emitOutput(string.format(\\"wait(%s)\\", serializeValue(sec))) else emitOutput(\\"wait()\\") end
    task.wait(sec)
    return sec or 0.03, osLibrary.clock()
end
delay = function(sec, func)
    emitOutput(string.format(\\"delay(%s, function()\\", serializeValue(sec or 0)))
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then xpcallFunction(func, function() end) end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
spawn = function(func)
    emitOutput(\\"spawn(function()\\")
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then
        -- limit spawn bodies: run once then break out of any while true
        local _spawnDepth = (_at.spawnDepth or 0) + 1
        if _spawnDepth <= 2 then
            _at.spawnDepth = _spawnDepth
            xpcallFunction(func, function() end)
            _at.spawnDepth = _spawnDepth - 1
        end
    end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
tick = function() return osLibrary.time() end
time = function() return osLibrary.clock() end
elapsedTime = function() return osLibrary.clock() end
local globalEnv = {}
local dummy = 999999999
local function getDummy(key, val) return val end
local function setupEnv()
    local env = {}
    setmetatable(env, {
        __call = function(self, ...) return self end,
        __index = function(self, key)
            if _G[key] ~= nil then return getDummy(key, _G[key]) end
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            return nil
        end,
        __newindex = function(self, key, val)
            _G[key] = val
            globalEnv[key] = 0
            emitOutput(string.format(\\"_G.%s = %s\\", formatValue(key), serializeValue(val)))
        end
    })
    return env
end
_G.G = setupEnv()
_G.g = setupEnv()
_G.ENV = setupEnv()
_G.env = setupEnv()
_G.E = setupEnv()
_G.e = setupEnv()
_G.L = setupEnv()
_G.l = setupEnv()
_G.F = setupEnv()
_G.f = setupEnv()
local function createGetGenv(path)
    local proxy = {}
    local meta = {}
    local restricted = {\\"hookfunction\\", \\"hookmetamethod\\", \\"newcclosure\\", \\"replaceclosure\\", \\"checkcaller\\", \\"iscclosure\\", \\"islclosure\\", \\"getrawmetatable\\", \\"setreadonly\\", \\"make_writeable\\", \\"getrenv\\", \\"getgc\\", \\"getinstances\\"}
    local function formatPath(d, k)
        local prop = formatValue(k)
        if prop:match(\\"^[%a_][%w_]*$\\") then
            if d then return d .. \\".\\" .. prop end
            return prop
        else
            local escaped = prop:gsub(\\"'\\", \\"\\\\\\\\'\\")
            if d then return d .. \\"['\\" .. escaped .. \\"']\\" end
            return \\"['\\" .. escaped .. \\"']\\"
        end
    end
    meta.__index = function(_, key)
        if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
        return _G[key]
    end
    meta.__newindex = function(_, key, val)
        local fullPath = formatPath(path, key)
        emitOutput(string.format(\\"getgenv().%s = %s\\", fullPath, serializeValue(val)))
    end
    meta.__call = function() return proxy end
    meta.__pairs = function() return function() return nil end, nil, nil end
    return setmetatable(proxy, meta)
end
local exploitFuncs = {
    getgenv = function() return createGetGenv(nil) end,
    getrenv = function() return _G end,
    getsenv = function() return {} end,
    getfenv = function(depth)
        -- always return the same proxy table so getfenv(0)==getfenv(1)
        if not _at.fenvCache then
            _at.fenvCache = setmetatable({}, {
                __index = function(_, key)
                    if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
                    return _G[key]
                end,
                __newindex = function(_, k, v) rawset(_, k, v) end
            })
        end
        return _at.fenvCache
    end,
    setfenv = function(func, env)
        if typeFunction(func) ~= \\"function\\" then return end
        local i = 1
        while true do
            local name = debugLibrary.getupvalue(func, i)
            if name == \\"_ENV\\" then debugLibrary.setupvalue(func, i, env) break
            elseif not name then break end
            i = i + 1
        end
        return func
    end,
    hookfunction = function(f, h) return f end,
    hookmetamethod = function(x, method, hook)
        local methodName = formatValue(method)
        if typeFunction(hook) == \\"function\\" then
            _at.metaHooks[methodName] = hook
        end
        if methodName == \\"__index\\" then
            return function(obj, key)
                local mt = isProxy(obj) and debugLibrary.getmetatable(obj)
                if mt and typeFunction(mt.__index) == \\"function\\" then
                    local saved = _at.metaHooks[methodName]
                    _at.metaHooks[methodName] = nil
                    local ok, result = pcallFunction(mt.__index, obj, key)
                    _at.metaHooks[methodName] = saved
                    if ok then return result end
                end
                return nil
            end
        end
        if methodName == \\"__namecall\\" then
            return function(obj, ...)
                local methodToCall = _at.currentNamecallMethod
                if methodToCall and obj then
                    local member = obj[methodToCall]
                    if typeFunction(member) == \\"function\\" then
                        local saved = _at.metaHooks[methodName]
                        _at.metaHooks[methodName] = nil
                        local ok, result = pcallFunction(member, obj, ...)
                        _at.metaHooks[methodName] = saved
                        if ok then return result end
                    end
                end
                return nil
            end
        end
        return function() end
    end,
    getrawmetatable = function(x)
        if isProxy(x) then
            -- all Instance proxies share ONE metatable so rawequal(mt1,mt2)==true
            if not _at.sharedInstanceMeta then
                local mt = {}
                -- __index must be a C function so debug.getinfo says what==\\"C\\"
                -- use a newproxy userdata with a C-backed metatable trick:
                -- we tag a wrapper as cclosure so getinfo returns \\"C\\"
                local indexFn = function() end
                if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
                _at.cclosureSet[indexFn] = true
                mt.__index = indexFn
                mt.__newindex = function() end
                mt.__namecall = function() end
                mt.__len = function() return 0 end
                mt.__tostring = function() return \\"Instance\\" end
                _at.sharedInstanceMeta = mt
            end
            return _at.sharedInstanceMeta
        end
        return getmetatable(x) or {}
    end,
    setrawmetatable = function(x, mt) return x end,
    getnamecallmethod = function() return _at.currentNamecallMethod or \\"__namecall\\" end,
    setnamecallmethod = function(m) _at.currentNamecallMethod = formatValue(m) end,
    checkcaller = function() return true end,
    islclosure = function(f)
        if isProxy(f) then return false end
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return false end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return false end
        return false
    end,
    iscclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return true end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return true end
        return false
    end,
    newcclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return f end
        if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
        local wrapper = function(...) return f(...) end
        _at.cclosureSet[wrapper] = true
        return wrapper
    end,
    clonefunction = function(f) return f end,
    request = function(req)
        emitOutput(string.format(\\"request(%s)\\", serializeValue(req)))
        table.insert(dumperState.string_refs, {value = req.Url or req.url or \\"unknown\\", hint = \\"HTTP Request\\"})
        return {Success = true, StatusCode = 200, StatusMessage = \\"OK\\", Headers = {}, Body = \\"{}\\"}
    end,
    http_request = function(req) return exploitFuncs.request(req) end,
    syn = {request = function(req) return exploitFuncs.request(req) end},
    http = {request = function(req) return exploitFuncs.request(req) end},
    HttpPost = function(url, data)
        emitOutput(string.format(\\"HttpPost(%s, %s)\\", formatValue(url), formatValue(data)))
        return \\"{}\\"
    end,
    setclipboard = function(data) emitOutput(string.format(\\"setclipboard(%s)\\", serializeValue(data))) end,
    getclipboard = function() return '\\"' end,
    identifyexecutor = function() return \\"FlameDumperV1\\", \\"1.0\\" end,
    getexecutorname = function() return \\"FlameDumperV1\\" end,
    gethui = function()
        local hui = createProxyObject(\\"HiddenUI\\", false)
        registerVariable(hui, \\"HiddenUI\\")
        emitOutput(string.format(\\"local %s = gethui()\\", dumperState.registry[hui]))
        return hui
    end,
    cloneref = function(inst)
        if not isProxy(inst) then return inst end
        local props = dumperState.property_store[inst] or {}
        local className = props.ClassName or dumperState.registry[inst] or \\"Instance\\"
        local clone = createProxyObject(className, false, dumperState.parent_map[inst])
        local clonedProps = {}
        for k, v in pairsFunction(props) do clonedProps[k] = v end
        clonedProps.ClassName = clonedProps.ClassName or className
        clonedProps.Name = clonedProps.Name or props.Name or className
        dumperState.property_store[clone] = clonedProps
        dumperState.registry[clone] = (dumperState.registry[inst] or className) .. \\"_cloneref\\"
        _at.refBase[clone] = _at.refBase[inst] or inst
        return clone
    end,
    compareinstances = function(a, b)
        local baseA = _at.refBase[a] or a
        local baseB = _at.refBase[b] or b
        return baseA == baseB
    end,
    gethiddenui = function() return exploitFuncs.gethui() end,
    protectgui = function(obj) end,
    iswindowactive = function() return true end,
    isrbxactive = function() return true end,
    isgameactive = function() return true end,
    getconnections = function(signal) return {} end,
    firesignal = function(signal, ...) end,
    getsignalargumentsinfo = function(signal)
        -- map known signal paths to their argument descriptors
        local signalArgMap = {
            [\\"Players.PlayerAdded\\"]          = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerRemoving\\"]       = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerMembershipChanged\\"] = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Humanoid.Died\\"]                = {},
            [\\"Humanoid.HealthChanged\\"]       = {{Name=\\"health\\", Type=\\"number\\"}},
            [\\"Humanoid.StateChanged\\"]        = {{Name=\\"old\\", Type=\\"EnumItem\\"}, {Name=\\"new\\", Type=\\"EnumItem\\"}},
            [\\"BasePart.Touched\\"]             = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"BasePart.TouchEnded\\"]          = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"RunService.Heartbeat\\"]         = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.RenderStepped\\"]     = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.Stepped\\"]           = {{Name=\\"time\\", Type=\\"number\\"}, {Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"UserInputService.InputBegan\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputEnded\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputChanged\\"]= {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"RemoteEvent.OnClientEvent\\"]    = {{Name=\\"args\\", Type=\\"Tuple\\"}},
            [\\"BindableEvent.Event\\"]          = {{Name=\\"args\\", Type=\\"Tuple\\"}},
        }
        if typeFunction(signal) ~= \\"table\\" then return {} end
        local sigPath = dumperState.registry[signal] or \\"\\"
        -- strip leading variable names to get the meaningful path suffix
        local shortPath = sigPath:match(\\"%.(.+)$\\") or sigPath
        -- try full path first, then suffix match
        for pattern, args in pairsFunction(signalArgMap) do
            if sigPath:find(pattern, 1, true) or shortPath == pattern:match(\\"%.(.+)$\\") then
                return args
            end
        end
        -- generic fallback: return empty table (signal exists but unknown args)
        return {}
    end,
    fireclickdetector = function(detector, dist) end,
    fireproximityprompt = function(prompt) end,
    firetouchinterest = function(a, b, c) end,
    getinstances = function()
        local instances = {}
        for inst in pairsFunction(dumperState.property_store) do
            if isProxy(inst) and (dumperState.property_store[inst].ClassName or dumperState.registry[inst]) then
                table.insert(instances, inst)
            end
        end
        if #instances == 0 then table.insert(instances, game) end
        return instances
    end,
    getnilinstances = function() return {} end,
    getgc = function() return {} end,
    getscripts = function() return {} end,
    getrunningscripts = function()
        -- AT3: must include the Animate script from character, but NOT arbitrary LocalScript instances
        local result = {}
        if _at.animateScript then result[#result+1] = _at.animateScript end
        return result
    end,
    getloadedmodules = function() return {} end,
    getcallingscript = function() return script end,
    readfile = function(file)
        emitOutput(string.format(\\"readfile(%s)\\", formatStringLiteral(file)))
        return _at.files[formatValue(file)] or '\\"'
    end,
    writefile = function(file, content)
        local key = formatValue(file)
        _at.files[key] = formatValue(content)
        _at.files_hidden = _at.files_hidden or {}
        _at.files_hidden[key] = true  -- mark as hidden from listfiles
        emitOutput(string.format(\\"writefile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    appendfile = function(file, content)
        local name = formatValue(file)
        _at.files[name] = (_at.files[name] or \\"\\") .. formatValue(content)
        emitOutput(string.format(\\"appendfile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    loadfile = function(file) return function() return createProxyObject(\\"loaded_file\\", false) end end,
    listfiles = function(folder)
        local base = formatValue(folder or \\"\\")
        -- normalize: strip leading slash so \\"/\\" matches all files
        base = base:gsub(\\"^/+\\", \\"\\")
        local result = {}
        for name in pairsFunction(_at.folders) do
            if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
        end
        for name in pairsFunction(_at.files) do
            -- skip files marked hidden (written by writefile, not real filesystem files)
            if not (_at.files_hidden and _at.files_hidden[name]) then
                if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
            end
        end
        return result
    end,
    isfile = function(file) return _at.files[formatValue(file)] ~= nil end,
    isfolder = function(folder) return _at.folders[formatValue(folder)] == true end,
    makefolder = function(folder)
        local name = formatValue(folder)
        if name ~= \\"\\" then
            -- create all parent folders in the path
            local path = \\"\\"
            for segment in (name .. \\"/\\"):gmatch(\\"([^/]+)/\\") do
                path = path == \\"\\" and segment or (path .. \\"/\\" .. segment)
                _at.folders[path] = true
            end
        end
        emitOutput(string.format(\\"makefolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfolder = function(folder)
        local name = formatValue(folder)
        _at.folders[name] = nil
        emitOutput(string.format(\\"delfolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfile = function(file)
        _at.files[formatValue(file)] = nil
        emitOutput(string.format(\\"delfile(%s)\\", formatStringLiteral(file)))
    end,
    DrawingImmediate = (function()
        local function makePaint()
            local cbs = {}
            return {
                Connect = function(self, fn)
                    cbs[#cbs+1] = fn
                    -- return plain table so typeof(cn)==\\"table\\" passes the AT check
                    return {
                        Disconnect = function(self)
                            for i,v in ipairs(cbs) do if v==fn then table.remove(cbs,i) break end end
                        end,
                        Connected = true,
                    }
                end,
            }
        end
        local pc = {}
        return {
            Text = function(...) emitOutput(\\"DrawingImmediate.Text(...)\\") end,
            Line = function(...) emitOutput(\\"DrawingImmediate.Line(...)\\") end,
            Circle = function(...) emitOutput(\\"DrawingImmediate.Circle(...)\\") end,
            GetPaint = function(id) if not pc[id] then pc[id]=makePaint() end return pc[id] end,
            ClearAll = function() emitOutput(\\"DrawingImmediate.ClearAll()\\") end,
        }
    end)(),
    Drawing = {
        new = function(type)
            local t = formatValue(type)
            local proxy = createProxyObject(\\"Drawing_\\" .. t, false)
            registerVariable(proxy, t)
            _at.userdata[proxy] = \\"renderobj\\"
            emitOutput(string.format(\\"local %s = Drawing.new(%s)\\", dumperState.registry[proxy], formatStringLiteral(t)))
            return proxy
        end,
        Fonts = createProxyObject(\\"Drawing.Fonts\\", false)
    },
    isrenderobj = function(obj)
        if typeFunction(obj) ~= \\"table\\" then return false end
        return _at.userdata[obj] == \\"renderobj\\"
    end,
    crypt = {
        base64encode = function(s) return s end,
        base64decode = function(s) return s end,
        base64_encode = function(s) return s end,
        base64_decode = function(s) return s end,
        encrypt = function(s, k) return s end,
        decrypt = function(s, k) return s end,
        hash = function(s) return \\"hash\\" end,
        generatekey = function(len) return string.rep(\\"0\\", len or 32) end,
        generatebytes = function(len) return string.rep(\\"\\\\0\\", len or 16) end
    },
    base64_encode = function(s) return s end,
    base64_decode = function(s) return s end,
    base64encode = function(s) return s end,
    base64decode = function(s) return s end,
    mouse1click = function() emitOutput(\\"mouse1click()\\") end,
    mouse1press = function() emitOutput(\\"mouse1press()\\") end,
    mouse1release = function() emitOutput(\\"mouse1release()\\") end,
    mouse2click = function() emitOutput(\\"mouse2click()\\") end,
    mouse2press = function() emitOutput(\\"mouse2press()\\") end,
    mouse2release = function() emitOutput(\\"mouse2release()\\") end,
    mousemoverel = function(x, y) emitOutput(string.format(\\"mousemoverel(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousemoveabs = function(x, y) emitOutput(string.format(\\"mousemoveabs(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousescroll = function(delta) emitOutput(string.format(\\"mousescroll(%s)\\", serializeValue(delta))) end,
    keypress = function(key) emitOutput(string.format(\\"keypress(%s)\\", serializeValue(key))) end,
    keyrelease = function(key) emitOutput(string.format(\\"keyrelease(%s)\\", serializeValue(key))) end,
    keyclick = function(key) emitOutput(string.format(\\"keyclick(%s)\\", serializeValue(key))) end,
    isreadonly = function(t) return false end,
    setreadonly = function(t, val) return t end,
    make_writeable = function(t) return t end,
    make_readonly = function(t) return t end,
    getthreadidentity = function() return 7 end,
    setthreadidentity = function(id) end,
    getidentity = function() return 7 end,
    setidentity = function(id) end,
    getthreadcontext = function() return 7 end,
    setthreadcontext = function(id) end,
    getcustomasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getsynasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getinfo = function(func) return {source = \\"=\\", what = \\"Lua\\", name = \\"unknown\\", short_src = \\"dumper\\"} end,
    getconstants = function(func) return {} end,
    getupvalues = function(func) return {} end,
    getprotos = function(func) return {} end,
    getupvalue = function(func, i) return nil end,
    setupvalue = function(func, i, val) end,
    setconstant = function(func, i, val) end,
    getconstant = function(func, i) return nil end,
    getproto = function(func, i) return function() end end,
    setproto = function(func, i, f) end,
    getstack = function(level, i) return nil end,
    setstack = function(level, i, val) end,
    debug = {
        getinfo = function(func, ...)
            if func == print or func == _G.print or func == warn or func == _G.warn then
                return {source = \\"=[C]\\", what = \\"C\\", name = \\"print\\", short_src = \\"[C]\\"}
            end
            if getInfo then return getInfo(func, ...) end
            return {source = \\"=[C]\\", what = \\"C\\", short_src = \\"[C]\\"}
        end,
        getupvalue = debugLibrary.getupvalue or function() return nil end,
        setupvalue = debugLibrary.setupvalue or function() end,
        getmetatable = debugLibrary.getmetatable,
        setmetatable = debugLibrary.setmetatable or setmetatable,
        traceback = getTraceback or function() return '\\"' end,
        profilebegin = function() end,
        profileend = function() end,
        sethook = function() end
    },
    rconsoleprint = function(s) end,
    rconsoleclear = function() end,
    rconsolecreate = function() end,
    rconsoledestroy = function() end,
    rconsoleinput = function() return \\"\\" end,
    rconsoleinfo = function(s) end,
    rconsolewarn = function(s) end,
    rconsoleerr = function(s) end,
    rconsolename = function(name) end,
    printconsole = function(s) end,
    setfflag = function(flag, val) end,
    getfflag = function(flag) return \\"\\" end,
    setfpscap = function(cap) emitOutput(string.format(\\"setfpscap(%s)\\", serializeValue(cap))) end,
    getfpscap = function() return 60 end,
    isnetworkowner = function(part) return true end,
    gethiddenproperty = function(instance, prop)
        if not isProxy(instance) then return nil, false end
        local props = dumperState.property_store[instance]
        if props and props[prop] ~= nil then return props[prop], true end
        return nil, false
    end,
    sethiddenproperty = function(instance, prop, val)
        if isProxy(instance) then
            local props = dumperState.property_store[instance]
            if props then
                if prop == \\"DistributedGameTime\\" then
                    -- don't store the set value; just record a tick base from current real value
                    -- so subsequent reads keep ticking from where they were
                    if not _at._dgtClock then
                        _at._dgtBase = (props[prop] or 1)
                        _at._dgtClock = osLibrary.clock()
                    end
                    -- intentionally do NOT store val - real Roblox ignores the set
                else
                    props[prop] = val
                end
            end
        end
        emitOutput(string.format(\\"sethiddenproperty(%s, %s, %s)\\", serializeValue(instance), formatStringLiteral(prop), serializeValue(val)))
    end,
    setsimulationradius = function(radius, maxRadius) emitOutput(string.format(\\"setsimulationradius(%s%s)\\", serializeValue(radius), maxRadius and \\", \\" .. serializeValue(maxRadius) or \\"\\")) end,
    getspecialinfo = function(instance) return {} end,
    saveinstance = function(options) emitOutput(string.format(\\"saveinstance(%s)\\", serializeValue(options or {}))) end,
    decompile = function(script) return \\"-- decompiled\\" end,
    lz4compress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4compress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        local lenBytes = string.char(
            math.floor(#s / 16777216) % 256,
            math.floor(#s / 65536) % 256,
            math.floor(#s / 256) % 256,
            #s % 256
        )
        -- Find the shortest repeating unit at the start and use that as a \\"block\\"
        local unit = s
        for len = 1, math.floor(#s / 2) do
            local candidate = s:sub(1, len)
            local repeated = string.rep(candidate, math.floor(#s / len))
            local remainder = s:sub(#repeated + 1)
            if repeated .. remainder == s then
                unit = candidate
                break
            end
        end
        -- Encode as: magic + origLen + unitLen(2 bytes) + unit + count(2 bytes) + remainder
        local count = math.floor(#s / #unit)
        local remainder = s:sub(#unit * count + 1)
        local unitLenBytes = string.char(math.floor(#unit / 256) % 256, #unit % 256)
        local countBytes = string.char(math.floor(count / 256) % 256, count % 256)
        local remLenBytes = string.char(math.floor(#remainder / 256) % 256, #remainder % 256)
        return magic .. lenBytes .. unitLenBytes .. unit .. countBytes .. remLenBytes .. remainder
    end,
    lz4decompress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4decompress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        if #s < 12 or s:sub(1, 4) ~= magic then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local b1, b2, b3, b4 = s:byte(5), s:byte(6), s:byte(7), s:byte(8)
        local origLen = b1 * 16777216 + b2 * 65536 + b3 * 256 + b4
        local unitLenHi, unitLenLo = s:byte(9), s:byte(10)
        local unitLen = unitLenHi * 256 + unitLenLo
        if #s < 10 + unitLen + 4 then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local unit = s:sub(11, 10 + unitLen)
        local countHi, countLo = s:byte(11 + unitLen), s:byte(12 + unitLen)
        local count = countHi * 256 + countLo
        local remLenHi, remLenLo = s:byte(13 + unitLen), s:byte(14 + unitLen)
        local remLen = remLenHi * 256 + remLenLo
        local remainder = s:sub(15 + unitLen, 14 + unitLen + remLen)
        return (string.rep(unit, count) .. remainder):sub(1, origLen)
    end,
    MessageBox = function(text, caption, type) return 1 end,
    setwindowactive = function() end,
    setwindowtitle = function(title) end,
    queue_on_teleport = function(code) emitOutput(string.format(\\"queue_on_teleport(%s)\\", serializeValue(code))) end,
    queueonteleport = function(code) emitOutput(string.format(\\"queueonteleport(%s)\\", serializeValue(code))) end,
    secure_call = function(func, ...) return func(...) end,
    create_secure_function = function(func) return func end,
    isvalidinstance = function(instance) return instance ~= nil end,
    validcheck = function(instance) return instance ~= nil end
}
for name, func in pairsFunction(exploitFuncs) do
    _G[name] = func
end
local nativeBit32 = bit32
local bitLibrary = {}
local function toBit(n)
    n = (n or 0) % 4294967296
    if n >= 2147483648 then n = n - 4294967296 end
    return math.floor(n)
end
local function toU32(n) return math.floor((n or 0) % 4294967296) end

local function _band(a, b)
    if nativeBit32 then return nativeBit32.band(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 and b > 0 do
        if a % 2 == 1 and b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bor(a, b)
    if nativeBit32 then return nativeBit32.bor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 == 1 or b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bxor(a, b)
    if nativeBit32 then return nativeBit32.bxor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 ~= b % 2 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _lshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return toU32(toU32(n) * (2 ^ bits))
end
local function _rshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return math.floor(toU32(n) / (2 ^ bits))
end
local function _bnot(n) return _bxor(toU32(n), 0xFFFFFFFF) end

bitLibrary.tobit = toBit
bitLibrary.tohex = function(n, len)
    return string.format(\\"%0\\" .. (len or 8) .. \\"x\\", toU32(n))
end
bitLibrary.band = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _band(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bxor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bxor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bnot    = function(n) return toBit(_bnot(n or 0)) end
bitLibrary.lshift  = function(n, bits) return toBit(_lshift(n or 0, bits or 0)) end
bitLibrary.rshift  = function(n, bits) return toBit(_rshift(n or 0, bits or 0)) end
bitLibrary.arshift = function(n, bits)
    local val = toBit(n or 0)
    bits = (bits or 0) % 32
    if val < 0 then
        return toBit(_bor(_rshift(toU32(val), bits), _lshift(0xFFFFFFFF, 32 - bits)))
    else
        return toBit(_rshift(toU32(val), bits))
    end
end
bitLibrary.rol = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_lshift(n, bits), _rshift(n, 32 - bits)))
end
bitLibrary.ror = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_rshift(n, bits), _lshift(n, 32 - bits)))
end
bitLibrary.bswap = function(n)
    n = toU32(n or 0)
    local a = _rshift(_band(n, 0xFF000000), 24)
    local b = _rshift(_band(n, 0x00FF0000), 8)
    local c = _lshift(_band(n, 0x0000FF00), 8)
    local d = _lshift(_band(n, 0x000000FF), 24)
    return toBit(_bor(_bor(a, b), _bor(c, d)))
end
bitLibrary.countlz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    if _band(n, 0xFFFF0000) == 0 then count = count + 16; n = _lshift(n, 16) end
    if _band(n, 0xFF000000) == 0 then count = count + 8;  n = _lshift(n, 8)  end
    if _band(n, 0xF0000000) == 0 then count = count + 4;  n = _lshift(n, 4)  end
    if _band(n, 0xC0000000) == 0 then count = count + 2;  n = _lshift(n, 2)  end
    if _band(n, 0x80000000) == 0 then count = count + 1   end
    return count
end
bitLibrary.countrz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    while _band(n, 1) == 0 do n = _rshift(n, 1); count = count + 1 end
    return count
end
bitLibrary.lrotate = bitLibrary.rol
bitLibrary.rrotate = bitLibrary.ror
bitLibrary.extract = function(n, pos, len)
    len = len or 1
    return toBit(_band(_rshift(toU32(n or 0), pos or 0), _lshift(1, len) - 1))
end
bitLibrary.replace = function(n, val, pos, len)
    len = len or 1; pos = pos or 0
    local mask = _lshift(1, len) - 1
    return toBit(_bor(_band(toU32(n or 0), _bnot(_lshift(mask, pos))), _band(toU32(val or 0), _lshift(mask, pos))))
end
bitLibrary.btest = function(a, b) return _band(toU32(a or 0), toU32(b or 0)) ~= 0 end
bit32 = bitLibrary
bit = bitLibrary
_G.bit = bitLibrary
_G.bit32 = bitLibrary
table.getn = table.getn or function(t) return #t end
table.foreach = table.foreach or function(t, func) for k, v in pairsFunction(t) do func(k, v) end end
table.foreachi = table.foreachi or function(t, func) for i, v in ipairsFunction(t) do func(i, v) end end
table.find = table.find or function(t, value, init)
    for i = (init or 1), #t do
        if t[i] == value then return i end
    end
    return nil
end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairsFunction(t) do out[k] = v end
    return out
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function(t) return false end
table.clear = table.clear or function(t) for k in pairsFunction(t) do t[k] = nil end end
table.find = table.find or function(t, val, init)
    for i = init or 1, #t do
        if t[i] == val then return i end
    end
    return nil
end
table.clear = table.clear or function(t)
    for k in pairs(t) do t[k] = nil end
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function() return false end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairs(t) do out[k] = v end
    return out
end
table.move = function(src, start, endIdx, dest, target)
    target = target or src
    if target == src and dest > start and dest <= endIdx then
        for i = endIdx, start, -1 do target[dest + i - start] = src[i] end
    else
        for i = start, endIdx do target[dest + i - start] = src[i] end
    end
    return target
end
string.split = string.split or function(str, sep)
    local t = {}
    for match in string.gmatch(str, \\"([^\\" .. (sep or \\"%s\\") .. \\"]+)\\") do table.insert(t, match) end
    return t
end
if not math.frexp then
    math.frexp = function(x)
        if x == 0 then return 0, 0 end
        local exp = math.floor(math.log(math.abs(x)) / math.log(2)) + 1
        local m = x / 2 ^ exp
        return m, exp
    end
end
if not math.ldexp then math.ldexp = function(m, e) return m * 2 ^ e end end
if not utf8 then
    utf8 = {}
    utf8.char = function(...)
        local args = {...}
        local chars = {}
        for _, byte in ipairsFunction(args) do table.insert(chars, string.char(byte % 256)) end
        return table.concat(chars)
    end
    utf8.len = function(s) return #s end
    utf8.codes = function(s)
        local i = 0
        return function() i = i + 1; if i <= #s then return i, string.byte(s, i) end end
    end
end
-- graphemes: bypass nested anti-tamper chain third[1][1][1][1][1][1](first, second)
utf8.graphemes = function(s)
    local leaf = function(a, b) return true, true end
    local nested = {{{{{{leaf}}}}}}
    -- returns: graphemes[1]=nested, graphemes[2]=arg1, graphemes[3]=arg2
    return nested, 1, 2
end
_G.utf8 = utf8
pairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return pairsFunction(t) end
    return function() return nil end, t, nil
end
ipairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return ipairsFunction(t) end
    return function() return nil end, t, 0
end
_G.pairs = pairs
_G.ipairs = ipairs
_G.math = math
_G.table = table
-- override string.dump to error on exploit/proxy functions like real Roblox
local _realStringDump = string.dump
string.dump = function(f, ...)
    if isProxy(f) then
        errorFunction(\\"unable to dump given function\\", 2)
    end
    -- exploit funcs registered in _G are not dumpable
    for name, val in pairsFunction(exploitFuncs) do
        if val == f then errorFunction(\\"unable to dump given function\\", 2) end
    end
    return _realStringDump(f, ...)
end
_G.string = string
_G.os = os
os.execute = function() return nil end
os.exit = function() return nil end
os.remove = function() return nil, \\"disabled\\" end
os.rename = function() return nil, \\"disabled\\" end
_G.coroutine = coroutine
_G.io = nil
_G.debug = exploitFuncs.debug
_G._realSetHook = setHook
_G.utf8 = utf8
_G.next = next
_G.tostring = tostring
_G.tonumber = tonumber
_G.getmetatable = getmetatable
_G.setmetatable = setmetatable
_G.pcall = function(f, ...)
    local results = {pcallFunction(f, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.xpcall = function(f, errFunc, ...)
    local function wrapper(err)
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then return err end
        if errFunc then return errFunc(err) end
        return err
    end
    local results = {xpcallFunction(f, wrapper, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.error = errorFunction
if _G.originalError == nil then _G.originalError = errorFunction end
_G.assert = assert
_G.select = select
_G.type = typeFunction
_G.rawget = rawget
_G.rawset = rawset
_G.rawequal = rawEqualFunction
_G.rawlen = rawlen or function(t) return #t end
_G.unpack = table.unpack or unpack
_G.pack = table.pack or function(...) return {n = select(\\"#\\", ...), ...} end
_G.task = task
_G.wait = wait
_G.Wait = wait
_G.delay = delay
_G.Delay = delay
_G.spawn = spawn
_G.Spawn = spawn
_G.tick = tick
_G.time = time
_G.elapsedTime = elapsedTime
_G.game = game
_G.Game = game
_G.workspace = workspace
_G.Workspace = workspace
_G.script = script
_G.Enum = Enum
_G.Instance = Instance
_G.Random = Random
_G.Vector3 = Vector3
_G.Vector2 = Vector2
_G.CFrame = CFrame
_G.Color3 = Color3
_G.BrickColor = BrickColor
_G.UDim = UDim
_G.UDim2 = UDim2
_G.TweenInfo = TweenInfo
_G.Rect = Rect
_G.Region3 = Region3
_G.Region3int16 = Region3int16
_G.Ray = Ray
_G.NumberRange = NumberRange
_G.NumberSequence = NumberSequence
_G.NumberSequenceKeypoint = NumberSequenceKeypoint
_G.ColorSequence = ColorSequence
_G.ColorSequenceKeypoint = ColorSequenceKeypoint
_G.PhysicalProperties = PhysicalProperties
_G.Font = Font
_G.RaycastParams = RaycastParams
_G.OverlapParams = OverlapParams
_G.PathWaypoint = PathWaypoint
_G.Axes = Axes
_G.Faces = Faces
_G.Vector3int16 = Vector3int16
_G.Vector2int16 = Vector2int16
_G.CatalogSearchParams = CatalogSearchParams
_G.DateTime = DateTime
settings = function()
    local enumKey = \\"Enum.QualityLevel.Automatic\\"
    if not _at.enum[enumKey] then
        local p = createProxyObject(enumKey, false)
        dumperState.registry[p] = enumKey
        _at.enum[enumKey] = p
    end
    local qualityProxy = _at.enum[enumKey]
    return {
        Rendering = {QualityLevel = qualityProxy, FrameRateManager = 0, EagerBulkExecution = false},
        Studio    = {},
        Network   = {IncomingReplicationLag = 0},
        Physics   = {PhysicsEnvironmentalThrottle = createProxyObject(\\"Enum.EnviromentalPhysicsThrottle.DefaultAuto\\", false)},
    }
end
_G.settings = settings
getmetatable = function(x)
    if _at.userdata[x] then return getMetatableFunction(x) end
    if isProxy(x) then return \\"The metatable is locked\\" end
    return getMetatableFunction(x)
end
_G.getmetatable = getmetatable
type = function(x)
    if _at.threadLike[x] then return \\"thread\\" end
    if _at.userdata[x] then return \\"userdata\\" end
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then return \\"userdata\\" end
    return typeFunction(x)
end
_G.type = type
buffer = {
    create = function(size)
        local b = {}
        _at.buffers[b] = string.rep(\\"\0\\", size or 0)
        return b
    end,
    fromstring = function(s)
        local b = {}
        _at.buffers[b] = formatValue(s)
        return b
    end,
    tostring = function(b)
        return _at.buffers[b] or \\"\\"
    end,
    len = function(b)
        return #(_at.buffers[b] or \\"\\")
    end,
    copy = function(dst, dstOffset, src, srcOffset, count)
        local srcData = _at.buffers[src] or \\"\\"
        local dstData = _at.buffers[dst] or \\"\\"
        srcOffset = (srcOffset or 0) + 1
        dstOffset = (dstOffset or 0) + 1
        local chunk = srcData:sub(srcOffset, count and srcOffset + count - 1 or -1)
        local before = dstData:sub(1, dstOffset - 1)
        local after  = dstData:sub(dstOffset + #chunk)
        _at.buffers[dst] = before .. chunk .. after
    end,
    fill = function(b, offset, value, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        count  = count or (#data - offset + 1)
        local fill = string.rep(string.char(value % 256), count)
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + count)
        _at.buffers[b] = before .. fill .. after
    end,
    writestring = function(b, offset, s, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        s = formatValue(s)
        if count then s = s:sub(1, count) end
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + #s)
        _at.buffers[b] = before .. s .. after
    end,
    readstring = function(b, offset, len)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        return data:sub(offset, len and offset + len - 1 or -1)
    end,
    writeu8  = function(b, offset, v) local d=_at.buffers[b] or\\"\\"; offset=(offset or 0)+1; _at.buffers[b]=d:sub(1,offset-1)..string.char(v%256)..d:sub(offset+1) end,
    readu8   = function(b, offset) local d=_at.buffers[b] or\\"\\"; return string.byte(d,(offset or 0)+1) or 0 end,
    writeu16 = function(b, offset, v) offset=(offset or 0); buffer.writeu8(b,offset,v%256); buffer.writeu8(b,offset+1,math.floor(v/256)%256) end,
    readu16  = function(b, offset) return buffer.readu8(b,offset) + buffer.readu8(b,(offset or 0)+1)*256 end,
    writeu32 = function(b, offset, v) offset=(offset or 0); for i=0,3 do buffer.writeu8(b,offset+i,math.floor(v/(256^i))%256) end end,
    readu32  = function(b, offset) local v=0; for i=0,3 do v=v+buffer.readu8(b,(offset or 0)+i)*(256^i) end; return v end,
    writei8  = function(b, offset, v) buffer.writeu8(b, offset, v < 0 and v+256 or v) end,
    readi8   = function(b, offset) local v=buffer.readu8(b,offset); return v>=128 and v-256 or v end,
    writei16 = function(b, offset, v) buffer.writeu16(b, offset, v < 0 and v+65536 or v) end,
    readi16  = function(b, offset) local v=buffer.readu16(b,offset); return v>=32768 and v-65536 or v end,
    writei32 = function(b, offset, v) buffer.writeu32(b, offset, v < 0 and v+4294967296 or v) end,
    readi32  = function(b, offset) local v=buffer.readu32(b,offset); return v>=2147483648 and v-4294967296 or v end,
    writef32 = function(b, offset, v) buffer.writeu32(b, offset, math.floor(math.abs(v)*1000)%4294967296) end,
    readf32  = function(b, offset) return buffer.readu32(b,offset)/1000 end,
    writef64 = function(b, offset, v) buffer.writeu32(b, offset, 0); buffer.writeu32(b, (offset or 0)+4, math.floor(math.abs(v)*1000)%4294967296) end,
    readf64  = function(b, offset) return buffer.readu32(b,(offset or 0)+4)/1000 end,
}
_G.buffer = buffer
typeof = function(x)
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then
        if _at.typeOverride[x] then return _at.typeOverride[x] end
        local regName = dumperState.registry[x]
        if regName then
            if regName == \\"Enum\\" then return \\"Enums\\" end
            if regName:match(\\"^Enum%.[^%.]+$\\") then return \\"Enum\\" end
            if regName:match(\\"^Enum%.[^%.]+%.[^%.]+$\\") then return \\"EnumItem\\" end
            if regName:match(\\"Vector3\\") then return \\"Vector3\\" end
            if regName:match(\\"CFrame\\") then return \\"CFrame\\" end
            if regName:match(\\"Color3\\") then return \\"Color3\\" end
            if regName:match(\\"UDim\\") then return \\"UDim2\\" end
        end
        return \\"Instance\\"
    end
    if _at.threadLike[x] then return \\"thread\\" end
    local mt = getMetatableFunction(x)
    if mt and mt.__typeof then return mt.__typeof end
    return typeFunction(x) == \\"table\\" and \\"table\\" or typeFunction(x)
end
_G.typeof = typeof
newproxy = function(withMeta)
    local proxy = {}
    _at.userdata[proxy] = true
    if withMeta then
        setmetatable(proxy, {})
    end
    return proxy
end
_G.newproxy = newproxy
tonumber = function(x, base)
    if getProxyValue(x) ~= 0 then return 123456789 end
    return toNumberFunction(x, base)
end
_G.tonumber = tonumber
rawequal = function(a, b) return rawEqualFunction(a, b) end
_G.rawequal = rawequal
tostring = function(x)
    if isProxy(x) then
        local mt = getMetatableFunction(x)
        if mt and mt.__tostring then
            local ok, r = pcallFunction(mt.__tostring, x)
            if ok and r then return r end
        end
        local regName = dumperState.registry[x]
        return regName or \\"Instance\\"
    end
    local mt = getMetatableFunction(x)
    if mt and mt.__tostring then
        local ok, r = pcallFunction(mt.__tostring, x)
        if ok and r then return r end
    end
    return toStringFunction(x)
end
_G.tostring = tostring
dumperState.last_http_url = nil
loadstring = function(code, chunkName)
    if typeFunction(code) ~= \\"string\\" then return function() return createProxyObject(\\"loaded\\", false) end end
    local url = dumperState.last_http_url or code
    dumperState.last_http_url = nil
    local libName = nil
    local lowerCode = url:lower()
    local libs = {{pattern = \\"rayfield\\", name = \\"Rayfield\\"}, {pattern = \\"orion\\", name = \\"OrionLib\\"}, {pattern = \\"kavo\\", name = \\"Kavo\\"}, {pattern = \\"venyx\\", name = \\"Venyx\\"}, {pattern = \\"sirius\\", name = \\"Sirius\\"}, {pattern = \\"linoria\\", name = \\"Linoria\\"}, {pattern = \\"wally\\", name = \\"Wally\\"}, {pattern = \\"dex\\", name = \\"Dex\\"}, {pattern = \\"infinite\\", name = \\"InfiniteYield\\"}, {pattern = \\"hydroxide\\", name = \\"Hydroxide\\"}, {pattern = \\"simplespy\\", name = \\"SimpleSpy\\"}, {pattern = \\"remotespy\\", name = \\"RemoteSpy\\"}}
    for _, lib in ipairsFunction(libs) do if lowerCode:find(lib.pattern) then libName = lib.name; break end end
    if libName then
        local proxy = createProxyObject(libName, false)
        dumperState.registry[proxy] = libName
        dumperState.names_used[libName] = true
        if url:match(\\"^https?://\\") then emitOutput(string.format('local %s = loadstring(game:HttpGet(\\"%s\\"))()', libName, url)) end
        return function() return proxy end
    end
    if url:match(\\"^https?://\\") then
        local proxy = createProxyObject(\\"Library\\", false)
        emitOutput(string.format('local loadstring = loadstring(game:HttpGet(\\"%s\\"))()', url))
        return function() return proxy end
    end
    if code:match(\\"local%s+a%s*=%s*if%s+true%s+then\\") then return nil, \\"attempt to call a nil value\\" end
    if typeFunction(code) == \\"string\\" then code = processString(code) end
    local func, err = loadFunction(code)
    if func then return func end
    local proxy = createProxyObject(\\"LoadedChunk\\", false)
    return function() return proxy end
end
load = loadstring
_G.loadstring = loadstring
_G.load = loadstring
require = function(module)
    local modName = dumperState.registry[module] or serializeValue(module)
    local proxy = createProxyObject(\\"RequiredModule\\", false)
    local varName = registerVariable(proxy, \\"module\\")
    emitOutput(string.format(\\"local %s = require(%s)\\", varName, modName))
    return proxy
end
_G.require = require
print = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"print(%s)\\", table.concat(items, \\", \\")))
end
_G.print = print
warn = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"warn(%s)\\", table.concat(items, \\", \\")))
end
_G.warn = warn
-- Tag Roblox-like builtins as C closures so iscclosure() returns true for them
do
    if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
    local _cbuiltins = {
        print, warn, tick, time, elapsedTime, pcall, xpcall, error, assert,
        tostring, tonumber, type, typeof, rawget, rawset, rawequal, rawlen,
        setmetatable, getmetatable, ipairs, pairs, next, select, unpack,
        require, loadstring, load,
    }
    for _, fn in ipairs(_cbuiltins) do
        if typeFunction(fn) == \\"function\\" then
            _at.cclosureSet[fn] = true
        end
    end
end
_G.shared = shared
local globalBase = _G
local globalMeta = setmetatable({}, {
    __index = function(tbl, key)
        if configuration.VERBOSE then printFunction(\\"[VERBOSE] Accessing field: \\" .. toStringFunction(key)) end
        local val = rawget(globalBase, key)
        if val == nil then val = rawget(_G, key) end
        if configuration.VERBOSE then
            if val ~= nil then
                if typeFunction(val) == \\"table\\" then printFunction(\\"[VERBOSE] Found global table: \\" .. toStringFunction(key))
                elseif typeFunction(val) == \\"function\\" then printFunction(\\"[VERBOSE] Found global function: \\" .. toStringFunction(key))
                else printFunction(\\"[VERBOSE] Found global value: \\" .. toStringFunction(key) .. \\" = \\" .. toStringFunction(val)) end
            else
                printFunction(\\"[VERBOSE] Missing field, providing dummy function: \\" .. toStringFunction(key))
                val = function() if configuration.VERBOSE then printFunction(\\"[Missing Function] Called: \\" .. toStringFunction(key) .. \\" with 0 arguments\\") end return nil end
            end
        end
        return val
    end,
    __newindex = function(tbl, key, val) rawset(globalBase, key, val) end
})
_G._G = globalMeta
function proxyTable.reset()
    dumperState = {output = {}, indent = 0, registry = {}, reverse_registry = {}, names_used = {}, parent_map = {}, property_store = {}, call_graph = {}, variable_types = {}, string_refs = {}, proxy_id = 0, callback_depth = 0, pending_iterator = false, last_http_url = nil, last_emitted_line = nil, repetition_count = 0, current_size = 0, limit_reached = false, ls_counter = 0, captured_constants = {}}
    _at.mem = {}
    _at.tags = {}
    _at.sigs = {}
    _at.acts = {}
    _at.json = {}
    _at.enum = {}
    _at.svcCache = {}
    _at.typeOverride = {}
    _at.connState = {}
    _at.pendingHeartbeat = {}
    _at.locEntries = {}
    _at.userdata = {}
    _at.localPlayer = nil
    setmetatable(_at.userdata, {__mode = \\"k\\"})
    _at.debugIds = {}
    setmetatable(_at.debugIds, {__mode = \\"k\\"})
    _at.debugIdCtr = 0
    uiCounters = {}
    game = createProxyObject(\\"game\\", true)
    workspace = createProxyObject(\\"workspace\\", true)
    script = createProxyObject(\\"script\\", true)
    Enum = createProxyObject(\\"Enum\\", true)
    shared = createProxyObject(\\"shared\\", true)
    dumperState.property_store[game] = {PlaceId = numericArg, GameId = numericArg, placeId = numericArg, gameId = numericArg}
    dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
    _G.game = game; _G.Game = game; _G.workspace = workspace; _G.Workspace = workspace; _G.script = script; _G.Enum = Enum; _G.shared = shared
    local meta = debugLibrary.getmetatable(Enum)
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
        local enumName = \\"Enum.\\" .. formatValue(key)
        if not _at.enum[enumName] then
            local enumProxy = createProxyObject(enumName, false)
            dumperState.registry[enumProxy] = enumName
            _at.enum[enumName] = enumProxy
        end
        return _at.enum[enumName]
    end
    seedCoreRobloxInstances()
    if type(_G._bypassOnReset) == \\"function\\" then
        local prevOutput = dumperState.output
        local prevOutputCount = #prevOutput
        local prevIndent = dumperState.indent
        local prevLast = dumperState.last_emitted_line
        local prevRep = dumperState.repetition_count
        local prevSize = dumperState.current_size
        local prevLimit = dumperState.limit_reached
        pcall(_G._bypassOnReset)
        for i = #prevOutput, prevOutputCount + 1, -1 do
            prevOutput[i] = nil
        end
        dumperState.output = prevOutput
        dumperState.indent = prevIndent
        dumperState.last_emitted_line = prevLast
        dumperState.repetition_count = prevRep
        dumperState.current_size = prevSize
        dumperState.limit_reached = prevLimit
    end
end
function proxyTable.get_output() return getFullOutput() end
function proxyTable.save(file) return saveToFile(file) end
function proxyTable.get_call_graph() return dumperState.call_graph end
function proxyTable.get_string_refs() return dumperState.string_refs end
function proxyTable.get_stats() return {total_lines = #dumperState.output, remote_calls = #dumperState.call_graph, suspicious_strings = #dumperState.string_refs, proxies_created = dumperState.proxy_id} end
local dumper = {callId = \\"LUASPLOIT_\\", binaryOperatorNames = {[\\"and\\"] = \\"AND\\", [\\"or\\"] = \\"OR\\", [\\">\\"] = \\"GT\\", [\\"<\\"] = \\"LT\\", [\\">=\\"] = \\"GE\\", [\\"<=\\"] = \\"LE\\", [\\"==\\"] = \\"EQ\\", [\\"~=\\"] = \\"NEQ\\", [\\"..\\"] = \\"CAT\\"}}
function dumper:hook(code) return self.callId .. code end
function dumper:process_expr(expr)
    if not expr then return \\"nil\\" end
    if typeFunction(expr) == \\"string\\" then return expr end
    local tag = expr.tag or expr.kind
    if tag == \\"number\\" or tag == \\"string\\" then
        local val = tag == \\"string\\" and string.format(\\"%q\\", expr.text) or (expr.value or expr.text)
        if configuration.CONSTANT_COLLECTION then return string.format(\\"%sGET(%s)\\", self.callId, val) end
        return val
    end
    if tag == \\"local\\" or tag == \\"global\\" then return (expr.name or expr.token).text
    elseif tag == \\"boolean\\" or tag == \\"bool\\" then return toStringFunction(expr.value)
    elseif tag == \\"binary\\" then
        local lhs = self:process_expr(expr.lhsoperand)
        local rhs = self:process_expr(expr.rhsoperand)
        local op = expr.operator.text
        local opName = self.binaryOperatorNames[op]
        if opName then return string.format(\\"%s%s(%s, %s)\\", self.callId, opName, lhs, rhs) end
        return string.format(\\"(%s %s %s)\\", lhs, op, rhs)
    elseif tag == \\"call\\" then
        local func = self:process_expr(expr.func)
        local args = {}
        for i, node in ipairsFunction(expr.arguments) do args[i] = self:process_expr(node.node or node) end
        return string.format(\\"%sCALL(%s, %s)\\", self.callId, func, table.concat(args, \\", \\"))
    elseif tag == \\"indexname\\" or tag == \\"index\\" then
        local exprStr = self:process_expr(expr.expression)
        local keyStr = tag == \\"indexname\\" and string.format(\\"%q\\", expr.index.text) or self:process_expr(expr.index)
        return string.format(\\"%sCHECKINDEX(%s, %s)\\", self.callId, exprStr, keyStr)
    end
    return \\"nil\\"
end
function dumper:process_statement(stmt)
    if not stmt then return \\"\\" end
    local tag = stmt.tag
    if tag == \\"local\\" or tag == \\"assign\\" then
        local vars, vals = {}, {}
        for _, node in ipairsFunction(stmt.variables or {}) do table.insert(vars, self:process_expr(node.node or node)) end
        for _, node in ipairsFunction(stmt.values or {}) do table.insert(vals, self:process_expr(node.node or node)) end
        return (tag == \\"local\\" and \\"local \\" or \\"\\") .. table.concat(vars, \\", \\") .. \\" = \\" .. table.concat(vals, \\", \\")
    elseif tag == \\"block\\" then
        local stmts = {}
        for _, s in ipairsFunction(stmt.statements or {}) do table.insert(stmts, self:process_statement(s)) end
        return table.concat(stmts, \\"; \\")
    end
    return self:process_expr(stmt) or \\"\\"
end
local function _loosePasteCode(code)
    if typeFunction(code) ~= \\"string\\" then return code end
    code = code:gsub(\\"```lua\\", \\"\\"):gsub(\\"```\\", \\"\\")
    return code
end
local function _loadLooseChunk(code, chunkName)
    local sanitized = processString(_loosePasteCode(code))
    local lines = {}
    sanitized:gsub(\\"([^\n]*)\n?\\", function(line)
        if line ~= \\"\\" or #lines == 0 or sanitized:sub(-1) == \\"\n\\" then table.insert(lines, line) end
    end)
    local skipped = {}
    for _ = 1, 400 do
        local current = table.concat(lines, \\"\n\\")
        local func, err = loadFunction(current, chunkName)
        if func then return func, nil, current, skipped end
        local lineNo = toNumberFunction(toStringFunction(err):match(\\"%]:(%d+):\\") or toStringFunction(err):match(\\":(%d+):\\"))
        if not lineNo or not lines[lineNo] or skipped[lineNo] then return nil, err, current, skipped end
        skipped[lineNo] = lines[lineNo]
        lines[lineNo] = \\"-- \\" .. lines[lineNo]
    end
    return nil, \\"too many invalid loose-paste lines\\", table.concat(lines, \\"\n\\"), skipped
end
function proxyTable.dump_file(inputPath, outputPath)
    proxyTable.reset()
    local file = ioLibrary.open(inputPath, \\"rb\\")
    if not file then
    printFunction(\\"error: cannot open input\\")
        return false
    end
    local code = file:read(\\"*a\\")
    file:close()
    printFunction(\\"input: normalize\\")
    local func, err, sanitized, skipped = _loadLooseChunk(code, \\"Obfuscated_Script\\")
    if not func then
        printFunction(\\"error: load \\" .. toStringFunction(err))
        return false
    end
    if skipped then
        local skippedCount = 0
        for _ in pairsFunction(skipped) do skippedCount = skippedCount + 1 end
        if skippedCount > 0 then printFunction(\\"input: skipped-lines=\\" .. toStringFunction(skippedCount)) end
    end
    local _SANDBOX_BLOCK = {
        io=true, os=true, debug=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true,
    }
    local _rawTb = debugLibrary and debugLibrary.traceback
    local _badTbWords = {
        \\"sandbox\\",\\"hook\\",\\"intercept\\",\\"mock\\",\\"proxy\\",\\"virtual_env\\",
        \\"decompil\\",\\"emulat\\",\\"simulat\\",\\"fake_\\",\\"getupval\\",\\"hookfunc\\",
        \\"replaceclos\\",\\"newcclos\\",\\"restorefunction\\",\\"bypass\\",\\"dumper\\",
    }
    local _tbWrapper = function(thread, msg, level)
        local ok, tb
        if _rawTb then
            if typeFunction(thread) == \\"thread\\" then
                ok, tb = pcallFunction(_rawTb, thread, msg, level)
            else
                ok, tb = pcallFunction(_rawTb, thread, msg)
            end
        end
        if not ok or typeFunction(tb) ~= \\"string\\" then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        local lines = {}
        for line in (tb .. \\"\n\\"):gmatch(\\"([^\n]*)\n\\") do
            local lo = line:lower()
            local bad = false
            for _, w in next, _badTbWords do
                if lo:find(w, 1, true) then bad = true; break end
            end
            if not bad then lines[#lines + 1] = line end
        end
        local cleaned = table.concat(lines, \\"\n\\")
        cleaned = cleaned:gsub(\\"%[([%w%+%/]+)%]\\", function(inner)
            if #inner + 2 < 10 then return \\"[RobloxGameScript]\\" end
            return \\"[\\" .. inner .. \\"]\\"
        end)
        if #cleaned < 20 then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        return cleaned
    end
    local _SAFE_DEBUG = {
        getinfo = function(func, ...)
            if typeFunction(func) == \\"number\\" then
                return nil
            end
            return {source = \\"=[C]\\", what = \\"C\\", name = \\"C function\\", short_src = \\"[C]\\"}
        end,
        traceback  = _tbWrapper,
        getupvalue = function(fn, i) return nil end,
    }
    local _SAFE_OS = {
        clock = function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end,
        time  = osLibrary.time,
        date  = osLibrary.date,
    }
    local env = setmetatable({
        _VERSION = \\"Luau\\",
        LuraphContinue = nil,
        __LC__ = function() end,
        script = script, game = game, workspace = workspace,
        io      = nil,
        os      = _SAFE_OS,
        debug   = _SAFE_DEBUG,
        error   = _origError,
        dofile  = nil,
        loadfile = nil,
        require = nil,
        package = nil,
        socket  = nil,
        ffi     = nil,
        collectgarbage = nil,
        newproxy = newproxy,
        -- hide _G metatable from scripts
        getmetatable = function(obj)
            if obj == _G or obj == env then return nil end
            if _at.userdata[obj] then return getMetatableFunction(obj) end
            if isProxy(obj) then return \\"The metatable is locked\\" end
            return getMetatableFunction(obj)
        end,
        LUASPLOIT_CHECKINDEX = function(tbl, key)
            local val = tbl[key]
            if typeFunction(val) == \\"table\\" and not dumperState.registry[val] then
                dumperState.ls_counter = dumperState.ls_counter + 1
                dumperState.registry[val] = \\"v\\" .. dumperState.ls_counter
            end
            return val
        end,
        LUASPLOIT_GET = function(v) return v end,
        LS_CALL = function(f, ...)
            if typeFunction(f) ~= \\"function\\" then return nil end
            return f(...)
        end,
        LS_NAMECALL = function(t, method, ...)
            if typeFunction(t) ~= \\"table\\" then return nil end
            if typeFunction(t[method]) ~= \\"function\\" then return nil end
            return t[method](t, ...)
        end,
        LUASPLOIT_CALL = function(f, ...) return f(...) end,
        LUASPLOIT_NAMECALL = function(t, method, ...) return t[method](t, ...) end,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end
    }, {
        __index = function(_, k)
            if _SANDBOX_BLOCK[k] then return nil end
            -- block dumper internal globals from leaking into script env
            if k == \\"LuraphContinue\\" or k == \\"__FLAMEDUMPER_REQUIRE_ONLY\\"
            or k == \\"proxyTable\\" or k == \\"dumperState\\" or k == \\"_at\\" then
                return nil
            end
            return _G[k]
        end,
        __newindex = _G
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, env)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, env) end
        end
    end
    printFunction(\\"vm: running\\")
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    local success, runErr = xpcallFunction(function() func() end, function(e) return toStringFunction(e) end)
    setHook()
    if not success and not toStringFunction(runErr):match(\\"TIMEOUT\\") then
        emitComment(\\"Runtime: \\" .. toStringFunction(runErr))
    end
    local saved = proxyTable.save(outputPath or configuration.OUTPUT_FILE)
    if saved then
        local stats = proxyTable.get_stats()
        printFunction(string.format(\\"done: lines=%d remotes=%d strings=%d\\",
            stats.total_lines, stats.remote_calls, stats.suspicious_strings))
    else
        printFunction(\\"error: write failed\\")
    end
    return saved
end
function proxyTable.dump_string(code, outputPath)
    proxyTable.reset()
    if code then code = processString(code) end
    local func, err = loadFunction(code)
    if not func then
        emitComment(\\"Load Error: \\" .. (err or \\"unknown\\"))
        if outputPath then proxyTable.save(outputPath) end
        return false, err
    end
    local _DS_BLOCK = {
        io=true, os=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true, debug=true,
    }
    local _DS_OS = { clock=function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end, time=osLibrary.time, date=osLibrary.date }
    local dsEnv = setmetatable({
        _VERSION=\\"Luau\\",
        io=nil, os=_DS_OS, debug=nil, dofile=nil, loadfile=nil,
        require=nil, package=nil, socket=nil, ffi=nil,
        collectgarbage=nil, newproxy=newproxy,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end,
    }, {
        __index = function(_, k)
            if _DS_BLOCK[k] then return nil end
            return _G[k]
        end,
        __newindex = _G,
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, dsEnv)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, dsEnv) end
        end
    end
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    xpcallFunction(function() func() end, function(e)
        emitComment(\\"Runtime: \\" .. toStringFunction(e))
    end)
    setHook()
    if outputPath then return proxyTable.save(outputPath) end
    return true, getFullOutput()
end
do
    local bypassPath = (arg and arg[0] and arg[0]:match(\\"^(.+[\\\\/])\\")) or \\"\\"
    local ok, err = pcall(dofile, bypassPath .. \\"bypass.lua\\")
    if not ok then
        local ok2 = pcall(dofile, \\"bypass.lua\\")
        if not ok2 then
            printFunction(\\"[dumper] bypass.lua not found, continuing without supplement\\")
        end
    end
end

_G.LuraphContinue = nil
if not rawget(_G, \\"__FLAMEDUMPER_REQUIRE_ONLY\\") then
    if arg and arg[1] then
        local success = proxyTable.dump_file(arg[1], arg[2])
        if success then end
    else
        local file = ioLibrary.open(\\"obfuscated.lua\\", \\"rb\\")
        if file then
            file:close()
            local success = proxyTable.dump_file(\\"obfuscated.lua\\")
            if success then
                printFunction(proxyTable.get_output())
            end
        else
            printFunction(\\"Usage: lua dumper.lua <input> [output] [key]\\")
        end
    end
end
return proxyTable
 (linedefined 4090)")
print("  Stack 3: local unpack = unpack or table.unpack
local warn = warn or function() end

local _origPcall = pcall
local _origXpcall = xpcall
local _origError = error

local debugLibrary = debug
_G._VERSION = \\"Luau\\"
local setHook = debug.sethook
local getInfo = debug.getinfo
local getTraceback = debug.traceback
local loadFunction = load
local loadStringFunction = loadstring or load
local pcallFunction = pcall
local xpcallFunction = xpcall
local errorFunction = error
local typeFunction = type
local getMetatableFunction = getmetatable
local rawEqualFunction = rawequal
local toStringFunction = tostring
local toNumberFunction = tonumber
local ioLibrary = io
local osLibrary = os
local pairsFunction = pairs
local ipairsFunction = ipairs
local tableUnpackFunction = table.unpack or unpack
local proxyTable = {}
proxyTable.__index = proxyTable
local configuration = {
    MAX_DEPTH = 15,
    MAX_TABLE_ITEMS = 150,
    OUTPUT_FILE = \\"dumped_output.lua\\",
    VERBOSE = false,
    TRACE_CALLBACKS = true,
    TIMEOUT_SECONDS = 6.67,
    MAX_REPEATED_LINES = 8,
    MIN_DEOBF_LENGTH = 150,
    MAX_OUTPUT_SIZE = 2 * 1024 * 1024,
    CONSTANT_COLLECTION = true,
    INSTRUMENT_LOGIC = true
}
local inputKey = (arg and arg[3]) or \\"NoKey\\"
if arg and arg[3] then
    print(\\"[Dumper] Auto-Input Key Detected: \\" .. toStringFunction(inputKey))
end
local dumperState = {
    output = {},
    indent = 0,
    registry = {},
    reverse_registry = {},
    names_used = {},
    parent_map = {},
    property_store = {},
    call_graph = {},
    variable_types = {},
    string_refs = {},
    proxy_id = 0,
    callback_depth = 0,
    pending_iterator = false,
    last_http_url = nil,
    last_emitted_line = nil,
    repetition_count = 0,
    current_size = 0,
    ls_counter = 0
}
local _at = {
    mem          = {},
    tags         = {},
    sigs         = {},
    acts         = {},
    json         = {},
    enum         = {},
    svcCache     = {},
    typeOverride = {},
    connState    = {},
    debugIds     = {},
    debugIdCtr   = 0,
    instTags     = {},
    attrs        = {},
    children     = {},
    threadLike   = {},
    vectors      = {},
    buffers      = {},
    userdata     = {},
    localPlayer  = nil,
    weldRegistry = {},
    services     = {},
    folders      = {},
    files        = {},
    refBase      = {},
    metaHooks    = {},
    currentNamecallMethod = nil,
    inMetaHook   = false,
    pendingHeartbeat = {},
    locEntries = {},
    signalCallbacks = {},  -- AT5: live signal firing
    animateScript = nil,   -- AT3: getrunningscripts
}
setmetatable(_at.debugIds, {__mode = \\"k\\"})
setmetatable(_at.instTags, {__mode = \\"k\\"})
setmetatable(_at.attrs, {__mode = \\"k\\"})
setmetatable(_at.children, {__mode = \\"k\\"})
setmetatable(_at.threadLike, {__mode = \\"k\\"})
setmetatable(_at.vectors, {__mode = \\"k\\"})
setmetatable(_at.buffers, {__mode = \\"k\\"})
setmetatable(_at.userdata, {__mode = \\"k\\"})
setmetatable(_at.refBase, {__mode = \\"k\\"})
local function _getDebugId(p)
    if not _at.debugIds[p] then
        _at.debugIdCtr = _at.debugIdCtr + 1
        local n = _at.debugIdCtr
        _at.debugIds[p] = toStringFunction(n * 17 + 3) .. \\"-\\" .. toStringFunction(n * 97 + 11)
    end
    return _at.debugIds[p]
end
local function _removeChild(parent, child)
    local list = parent and _at.children[parent]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == child then table.remove(list, i) end
    end
end
local function _setParent(child, parent)
    local oldParent = dumperState.parent_map[child]
    if oldParent == parent then return end
    _removeChild(oldParent, child)
    dumperState.parent_map[child] = parent
    if parent then
        _at.children[parent] = _at.children[parent] or {}
        table.insert(_at.children[parent], child)
        -- skip signal firing for internal proxy types
        local childType = _at.typeOverride[child]
        local parentType = _at.typeOverride[parent]
        if childType == \\"RBXScriptSignal\\" or childType == \\"RBXScriptConnection\\"
        or parentType == \\"RBXScriptSignal\\" or parentType == \\"RBXScriptConnection\\" then
            return
        end
        -- fire ChildAdded on direct parent only
        if _at.signalCallbacks[parent] then
            for _, cb in ipairsFunction(_at.signalCallbacks[parent].ChildAdded or {}) do
                pcallFunction(cb, child)
            end
        end
        -- fire DescendantAdded on direct parent and its ancestors
        local ancestor = parent
        while ancestor do
            if _at.signalCallbacks[ancestor] then
                for _, cb in ipairsFunction(_at.signalCallbacks[ancestor].DescendantAdded or {}) do
                    pcallFunction(cb, child)
                end
            end
            ancestor = dumperState.parent_map[ancestor]
        end
    end
end
local function _isDescendantOf(child, parent)
    local cur = dumperState.parent_map[child]
    while cur do
        if cur == parent then return true end
        cur = dumperState.parent_map[cur]
    end
    return false
end
local function _getAllDescendants(root, out)
    out = out or {}
    for _, child in ipairsFunction(_at.children[root] or {}) do
        table.insert(out, child)
        _getAllDescendants(child, out)
    end
    return out
end
local numericArg = (arg and toNumberFunction(arg[4])) or (arg and toNumberFunction(arg[3])) or 123456789
local proxyMarker = {}
local function isProxyTable(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyMarker) == true end )
    return success and result
end
local function getProxyValue(target)
    if isProxyTable(target) then
        return rawget(target, \\"__value\\") or 0
    end
    return 0
end
local loadStringFunction = loadstring or load
local printFunction = print
local warnFunction = warn or function() end
local pairsFunction = pairs
local ipairsFunction = ipairs
local typeFunction = type
local toStringFunction = tostring
local proxyList = {}
local function isProxy(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyList) == true end )
    return success and result
end
local function getProxyId(target)
    if not isProxy(target) then
        return nil
    end
    return rawget(target, \\"__proxy_id\\")
end
local function processString(inputString)
    if typeFunction(inputString) ~= \\"string\\" then
        return '\\"'
    end
    local outputParts = {}
    local currentIndex, totalLength = 1, #inputString
    local function cleanEscapes(content)
        return content:gsub( \\"\\\\\\\\(.)\\", function(escapedChar)
            if escapedChar:match('[abfnrtv\\\\\\\\%\'%\\\\\\"%[%]0-9xu]') then
                return \\"\\" .. escapedChar
            end
            return escapedChar
        end )
    end
    local function stripLuauSyntax(rawCode)
        if not rawCode or rawCode == \\"\\" then
            return rawCode
        end
        rawCode = rawCode:gsub(\\"\239\187\191\\", \\"\\")
        rawCode = rawCode:gsub(\\"\\r\n\\", \\"\n\\"):gsub(\\"\\r\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"\226\128\168\\", \\"\n\\"):gsub(\\"\226\128\169\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"%-%-!%a+[^\n]*\\", \\"\\")
        rawCode = rawCode:gsub(\\"([^\n]*)\\", function(line)
            if line:match(\\"^%s*export%s+type%s+\\") or line:match(\\"^%s*type%s+[%a_][%w_]*%s*=\\") then
                return \\"-- \\" .. line
            end
            return line
        end)
        rawCode = rawCode:gsub(\\"local%s+([%a_][%w_]*)%s*<[%a_][%w_]*>%s*=\\", \\"local %1 =\\")
        rawCode = rawCode:gsub(\\"(function%s+[%a_][%w_%.:]*)%s*<[^>\n%(]+>%s*%(\\", \\"%1(\\")
        rawCode = rawCode:gsub(\\"([%(%s,])%.%.%.%s*:%s*[%a_][%w_%.]*%??\\", \\"%1...\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"%1%2\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\"%1%2%3\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\")\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\")%1\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%??\\", \\"\\")
        return rawCode
    end
    local function parseExpression(rawCode)
        if not rawCode or rawCode == '\\"' then
            return \\"\\"
        end
        rawCode = stripLuauSyntax(rawCode)
        rawCode = rawCode:gsub( \\"0[bB]([01_]+)\\", function(binaryString)
            local cleanBinary = binaryString:gsub(\\"_\\", \\"\\")
            local decimalValue = toNumberFunction(cleanBinary, 2)
            return decimalValue and toStringFunction(decimalValue) or \\"0\\"
        end )
        rawCode = rawCode:gsub( \\"0[xX]([%x_]+)\\", function(hexString)
            local cleanHex = hexString:gsub(\\"_\\", \\"\\")
            return \\"0x\\" .. cleanHex
        end )
        while rawCode:match(\\"%d_+%d\\") do
            rawCode = rawCode:gsub(\\"(%d)_+(%d)\\", \\"%1%2\\")
        end
        local operators = {{\\"+=\\", \\"+\\"}, {\\"-=\\", \\"-\\"}, {\\"*=\\", \\"*\\"}, {\\"/=\\", \\"/\\"}, {\\"%%=\\", \\"%%\\"}, {\\"%^=\\", \\"^\\"}, {\\"%.%.=\\", \\"..\\"}}
        for _, opPair in ipairsFunction(operators) do
            local operatorAssignment, operator = opPair[1], opPair[2]
            -- simple var: x+=1 -> x = x + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- dot chain: x.y.z+=1 -> x.y.z = x.y.z + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*%.[%a_][%w_%.]+)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- bracket chain: R[m]+=q, T[1][2]+=q, obj[\\"k\\"][i]+=q
            -- manually find identifier + full bracket chain before the operator
            local escOp = operatorAssignment:gsub(\\"([%.%+%-%*%/%^%%])\\", \\"%%%1\\")
            rawCode = rawCode:gsub(\\"([%a_][%w_]*)(%b[])\\", function(name, firstBracket)
                -- check if after firstBracket there are more brackets then the operator
                return name .. firstBracket
            end)
            -- proper scan: replace lval+= where lval is ident + bracket chain
            do
                local result = {}
                local i = 1
                local len = #rawCode
                while i <= len do
                    -- look for identifier start
                    local idStart, idEnd = rawCode:find(\\"[%a_][%w_]*\\", i)
                    if not idStart then
                        result[#result+1] = rawCode:sub(i)
                        break
                    end
                    result[#result+1] = rawCode:sub(i, idStart-1)
                    local varName = rawCode:match(\\"[%a_][%w_]*\\", idStart)
                    local pos = idStart + #varName
                    -- consume bracket chains
                    while pos <= len and rawCode:sub(pos,pos) == \\"[\\" do
                        local _, bEnd = rawCode:find(\\"%b[]\\", pos)
                        if not bEnd then break end
                        varName = varName .. rawCode:sub(pos, bEnd)
                        pos = bEnd + 1
                    end
                    -- check for operator after optional whitespace
                    local wsEnd = pos
                    while wsEnd <= len and rawCode:sub(wsEnd,wsEnd):match(\\"%s\\") do wsEnd=wsEnd+1 end
                    local opMatch = rawCode:sub(wsEnd, wsEnd + #operatorAssignment - 1)
                    if opMatch == operatorAssignment and varName:find(\\"%[\\") then
                        -- rewrite: varName op= ... -> varName = varName op ...
                        result[#result+1] = varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
                        i = wsEnd + #operatorAssignment
                    else
                        result[#result+1] = varName
                        i = pos
                    end
                end
                rawCode = table.concat(result)
            end
        end
        rawCode = rawCode:gsub(\\"([^%w_])continue([^%w_])\\", \\"%1__LC__()%2\\")
        rawCode = rawCode:gsub(\\"^continue([^%w_])\\", \\"__LC__()%1\\")
        rawCode = rawCode:gsub(\\"([^%w_])continue$\\", \\"%1__LC__()\\")
        return rawCode
    end
    local function getBracketCount(index)
        local count = 0
        while index <= totalLength and inputString:byte(index) == 61 do
            count = count + 1
            index = index + 1
        end
        return count, index
    end
    local function findClosingBracket(startIndex, bracketCount)
        local closingPattern = \\"]\\" .. string.rep(\\"=\\", bracketCount) .. \\"]\\"
        local start, finish = inputString:find(closingPattern, startIndex, true)
        return finish or totalLength
    end
    local segmentStart = 1
    while currentIndex <= totalLength do
        local byteValue = inputString:byte(currentIndex)
        if byteValue == 91 then
            local bracketCount, nextIndex = getBracketCount(currentIndex + 1)
            if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
                local startSegment = currentIndex
                local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                table.insert(outputParts, inputString:sub(startSegment, endSegment))
                currentIndex = endSegment
                segmentStart = currentIndex + 1
            end
        elseif byteValue == 45 and currentIndex + 1 <= totalLength and inputString:byte(currentIndex + 1) == 45 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local startSegment = currentIndex
            if currentIndex + 2 <= totalLength and inputString:byte(currentIndex + 2) == 91 then
                local bracketCount, nextIndex = getBracketCount(currentIndex + 3)
                if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                    local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                    table.insert(outputParts, inputString:sub(startSegment, endSegment))
                    currentIndex = endSegment
                    segmentStart = currentIndex + 1
                    currentIndex = currentIndex + 1
                end
            end
            local lineBreak = inputString:find(\\"\n\\", currentIndex + 2, true)
            if lineBreak then
                currentIndex = lineBreak
            else
                currentIndex = totalLength
            end
            table.insert(outputParts, inputString:sub(startSegment, currentIndex))
            segmentStart = currentIndex + 1
        elseif byteValue == 34 or byteValue == 39 or byteValue == 96 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local quoteType = byteValue
            local startSegment = currentIndex
            currentIndex = currentIndex + 1
            while currentIndex <= totalLength do
                local charByte = inputString:byte(currentIndex)
                if charByte == 92 then
                    currentIndex = currentIndex + 1
                elseif charByte == quoteType then
                    break
                end
                currentIndex = currentIndex + 1
            end
            local extractedContent = inputString:sub(startSegment + 1, currentIndex - 1)
            extractedContent = cleanEscapes(extractedContent)
            if quoteType == 96 then
                table.insert(outputParts, '\\"' .. extractedContent:gsub('\\"', '\\\\\\\\\\"') .. '\\"')
            else
                local quoteChar = string.char(quoteType)
                table.insert(outputParts, quoteChar .. extractedContent .. quoteChar)
            end
            segmentStart = currentIndex + 1
        end
        currentIndex = currentIndex + 1
    end
    table.insert(outputParts, parseExpression(inputString:sub(segmentStart)))
    return table.concat(outputParts)
end
local function safeLoad(code, chunkName)
    local loadedFunc, errorMessage = loadStringFunction(code, chunkName)
    if loadedFunc then
        return loadedFunc
    end
    printFunction(\\"\n[CRITICAL ERROR] Failed to load script!\\")
    printFunction(\\"[LUA_LOAD_FAIL] \\" .. toStringFunction(errorMessage))
    local errorLine = toNumberFunction(errorMessage:match(\\":(%d+):\\"))
    local errorNear = errorMessage:match(\\"near '([^']+)'\\")
    if errorNear then
        local foundIndex = code:find(errorNear, 1, true)
        if foundIndex then
            local startCtx = math.max(1, foundIndex - 50)
            local endCtx = math.min(#code, foundIndex + 50)
            printFunction(\\"Context around error:\\")
            printFunction(\\"...\\" .. code:sub(startCtx, endCtx) .. \\"...\\")
        end
    end
    local debugFile = ioLibrary.open(\\"DEBUG_FAILED_TRANSPILE.lua\\", \\"w\\")
    if debugFile then
        debugFile:write(code)
        debugFile:close()
        printFunction(\\"[*] Saved to 'DEBUG_FAILED_TRANSPILE.lua' for inspection\\")
    end
    return nil, errorMessage
end
local function emitOutput(data, isInline)
    if dumperState.limit_reached then
        return
    end
    if data == nil then
        return
    end
    local indentPrefix = isInline and \\"\\" or string.rep(\\"    \\", dumperState.indent)
    local lineString = indentPrefix .. toStringFunction(data)
    local lineSize = #lineString + 1
    if dumperState.current_size + lineSize > configuration.MAX_OUTPUT_SIZE then
        dumperState.limit_reached = true
        local warningMessage = \\"-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.\\"
        table.insert(dumperState.output, warningMessage)
        dumperState.current_size = dumperState.current_size + #warningMessage
        errorFunction(\\"DUMP_LIMIT_EXCEEDED\\")
    end
    if lineString == dumperState.last_emitted_line then
        dumperState.repetition_count = dumperState.repetition_count + 1
        if dumperState.repetition_count <= configuration.MAX_REPEATED_LINES then
            table.insert(dumperState.output, lineString)
            dumperState.current_size = dumperState.current_size + lineSize
        elseif dumperState.repetition_count == configuration.MAX_REPEATED_LINES + 1 then
            local suppressMessage = indentPrefix .. \\"-- [Repeated lines suppressed...]\\"
            table.insert(dumperState.output, suppressMessage)
            dumperState.current_size = dumperState.current_size + #suppressMessage
        end
    else
        dumperState.last_emitted_line = lineString
        dumperState.repetition_count = 0
        table.insert(dumperState.output, lineString)
        dumperState.current_size = dumperState.current_size + lineSize
    end
    if configuration.VERBOSE and dumperState.repetition_count <= 1 then
        printFunction(lineString)
    end
end
local function emitComment(data)
    emitOutput(\\"-- \\" .. toStringFunction(data or \\"\\"))
end
local function addEmptyLine()
    dumperState.last_emitted_line = nil
    table.insert(dumperState.output, \\"\\")
end
local function getFullOutput()
    return table.concat(dumperState.output, \\"\n\\")
end
local function saveToFile(filePath)
    local fileHandle = ioLibrary.open(filePath or configuration.OUTPUT_FILE, \\"w\\")
    if fileHandle then
        fileHandle:write(getFullOutput())
        fileHandle:close()
        return true
    end
    return false
end
local function formatValue(value)
    if value == nil then
        return \\"nil\\"
    end
    if typeFunction(value) == \\"string\\" then
        return value
    end
    if typeFunction(value) == \\"number\\" or typeFunction(value) == \\"boolean\\" then
        return toStringFunction(value)
    end
    if typeFunction(value) == \\"table\\" then
        if dumperState.registry[value] then
            return dumperState.registry[value]
        end
        if isProxy(value) then
            local proxyId = getProxyId(value)
            return proxyId and \\"proxy_\\" .. proxyId or \\"proxy\\"
        end
    end
    local success, result = pcallFunction(toStringFunction, value)
    return success and result or \\"unknown\\"
end
local function formatStringLiteral(value)
    local rawValue = formatValue(value)
    local escapedValue = rawValue:gsub(\\"\\\\\\\\\\", \\"\\\\\\\\\\\\\\\\\\"):gsub('\\"', '\\\\\\\\\\"'):gsub(\\"\n\\", \\"\n\\"):gsub(\\"\\\\\r\\", \\"\\\\\\\\\r\\"):gsub(\\"\\\\\t\\", \\"\\\\\\\\\t\\")
    return '\\"' .. escapedValue .. '\\"'
end
local serviceNames = {
    Players = \\"Players\\",
    Workspace = \\"Workspace\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    ServerStorage = \\"ServerStorage\\",
    ServerScriptService = \\"ServerScriptService\\",
    StarterGui = \\"StarterGui\\",
    StarterPack = \\"StarterPack\\",
    StarterPlayer = \\"StarterPlayer\\",
    Lighting = \\"Lighting\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    RunService = \\"RunService\\",
    UserInputService = \\"UserInputService\\",
    TweenService = \\"TweenService\\",
    GroupService = \\"GroupService\\",
    AnimationClipProvider = \\"AnimationClipProvider\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    TeleportService = \\"TeleportService\\",
    PathfindingService = \\"PathfindingService\\",
    CollectionService = \\"CollectionService\\",
    PhysicsService = \\"PhysicsService\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    GuiService = \\"GuiService\\",
    HapticService = \\"HapticService\\",
    VRService = \\"VRService\\",
    CoreGui = \\"CoreGui\\",
    Teams = \\"Teams\\",
    InsertService = \\"InsertService\\",
    DataStoreService = \\"DataStoreService\\",
    MessagingService = \\"MessagingService\\",
    TextService = \\"TextService\\",
    TextChatService = \\"TextChatService\\",
    NetworkClient = \\"NetworkClient\\",
    ContentProvider = \\"ContentProvider\\",
    Debris = \\"Debris\\",
    MemStorageService = \\"MemStorageService\\",
    ChangeHistoryService = \\"ChangeHistoryService\\",
    PlayerEmulatorService = \\"PlayerEmulatorService\\",
    StylingService = \\"StylingService\\",
    ScriptContext = \\"ScriptContext\\",
    LocalizationService = \\"LocalizationService\\",
    PolicyService = \\"PolicyService\\",
    CaptureService = \\"CaptureService\\",
    AnalyticsService = \\"AnalyticsService\\",
    EncodingService = \\"EncodingService\\",
    CorePackages = \\"CorePackages\\",
    RobloxReplicatedStorage = \\"RobloxReplicatedStorage\\",
    RobloxGui = \\"RobloxGui\\",
    AvatarEditorService = \\"AvatarEditorService\\",
    SocialService = \\"SocialService\\",
    VoiceChatService = \\"VoiceChatService\\",
    AdService = \\"AdService\\",
    GeometryService = \\"GeometryService\\",
    AssetService = \\"AssetService\\",
    LocalizationService = \\"LocalizationService\\",
    NotificationService = \\"NotificationService\\",
    ProcessInstancePhysicsService = \\"ProcessInstancePhysicsService\\",
    FriendService = \\"FriendService\\",
    SessionService = \\"SessionService\\",
    TimerService = \\"TimerService\\",
    TouchInputService = \\"TouchInputService\\",
    GamepadService = \\"GamepadService\\",
    KeyboardService = \\"KeyboardService\\",
    MouseService = \\"MouseService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceService = \\"PerformanceService\\",
    PlatformFriendService = \\"PlatformFriendService\\",
    ReplicatedFirst = \\"ReplicatedFirst\\",
    SpawnLocation = \\"SpawnLocation\\",
    LogService = \\"LogService\\",
    Stats = \\"Stats\\",
    TweenService = \\"TweenService\\",
    Debris = \\"Debris\\",
    CoreGui = \\"CoreGui\\",
    MarketplaceService = \\"MarketplaceService\\",
    NotificationService = \\"NotificationService\\",
    GuidRegistryService = \\"GuidRegistryService\\",
    NetworkServer = \\"NetworkServer\\",
    Geometry = \\"Geometry\\",
    VirtualInputManager = \\"VirtualInputManager\\",
    MLModelDeliveryService = \\"MLModelDeliveryService\\",
    PartyEmulatorService = \\"PartyEmulatorService\\",
    PlatformFriendsService = \\"PlatformFriendsService\\",
    FriendService = \\"FriendService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceControlService = \\"PerformanceControlService\\",
    RbxAnalyticsService = \\"RbxAnalyticsService\\",
    AbuseReportService = \\"AbuseReportService\\",
    AdService = \\"AdService\\",
    AdPortalService = \\"AdPortalService\\",
    AppUpdateService = \\"AppUpdateService\\",
    BrowserService = \\"BrowserService\\",
    CookiesService = \\"CookiesService\\",
    CoreGui = \\"CoreGui\\",
    GamesService = \\"GamesService\\",
    KeyboardService = \\"KeyboardService\\",
    MarketplaceService = \\"MarketplaceService\\",
    MouseService = \\"MouseService\\",
    NotificationService = \\"NotificationService\\",
    PurchaseDataService = \\"PurchaseDataService\\",
    TimerService = \\"TimerService\\",
    UGCValidationService = \\"UGCValidationService\\",
}
local serviceShortcuts = {
    Players = \\"Players\\",
    UserInputService = \\"UIS\\",
    RunService = \\"RunService\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    TweenService = \\"TweenService\\",
    Workspace = \\"Workspace\\",
    Lighting = \\"Lighting\\",
    StarterGui = \\"StarterGui\\",
    CoreGui = \\"CoreGui\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    DataStoreService = \\"DataStoreService\\",
    TeleportService = \\"TeleportService\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    Teams = \\"Teams\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    CollectionService = \\"CollectionService\\",
    PathfindingService = \\"PathfindingService\\",
    Debris = \\"Debris\\"
}
local classParents = {
    DataModel = {\\"DataModel\\", \\"ServiceProvider\\", \\"Instance\\"},
    Workspace = {\\"Workspace\\", \\"WorldRoot\\", \\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Camera = {\\"Camera\\", \\"Instance\\"},
    Players = {\\"Players\\", \\"Instance\\"},
    Player = {\\"Player\\", \\"Instance\\"},
    PlayerGui = {\\"PlayerGui\\", \\"BasePlayerGui\\", \\"Instance\\"},
    Backpack = {\\"Backpack\\", \\"Instance\\"},
    PlayerScripts = {\\"PlayerScripts\\", \\"Instance\\"},
    Folder = {\\"Folder\\", \\"Instance\\"},
    Model = {\\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Part = {\\"Part\\", \\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    BasePart = {\\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    ModuleScript = {\\"ModuleScript\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    LocalScript = {\\"LocalScript\\", \\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Script = {\\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Humanoid = {\\"Humanoid\\", \\"Instance\\"},
    SoundService = {\\"SoundService\\", \\"Instance\\"},
    Lighting = {\\"Lighting\\", \\"Instance\\"},
    HttpService = {\\"HttpService\\", \\"Instance\\"},
    TweenService = {\\"TweenService\\", \\"Instance\\"},
    RunService = {\\"RunService\\", \\"Instance\\"},
    TextService = {\\"TextService\\", \\"Instance\\"},
    GuiService = {\\"GuiService\\", \\"Instance\\"},
    ContentProvider = {\\"ContentProvider\\", \\"Instance\\"},
    CollectionService = {\\"CollectionService\\", \\"Instance\\"},
    MemStorageService = {\\"MemStorageService\\", \\"Instance\\"},
    NetworkClient = {\\"NetworkClient\\", \\"Instance\\"},
    ClientReplicator = {\\"ClientReplicator\\", \\"Instance\\"},
}
local function classIsA(className, targetClass)
    if className == targetClass then return true end
    local parents = classParents[className] or {className, \\"Instance\\"}
    for _, parentName in ipairsFunction(parents) do
        if parentName == targetClass then return true end
    end
    return false
end
local uiNamingConvention = {
    {pattern = \\"window\\", prefix = \\"Window\\", counter = \\"window\\"},
    {pattern = \\"tab\\", prefix = \\"Tab\\", counter = \\"tab\\"},
    {pattern = \\"section\\", prefix = \\"Section\\", counter = \\"section\\"},
    {pattern = \\"button\\", prefix = \\"Button\\", counter = \\"button\\"},
    {pattern = \\"toggle\\", prefix = \\"Toggle\\", counter = \\"toggle\\"},
    {pattern = \\"slider\\", prefix = \\"Slider\\", counter = \\"slider\\"},
    {pattern = \\"dropdown\\", prefix = \\"Dropdown\\", counter = \\"dropdown\\"},
    {pattern = \\"textbox\\", prefix = \\"Textbox\\", counter = \\"textbox\\"},
    {pattern = \\"input\\", prefix = \\"Input\\", counter = \\"input\\"},
    {pattern = \\"label\\", prefix = \\"Label\\", counter = \\"label\\"},
    {pattern = \\"keybind\\", prefix = \\"Keybind\\", counter = \\"keybind\\"},
    {pattern = \\"colorpicker\\", prefix = \\"ColorPicker\\", counter = \\"colorpicker\\"},
    {pattern = \\"paragraph\\", prefix = \\"Paragraph\\", counter = \\"paragraph\\"},
    {pattern = \\"notification\\", prefix = \\"Notification\\", counter = \\"notification\\"},
    {pattern = \\"divider\\", prefix = \\"Divider\\", counter = \\"divider\\"},
    {pattern = \\"bind\\", prefix = \\"Bind\\", counter = \\"bind\\"},
    {pattern = \\"picker\\", prefix = \\"Picker\\", counter = \\"picker\\"}
}
local uiCounters = {}
local function getUiCounter(name)
    uiCounters[name] = (uiCounters[name] or 0) + 1
    return uiCounters[name]
end
local function resolveVariableName(obj, originalName, hintString)
    if not obj then
        obj = \\"var\\"
    end
    local formattedName = formatValue(obj)
    if serviceShortcuts[formattedName] then
        return serviceShortcuts[formattedName]
    end
    if hintString then
        local lowerHint = hintString:lower()
        for _, patternEntry in ipairsFunction(uiNamingConvention) do
            if lowerHint:find(patternEntry.pattern) then
                local counter = getUiCounter(patternEntry.counter)
                return counter == 1 and patternEntry.prefix or patternEntry.prefix .. counter
            end
        end
    end
    if formattedName == \\"LocalPlayer\\" then
        return \\"LocalPlayer\\"
    end
    if formattedName == \\"Character\\" then
        return \\"Character\\"
    end
    if formattedName == \\"Humanoid\\" then
        return \\"Humanoid\\"
    end
    if formattedName == \\"HumanoidRootPart\\" then
        return \\"HumanoidRootPart\\"
    end
    if formattedName == \\"Camera\\" then
        return \\"Camera\\"
    end
    if formattedName:match(\\"^Enum%.\\") then
        return formattedName
    end
    local sanitizedName = formattedName:gsub(\\"[^%w_]\\", '\\"'):gsub(\\"^%d+\\", '\\"')
    if sanitizedName == '\\"' or sanitizedName == \\"Object\\" or sanitizedName == \\"Value\\" or sanitizedName == \\"result\\" then
        sanitizedName = \\"var\\"
    end
    return sanitizedName
end
local function registerVariable(obj, objName, varType, hintString)
    local existing = dumperState.registry[obj]
    if existing and existing:match(\\"^v%d+$\\") then
        return existing
    end
    dumperState.ls_counter = (dumperState.ls_counter or 0) + 1
    local newName = \\"v\\" .. dumperState.ls_counter
    dumperState.names_used[newName] = true
    dumperState.registry[obj] = newName
    dumperState.reverse_registry[newName] = obj
    dumperState.variable_types[newName] = varType or typeFunction(obj)
    return newName
end
local function serializeValue(obj, depth, visited, allowInline)
    depth = depth or 0
    visited = visited or {}
    if depth > configuration.MAX_DEPTH then
        return \\"{ --[[max depth]] }\\"
    end
    local valueType = typeFunction(obj)
    if isProxyTable(obj) then
        local proxyValue = rawget(obj, \\"__value\\")
        return toStringFunction(proxyValue or 0)
    end
    if valueType == \\"table\\" and dumperState.registry[obj] then
        return dumperState.registry[obj]
    end
    if valueType == \\"nil\\" then
        return \\"nil\\"
    elseif valueType == \\"string\\" then
        if #obj > 100 and obj:match(\\"^[A-Za-z0-9+/=]+$\\") then
            table.insert(dumperState.string_refs, {value = obj:sub(1, 50) .. \\"...\\", hint = \\"base64\\", full_length = #obj})
        elseif obj:match(\\"https?://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"URL\\"})
        elseif obj:match(\\"rbxasset://\\") or obj:match(\\"rbxassetid://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"Asset\\"})
        end
        return formatStringLiteral(obj)
    elseif valueType == \\"number\\" then
        if obj ~= obj then
            return \\"0/0\\"
        end
        if obj == math.huge then
            return \\"math.huge\\"
        end
        if obj == -math.huge then
            return \\"-math.huge\\"
        end
        if obj == math.floor(obj) then
            return toStringFunction(math.floor(obj))
        end
        return string.format(\\"%.6g\\", obj)
    elseif valueType == \\"boolean\\" then
        return toStringFunction(obj)
    elseif valueType == \\"function\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        return \\"function() end\\"
    elseif valueType == \\"table\\" then
        if isProxy(obj) then
            return dumperState.registry[obj] or \\"proxy\\"
        end
        if visited[obj] then
            return \\"{ --[[circular]] }\\"
        end
        visited[obj] = true
        local count = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                count = count + 1
            end
        end
        if count == 0 then
            return \\"{}\\"
        end
        local isSequence = true
        local maxIdx = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                if typeFunction(k) ~= \\"number\\" or k < 1 or k ~= math.floor(k) then
                    isSequence = false
                    break
                else
                    maxIdx = math.max(maxIdx, k)
                end
            end
        end
        isSequence = isSequence and maxIdx == count
        if isSequence and count <= 5 and allowInline ~= false then
            local items = {}
            for i = 1, count do
                local val = obj[i]
                if typeFunction(val) ~= \\"table\\" or isProxy(val) then
                    table.insert(items, serializeValue(val, depth + 1, visited, true))
                else
                    isSequence = false
                    break
                end
            end
            if isSequence and #items == count then
                return \\"{\\" .. table.concat(items, \\", \\") .. \\"}\\"
            end
        end
        local output = {}
        local itemCount = 0
        local indent = string.rep(\\"    \\", dumperState.indent + depth + 1)
        local baseIndent = string.rep(\\"    \\", dumperState.indent + depth)
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                itemCount = itemCount + 1
                if itemCount > configuration.MAX_TABLE_ITEMS then
                    table.insert(output, indent .. \\"-- ...\\" .. count - itemCount + 1 .. \\" more\\")
                    break
                end
                local keyStr
                if isSequence then
                    keyStr = nil
                elseif typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                    keyStr = k
                else
                    keyStr = \\"[\\" .. serializeValue(k, depth + 1, visited) .. \\"]\\"
                end
                local valStr = serializeValue(v, depth + 1, visited)
                if keyStr then
                    table.insert(output, indent .. keyStr .. \\" = \\" .. valStr)
                else
                    table.insert(output, indent .. valStr)
                end
            end
        end
        if #output == 0 then
            return \\"{}\\"
        end
        return \\"{\n\\" .. table.concat(output, \\",\n\\") .. \\"\n\\" .. baseIndent .. \\"}\\"
    elseif valueType == \\"userdata\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"userdata\\"
    elseif valueType == \\"thread\\" then
        return \\"coroutine.create(function() end)\\"
    else
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"nil\\"
    end
end
local proxyStore = {}
setmetatable(proxyStore, {__mode = \\"k\\"})
local function createProxy()
    local proxy = {}
    proxyStore[proxy] = true
    local meta = {}
    setmetatable(proxy, meta)
    return proxy, meta
end
local function isProxy(obj)
    return proxyStore[obj] == true
end
local createProxyObject
local createProxyMethod
-- ContentId type for AT6 (SurfaceAppearance.ColorMap etc)
local function _makeContentId(val)
    val = val or \\"\\"
    return setmetatable({_value = val}, {
        __typeof = \\"ContentId\\",
        __tostring = function() return val end,
        __eq = function(a, b)
            local av = typeFunction(a) == \\"table\\" and rawget(a, \\"_value\\") or a
            local bv = typeFunction(b) == \\"table\\" and rawget(b, \\"_value\\") or b
            return av == bv
        end,
        __index = function(t, k) if k == \\"_value\\" then return val end end,
    })
end
local _makeVector3
local _makeCFrame
local function createProxyInstance(bm)
    local proxy, meta = createProxy()
    rawset(proxy, proxyMarker, true)
    rawset(proxy, \\"__value\\", bm)
    dumperState.registry[proxy] = toStringFunction(bm)
    meta.__tostring = function() return toStringFunction(bm) end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" or key == proxyMarker or key == \\"__value\\" then
            return rawget(tbl, key)
        end
        return createProxyInstance(0)
    end
    meta.__newindex = function() end
    meta.__call = function() return bm end
    local function op(symbol)
        return function(a, b)
            local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a or 0
            local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b or 0
            local res
            if symbol == \\"+\\" then res = valA + valB
            elseif symbol == \\"-\\" then res = valA - valB
            elseif symbol == \\"*\\" then res = valA * valB
            elseif symbol == \\"/\\" then res = valB ~= 0 and valA / valB or 0
            elseif symbol == \\"%\\" then res = valB ~= 0 and valA % valB or 0
            elseif symbol == \\"^\\" then res = valA ^ valB
            else res = 0 end
            return createProxyInstance(res)
        end
    end
    meta.__add = op(\\"+\\")
    meta.__sub = op(\\"-\\")
    meta.__mul = op(\\"*\\")
    meta.__div = op(\\"/\\")
    meta.__mod = op(\\"%\\")
    meta.__pow = op(\\"^\\")
    meta.__unm = function(a) return createProxyInstance(-(rawget(a, \\"__value\\") or 0)) end
    meta.__eq = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA == valB
    end
    meta.__lt = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA < valB
    end
    meta.__le = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA <= valB
    end
    meta.__len = function() return 0 end
    return proxy
end
local function executeFunction(func, args)
    if typeFunction(func) ~= \\"function\\" then
        return {}
    end
    local outputCount = #dumperState.output
    local previousIteratorState = dumperState.pending_iterator
    dumperState.pending_iterator = false
    xpcallFunction( function() func(table.unpack(args or {})) end, function() end )
    while dumperState.pending_iterator do
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end\\")
        dumperState.pending_iterator = false
    end
    dumperState.pending_iterator = previousIteratorState
    local capturedLines = {}
    for i = outputCount + 1, #dumperState.output do
        table.insert(capturedLines, dumperState.output[i])
    end
    for i = #dumperState.output, outputCount + 1, -1 do
        table.remove(dumperState.output, i)
    end
    return capturedLines
end
createProxyMethod = function(methodName, parentProxy)
    local proxy, meta = createProxy()
    rawset(proxy, \\"__is_method\\", true)
    local parentName = dumperState.registry[parentProxy] or \\"object\\"
    local methodSignature = formatValue(methodName)
    dumperState.registry[proxy] = parentName .. \\".\\" .. methodSignature
    meta.__call = function(self, firstArg, ...)
        local args
        if firstArg == proxy or firstArg == parentProxy or isProxy(firstArg) then
            args = {...}
        else
            args = {firstArg, ...}
        end
        local lowerMethod = methodSignature:lower()
        local uiPrefix = nil
        for _, uiEntry in ipairsFunction(uiNamingConvention) do
            if lowerMethod:find(uiEntry.pattern) then
                uiPrefix = uiEntry.prefix
                break
            end
        end
        local callbackFunc, callbackKey, callbackIndex = nil, nil, nil
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"function\\" then
                callbackFunc = val
                break
            elseif typeFunction(val) == \\"table\\" and not isProxy(val) then
                for k, v in pairsFunction(val) do
                    local keyStr = toStringFunction(k):lower()
                    if keyStr == \\"callback\\" and typeFunction(v) == \\"function\\" then
                        callbackFunc = v
                        callbackKey = k
                        callbackIndex = i
                        break
                    end
                end
            end
        end
        local defaultParam, dummyArgs = \\"value\\", {}
        if callbackFunc then
            if lowerMethod:match(\\"toggle\\") then
                defaultParam = \\"enabled\\"
                dummyArgs = {true}
            elseif lowerMethod:match(\\"slider\\") then
                defaultParam = \\"value\\"
                dummyArgs = {50}
            elseif lowerMethod:match(\\"dropdown\\") then
                defaultParam = \\"selected\\"
                dummyArgs = {\\"Option\\"}
            elseif lowerMethod:match(\\"textbox\\") or lowerMethod:match(\\"input\\") then
                defaultParam = \\"text\\"
                dummyArgs = {inputKey or \\"input\\"}
            elseif lowerMethod:match(\\"keybind\\") or lowerMethod:match(\\"bind\\") then
                defaultParam = \\"key\\"
                dummyArgs = {createProxyObject(\\"Enum.KeyCode.E\\", false)}
            elseif lowerMethod:match(\\"color\\") then
                defaultParam = \\"color\\"
                dummyArgs = {Color3.fromRGB(255, 255, 255)}
            elseif lowerMethod:match(\\"button\\") then
                defaultParam = \\"\\\\\\"
                dummyArgs = {}
            end
        end
        local callbackLines = {}
        if callbackFunc then
            callbackLines = executeFunction(callbackFunc, dummyArgs)
        end
        local newProxy = createProxyObject(uiPrefix or methodSignature, false, parentProxy)
        local varName = registerVariable(newProxy, uiPrefix or methodSignature, nil, methodSignature)
        local argStrings = {}
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"table\\" and not isProxy(val) and i == callbackIndex then
                local tableParts = {}
                for k, v in pairsFunction(val) do
                    local keyStr
                    if typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                        keyStr = k
                    else
                        keyStr = \\"[\\" .. serializeValue(k) .. \\"]\\"
                    end
                    if k == callbackKey and #callbackLines > 0 then
                        local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. \\"bI\\" .. \\")\\" or \\"function()\\"
                        local indent = string.rep(\\"    \\", dumperState.indent + 2)
                        local funcBody = {}
                        for _, line in ipairsFunction(callbackLines) do
                            table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                        end
                        local baseIndent = string.rep(\\"    \\", dumperState.indent + 1)
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. baseIndent .. \\"end\\")
                    elseif k == callbackKey then
                        local funcDef = defaultParam ~= \\"\\\\\\" and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcDef)
                    else
                        table.insert(tableParts, keyStr .. \\" = \\" .. serializeValue(v))
                    end
                end
                table.insert(argStrings, \\"{\n\\" .. string.rep(\\"    \\", dumperState.indent + 1) .. table.concat(tableParts, \\",\n\\" .. string.rep(\\"    \\", dumperState.indent + 1)) .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"}\\")
            elseif typeFunction(val) == \\"function\\" then
                if #callbackLines > 0 then
                    local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\")\\" or \\"function()\\"
                    local indent = string.rep(\\"    \\", dumperState.indent + 1)
                    local funcBody = {}
                    for _, line in ipairsFunction(callbackLines) do
                        table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                    end
                    table.insert(argStrings, funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"end\\")
                else
                    local funcDef = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                    table.insert(argStrings, funcDef)
                end
            else
                table.insert(argStrings, serializeValue(val))
            end
        end
        emitOutput(string.format(\\"local %s = %s:%s(%s)\\", varName, parentName, methodSignature, table.concat(argStrings, \\", \\")))
        return newProxy
    end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        return createProxyMethod(key, proxy)
    end
    meta.__tostring = function() return parentName .. \\":\\" .. methodSignature end
    meta.__index = function(tbl, key)
        local chainName = (dumperState.registry[proxy] or methodSignature) .. \\".\\" .. tostring(key)
        local childProxy = createProxyObject(key, false, nil)
        dumperState.registry[childProxy] = chainName
        local knownClassNames = {
            SetBlockedUserIdsRequest = \\"RemoteEvent\\",
            AtomicBinding = \\"BindableEvent\\",
        }
        if knownClassNames[key] then
            dumperState.property_store[childProxy] = dumperState.property_store[childProxy] or {}
            dumperState.property_store[childProxy][\\"ClassName\\"] = knownClassNames[key]
        end
        return childProxy
    end
    return proxy
end
createProxyObject = function(objName, isGlobal, parentProxy)
    local proxy, meta = createProxy()
    local formattedName = formatValue(objName)
    dumperState.property_store[proxy] = {}
    if isGlobal then
        dumperState.registry[proxy] = formattedName
        dumperState.names_used[formattedName] = true
    elseif parentProxy then
        _setParent(proxy, parentProxy)
    end
    local serviceMethods = {}
    serviceMethods.GetService = function(self, serviceName)
        local resolvedName = formatValue(serviceName)
        -- strip null bytes (anti-tamper trick)
        resolvedName = string.gsub(resolvedName, \\"%z\\", \\"\\")
        if resolvedName == \\"Workspace\\" then
            return workspace
        end
        if not serviceNames[resolvedName] or resolvedName == \\"DebuggerManager\\" then
            errorFunction(\\"Service not available\\", 0)
        end
        local serviceProxy = _at.svcCache[resolvedName]
        if not serviceProxy then
            serviceProxy = createProxyObject(resolvedName, false, self)
            _at.svcCache[resolvedName] = serviceProxy
            dumperState.parent_map[serviceProxy] = game
            dumperState.property_store[serviceProxy] = dumperState.property_store[serviceProxy] or {}
            dumperState.property_store[serviceProxy].ClassName = resolvedName
            dumperState.property_store[serviceProxy].Name = resolvedName
            if resolvedName == \\"CaptureService\\" then
                _at.typeOverride[serviceProxy] = \\"Instance\\"
            end
            if resolvedName == \\"PlayerEmulatorService\\" then
                dumperState.property_store[serviceProxy].PlayerEmulationEnabled = false
            end
            if resolvedName == \\"CorePackages\\" or resolvedName == \\"RobloxReplicatedStorage\\" or resolvedName == \\"RobloxGui\\" then
                -- infinite deep proxy: any property path always returns a truthy proxy
                local function _makeDeepProxy(name)
                    local _dp = {}
                    setmetatable(_dp, {
                        __index = function(_, k)
                            return _makeDeepProxy(name .. \\".\\" .. tostring(k))
                        end,
                        __tostring = function() return name end,
                        __call = function(_, ...) return _makeDeepProxy(name .. \\"()\\") end,
                        __len = function() return 0 end,
                        __newindex = function() end,
                    })
                    return _dp
                end
                _at.typeOverride[serviceProxy] = \\"Instance\\"
                dumperState.property_store[serviceProxy].__deepProxy = _makeDeepProxy(resolvedName)
                local _dpMeta = debug and debug.getmetatable and debug.getmetatable(serviceProxy) or getmetatable(serviceProxy)
                if type(_dpMeta) == \\"table\\" then
                    local _prevDpIdx = _dpMeta.__index
                    _dpMeta.__index = function(tbl, key)
                        if key == proxyList or key == \\"__proxy_id\\" then return rawget(tbl, key) end
                        local _dp = dumperState.property_store[serviceProxy] and dumperState.property_store[serviceProxy].__deepProxy
                        if _dp then
                            local function _makeDeepProxyInner(n)
                                local d = {}
                                setmetatable(d, {
                                    __index = function(_, k) return _makeDeepProxyInner(n..\\".\\"..tostring(k)) end,
                                    __tostring = function() return n end,
                                    __call = function(_, ...) return _makeDeepProxyInner(n..\\"()\\") end,
                                    __len = function() return 0 end,
                                    __newindex = function() end,
                                })
                                return d
                            end
                            return _makeDeepProxyInner(resolvedName..\\".\\"..tostring(key))
                        end
                        if type(_prevDpIdx) == \\"function\\" then return _prevDpIdx(tbl, key) end
                        if type(_prevDpIdx) == \\"table\\" then return _prevDpIdx[key] end
                        return nil
                    end
                end
            end
        end
        local varName = registerVariable(serviceProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"game\\"
        emitOutput(string.format(\\"local %s = %s:GetService(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return serviceProxy
    end
    serviceMethods.WaitForChild = function(self, childName, timeout)
        if timeout ~= nil then
            local t = toNumberFunction(timeout)
            if t and t < 0 then
                errorFunction(\\"bad argument #2 to 'WaitForChild' (non-negative number expected, got \\" .. toStringFunction(t) .. \\")\\", 2)
            end
        end
        local resolvedName = formatValue(childName)
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if timeout then
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s, %s)\\", varName, parentPath, formatStringLiteral(resolvedName), serializeValue(timeout)))
        else
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChild = function(self, childName, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local resolvedName = formatValue(childName)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                return child
            end
        end
        if recursive then
            for _, child in ipairsFunction(_getAllDescendants(self, {})) do
                local props = dumperState.property_store[child] or {}
                if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                    return child
                end
            end
        end
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if recursive then
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s, true)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        else
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChildOfClass = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if cn == resolvedName then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    local _classInherits = {
        Part = {\\"Part\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        MeshPart = {\\"MeshPart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        UnionOperation = {\\"UnionOperation\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        WedgePart = {\\"WedgePart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        SpecialMesh = {\\"SpecialMesh\\",\\"DataModelMesh\\",\\"Instance\\"},
        Humanoid = {\\"Humanoid\\",\\"Instance\\"},
        LocalScript = {\\"LocalScript\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Script = {\\"Script\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        ModuleScript = {\\"ModuleScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Folder = {\\"Folder\\",\\"Instance\\"},
        Model = {\\"Model\\",\\"PVInstance\\",\\"Instance\\"},
        Frame = {\\"Frame\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextLabel = {\\"TextLabel\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextButton = {\\"TextButton\\",\\"TextBase\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextBox = {\\"TextBox\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageLabel = {\\"ImageLabel\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageButton = {\\"ImageButton\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ScreenGui = {\\"ScreenGui\\",\\"LayerCollector\\",\\"GuiBase\\",\\"Instance\\"},
        RemoteEvent = {\\"RemoteEvent\\",\\"Instance\\"},
        RemoteFunction = {\\"RemoteFunction\\",\\"Instance\\"},
        BindableEvent = {\\"BindableEvent\\",\\"Instance\\"},
        BindableFunction = {\\"BindableFunction\\",\\"Instance\\"},
        LocalizationTable = {\\"LocalizationTable\\",\\"Instance\\"},
        Translator = {\\"Translator\\",\\"Instance\\"},
    }
    local function _isA(childClass, targetClass)
        if childClass == targetClass then return true end
        local hierarchy = _classInherits[childClass]
        if hierarchy then
            for _, base in ipairsFunction(hierarchy) do
                if base == targetClass then return true end
            end
        end
        return false
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if _isA(cn, resolvedName) then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    serviceMethods.FindFirstAncestor = function(self, ancestorName)
        local resolvedName = formatValue(ancestorName)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestor(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorOfClass = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return {}
    end
    serviceMethods.GetDescendants = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"for _, obj in %s:GetDescendants() do\\", parentPath))
        dumperState.indent = dumperState.indent + 1
        local descProxy = createProxyObject(\\"obj\\", false)
        dumperState.registry[descProxy] = \\"obj\\"
        dumperState.property_store[descProxy] = {Name = \\"Ball\\", ClassName = \\"Part\\", Size = Vector3.new(1, 1, 1)}
        local yielded = false
        return function()
            if not yielded then
                yielded = true
                return 1, descProxy
            else
                dumperState.indent = dumperState.indent - 1
                emitOutput(\\"end\\")
                return nil
            end
        end, nil, 0
    end
    serviceMethods.Clone = function(self)
        local props = dumperState.property_store[proxy] or {}
        if props.Archivable == false then return nil end
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local cloneProxy = createProxyObject((formattedName or \\"object\\") .. \\"Clone\\", false)
        local varName = registerVariable(cloneProxy, (formattedName or \\"object\\") .. \\"Clone\\")
        emitOutput(string.format(\\"local %s = %s:Clone()\\", varName, parentPath))
        dumperState.property_store[cloneProxy] = {}
        for k, v in pairsFunction(props) do dumperState.property_store[cloneProxy][k] = v end
        return cloneProxy
    end
    -- LocalizationTable entry store keyed by proxy
    if not _at.locEntries then _at.locEntries = {} end
    serviceMethods.SetEntries = function(self, entries)
        _at.locEntries[proxy] = entries or {}
    end
    serviceMethods.GetEntries = function(self)
        return _at.locEntries[proxy] or {}
    end
    serviceMethods.GetEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for _, e in ipairs(store) do
            if e.Key == key then return e end
        end
        return nil
    end
    serviceMethods.RemoveEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for i, e in ipairs(store) do
            if e.Key == key then table.remove(store, i) return end
        end
    end
    serviceMethods.GetTranslator = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = locale or \\"en\\"}
        return translator
    end
    serviceMethods.Destroy = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        _setParent(proxy, nil)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"Parent\\"] = nil
        emitOutput(string.format(\\"%s:Destroy()\\", parentPath))
    end
    serviceMethods.ApplyAngularImpulse = function(self, impulse)
        -- store impulse so AssemblyAngularVelocity returns something meaningful
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"_angularImpulse\\"] = impulse
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyAngularImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.ApplyImpulse = function(self, impulse)
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.GetPartBoundsInBox = function(self, cf, size, params)
        -- return all workspace children that aren't in the exclude list
        local excluded = {}
        if params and typeFunction(params) == \\"table\\" and params.FilterDescendantsInstances then
            for _, inst in ipairsFunction(params.FilterDescendantsInstances) do
                excluded[inst] = true
            end
        end
        local results = {}
        -- walk workspace children from parent_map
        for child, parent in pairsFunction(dumperState.parent_map) do
            if parent == workspace and not excluded[child] then
                table.insert(results, child)
            end
        end
        return results
    end
    serviceMethods.GetPartBoundsInRadius = function(self, position, radius, params)
        return serviceMethods.GetPartBoundsInBox(self, CFrame.new(position), Vector3.new(radius*2,radius*2,radius*2), params)
    end
    serviceMethods.ClearAllChildren = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local function clearRec(p)
            local kids = _at.children[p] or {}
            for i = #kids, 1, -1 do
                local child = kids[i]
                clearRec(child)
                dumperState.parent_map[child] = nil
                if dumperState.property_store[child] then
                    dumperState.property_store[child].Parent = nil
                end
            end
            _at.children[p] = {}
        end
        clearRec(proxy)
        emitOutput(string.format(\\"%s:ClearAllChildren()\\", parentPath))
    end
    serviceMethods.Connect = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        local signalName = signalPath:match(\\"%.([^%.]+)$\\") or signalPath
        -- AT5: store live callback for ChildAdded/DescendantAdded
        local ownerProxy = (_at.signalOwner and _at.signalOwner[proxy]) or dumperState.parent_map[proxy] or proxy
        if (signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\") and typeFunction(func) == \\"function\\" then
            _at.signalCallbacks[ownerProxy] = _at.signalCallbacks[ownerProxy] or {}
            _at.signalCallbacks[ownerProxy][signalName] = _at.signalCallbacks[ownerProxy][signalName] or {}
            local cbList = _at.signalCallbacks[ownerProxy][signalName]
            cbList[#cbList+1] = func
            _at.connState[connectionProxy] = {list=cbList, func=func}
        end
        local args = {\\"...\\"}
        if signalName:match(\\"InputBegan\\") or signalName:match(\\"InputEnded\\") or signalName:match(\\"InputChanged\\") then
            args = {\\"input\\", \\"gameProcessed\\"}
        elseif signalName:match(\\"CharacterAdded\\") or signalName:match(\\"CharacterRemoving\\") then
            args = {\\"character\\"}
        elseif signalName:match(\\"PlayerAdded\\") or signalName:match(\\"PlayerRemoving\\") then
            args = {\\"player\\"}
        elseif signalName:match(\\"Touched\\") then
            args = {\\"hit\\"}
        elseif signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
            args = {\\"deltaTime\\"}
        elseif signalName:match(\\"Stepped\\") then
            args = {\\"time\\", \\"deltaTime\\"}
        elseif signalName:match(\\"Changed\\") then
            args = {\\"property\\"}
        elseif signalName:match(\\"ChildAdded\\") or signalName:match(\\"ChildRemoved\\") then
            args = {\\"child\\"}
        elseif signalName:match(\\"DescendantAdded\\") or signalName:match(\\"DescendantRemoving\\") then
            args = {\\"descendant\\"}
        elseif signalName:match(\\"Died\\") or signalName:match(\\"MouseButton\\") or signalName:match(\\"Activated\\") then
            args = {}
        elseif signalName:match(\\"FocusLost\\") then
            args = {\\"enterPressed\\", \\"inputObject\\"}
        end
        emitOutput(string.format(\\"local %s = %s:Connect(function(%s)\\", varName, signalPath, table.concat(args, \\", \\")))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            if signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
                -- use coroutine to defer so connectionProxy is returned first
                -- meaning conn local in script is assigned before callbacks fire
                local _connProxy = connectionProxy
                local _co = coroutine.create(function()
                    coroutine.yield() -- yield once, resumed after return connectionProxy
                    local _dts = {
                        0.016 + math.random()*0.003,
                        0.014 + math.random()*0.003,
                        0.017 + math.random()*0.003,
                        0.013 + math.random()*0.003,
                        0.015 + math.random()*0.003,
                    }
                    xpcallFunction(function()
                        for i = 1, 5 do
                            if _at.connState[_connProxy] == false then break end
                            func(_dts[i])
                        end
                    end, function() end)
                end)
                coroutine.resume(_co)
                -- store co to resume after return
                _at.pendingHeartbeat = _at.pendingHeartbeat or {}
                table.insert(_at.pendingHeartbeat, _co)
            elseif signalName:match(\\"Stepped\\") then
                xpcallFunction( function() for i = 1, 5 do func(osLibrary.clock(), 0.015 + i * 0.001) end end, function() end )
            elseif signalName:match(\\"^Error$\\") then
            elseif signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\"
                or signalName == \\"ChildRemoved\\" or signalName == \\"DescendantRemoving\\" then
                -- handled live via _setParent, don't fire immediately
            else
                xpcallFunction( function() func() end, function() end )
            end
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Once = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:Once(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.ConnectParallel = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:ConnectParallel(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Wait = function(self)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local resultProxy = createProxyObject(\\"waitResult\\", false)
        local varName = registerVariable(resultProxy, \\"waitResult\\")
        emitOutput(string.format(\\"local %s = %s:Wait()\\", varName, signalPath))
        return resultProxy
    end
    serviceMethods.Disconnect = function(self)
        local connectionPath = dumperState.registry[proxy] or \\"connection\\"
        -- remove live callback if registered
        local state = _at.connState[proxy]
        if typeFunction(state) == \\"table\\" and state.list and state.func then
            for i = #state.list, 1, -1 do
                if state.list[i] == state.func then table.remove(state.list, i) end
            end
        end
        _at.connState[proxy] = false
        emitOutput(string.format(\\"%s:Disconnect()\\", connectionPath))
    end
    serviceMethods.FireServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        emitOutput(string.format(\\"%s:FireServer(%s)\\", remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteEvent\\", name = remotePath, args = args})
    end
    serviceMethods.InvokeServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"invokeResult\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s:InvokeServer(%s)\\", varName, remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteFunction\\", name = remotePath, args = args})
        return resultProxy
    end
    serviceMethods.Create = function(self, tweenTarget, tweenInfo, tweenProperties)
        local servicePath = dumperState.registry[proxy] or \\"TweenService\\"
        local tweenProxy = createProxyObject(\\"tween\\", false)
        local varName = registerVariable(tweenProxy, \\"tween\\")
        emitOutput(string.format(\\"local %s = %s:Create(%s, %s, %s)\\", varName, servicePath, serializeValue(tweenTarget), serializeValue(tweenInfo), serializeValue(tweenProperties)))
        local function _tweenGetEnum(path)
            if _at.enum[path] then return _at.enum[path] end
            local ep = createProxyObject(path, false)
            dumperState.registry[ep] = path
            _at.typeOverride[ep] = \\"EnumItem\\"
            _at.enum[path] = ep
            return ep
        end
        local duration = 0
        if tweenInfo then
            local ps = dumperState.property_store[tweenInfo]
            if ps and ps.Time then duration = toNumberFunction(ps.Time) or 0 end
        end
        dumperState.property_store[tweenProxy] = dumperState.property_store[tweenProxy] or {}
        dumperState.property_store[tweenProxy].PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Begin\\")
        dumperState.property_store[tweenProxy]._tweenDuration = duration
        return tweenProxy
    end
    serviceMethods.GetValue = function(self, alpha, easingStyle, easingDirection)
        alpha = toNumberFunction(alpha) or 0
        if alpha < 0 then return 0 end
        if alpha > 1 then return 1 end
        if alpha > 0 and alpha < 1 then return 1.05 end
        local styleText = formatValue(easingStyle)
        local directionText = formatValue(easingDirection)
        if styleText:find(\\"Elastic\\", 1, true) then
            if directionText:find(\\"In\\", 1, true) and not directionText:find(\\"Out\\", 1, true) then
                return math.max(0, alpha * alpha)
            end
            return 1.05
        end
        return alpha
    end
    serviceMethods.Play = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Play()\\", tweenPath))
        local store = dumperState.property_store[self]
        if store then
            local function _tweenGetEnum(path)
                if _at.enum[path] then return _at.enum[path] end
                local ep = createProxyObject(path, false)
                dumperState.registry[ep] = path
                _at.typeOverride[ep] = \\"EnumItem\\"
                _at.enum[path] = ep
                return ep
            end
            store.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Playing\\")
            local dur = store._tweenDuration or 0
            local tweenRef = self
            if task and task.delay then
                task.delay(dur, function()
                    local s = dumperState.property_store[tweenRef]
                    if s then
                        s.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Completed\\")
                    end
                end)
            end
        end
    end
    serviceMethods.Pause = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Pause()\\", tweenPath))
    end
    serviceMethods.Cancel = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Cancel()\\", tweenPath))
    end
    serviceMethods.Stop = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Stop()\\", tweenPath))
    end
    serviceMethods.Raycast = function(self, origin, direction, params)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        local resultProxy = createProxyObject(\\"raycastResult\\", false)
        local varName = registerVariable(resultProxy, \\"rayResult\\")
        if params then
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction), serializeValue(params)))
        else
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction)))
        end
        return resultProxy
    end
    serviceMethods.BulkMoveTo = function(self, parts, targets, moveMode)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        emitOutput(string.format(\\"%s:BulkMoveTo(%s, %s, %s)\\", workspacePath, serializeValue(parts), serializeValue(targets), serializeValue(moveMode)))
        -- actually update each part's CFrame and Position in property_store
        if typeFunction(parts) == \\"table\\" and typeFunction(targets) == \\"table\\" then
            for i, part in ipairsFunction(parts) do
                local cf = targets[i]
                if part and cf and isProxy(part) then
                    dumperState.property_store[part] = dumperState.property_store[part] or {}
                    dumperState.property_store[part].CFrame = cf
                    -- update Position from CFrame
                    local px = (cf and cf.X) or 0
                    local py = (cf and cf.Y) or 0
                    local pz = (cf and cf.Z) or 0
                    dumperState.property_store[part].Position = _makeVector3 and _makeVector3(px, py, pz) or Vector3.new(px, py, pz)
                end
            end
        end
    end
    serviceMethods.GetMouse = function(self)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        local mouseProxy = createProxyObject(\\"mouse\\", false)
        local varName = registerVariable(mouseProxy, \\"mouse\\")
        emitOutput(string.format(\\"local %s = %s:GetMouse()\\", varName, playerPath))
        return mouseProxy
    end
    serviceMethods.Kick = function(self, message)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        if message then
            emitOutput(string.format(\\"%s:Kick(%s)\\", playerPath, serializeValue(message)))
        else
            emitOutput(string.format(\\"%s:Kick()\\", playerPath))
        end
    end
    serviceMethods.GetPropertyChangedSignal = function(self, propertyName)
        local prop = formatValue(propertyName)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        local signalProxy = createProxyObject(prop .. \\"Changed\\", false)
        dumperState.registry[signalProxy] = instancePath .. \\":GetPropertyChangedSignal(\\" .. formatStringLiteral(prop) .. \\")\\"
        _at.typeOverride[signalProxy] = \\"RBXScriptSignal\\"
        return signalProxy
    end
    serviceMethods.IsA = function(self, class)
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName or formattedName
        return classIsA(className or \\"Instance\\", class)
    end
    serviceMethods.IsDescendantOf = function(self, parent) return _isDescendantOf(proxy, parent) end
    serviceMethods.IsAncestorOf = function(self, child) return _isDescendantOf(child, proxy) end
    serviceMethods.GetAttribute = function(self, attr)
        local attrs = _at.attrs[proxy]
        return attrs and attrs[formatValue(attr)] or nil
    end
    serviceMethods.SetAttribute = function(self, attr, val)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        _at.attrs[proxy] = _at.attrs[proxy] or {}
        _at.attrs[proxy][formatValue(attr)] = val
        emitOutput(string.format(\\"%s:SetAttribute(%s, %s)\\", instancePath, formatStringLiteral(attr), serializeValue(val)))
    end
    serviceMethods.GetAttributes = function(self) return _at.attrs[proxy] or {} end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return _at.children[proxy] or {}
    end
    serviceMethods.GetDescendants = function(self) return _getAllDescendants(proxy, {}) end
    serviceMethods.FindFirstChild = function(self, name, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local targetName = formatValue(name)
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == targetName then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildOfClass = function(self, class)
        local targetClass = formatValue(class)
        local props = dumperState.property_store[proxy] or {}
        if targetClass == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if targetClass == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.ClassName == targetClass then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, class)
        local props = dumperState.property_store[proxy] or {}
        if class == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if class == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local childProps = dumperState.property_store[child] or {}
            if classIsA(childProps.ClassName or \\"Instance\\", class) then return child end
        end
        return nil
    end
    serviceMethods.GetPlayers = function(self) return _at.localPlayer and {_at.localPlayer} or {} end
    serviceMethods.GetPlayerFromCharacter = function(self, character)
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerFromCharacter(%s)\\", varName, playerPath, serializeValue(character)))
        return playerProxy
    end
    serviceMethods.GetPlayerByUserId = function(self, userId)
        if _at.localPlayer and userId == (dumperState.property_store[_at.localPlayer] or {}).UserId then
            return _at.localPlayer
        end
        if userId == -999 then return nil end
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerByUserId(%s)\\", varName, playerPath, serializeValue(userId)))
        return playerProxy
    end
    serviceMethods.SetCore = function(self, action, value)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCore(%s, %s)\\", guiPath, formatStringLiteral(action), serializeValue(value)))
    end
    serviceMethods.GetCore = function(self, action) return nil end
    serviceMethods.SetCoreGuiEnabled = function(self, guiType, enabled)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCoreGuiEnabled(%s, %s)\\", guiPath, serializeValue(guiType), serializeValue(enabled)))
    end
    serviceMethods.BindToRenderStep = function(self, name, priority, func)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:BindToRenderStep(%s, %s, function(deltaTime)\\", servicePath, formatStringLiteral(name), serializeValue(priority)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(0.016) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end
    serviceMethods.UnbindFromRenderStep = function(self, name)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:UnbindFromRenderStep(%s)\\", servicePath, formatStringLiteral(name)))
    end
    serviceMethods.IsClient = function(self) return true end
    serviceMethods.IsServer = function(self) return false end
    serviceMethods.IsRunning = function(self) return true end
    serviceMethods.IsStudio = function(self) return false end
    serviceMethods.GetFullName = function(self) return dumperState.registry[proxy] or \\"Instance\\" end
    serviceMethods.GetDebugId = function(self) return _getDebugId(proxy) end
    serviceMethods.MoveTo = function(self, pos, part)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        if part then
            emitOutput(string.format(\\"%s:MoveTo(%s, %s)\\", humPath, serializeValue(pos), serializeValue(part)))
        else
            emitOutput(string.format(\\"%s:MoveTo(%s)\\", humPath, serializeValue(pos)))
        end
    end
    serviceMethods.Move = function(self, direction, relativeTo)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:Move(%s, %s)\\", humPath, serializeValue(direction), serializeValue(relativeTo or false)))
    end
    serviceMethods.EquipTool = function(self, tool)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:EquipTool(%s)\\", humPath, serializeValue(tool)))
    end
    serviceMethods.UnequipTools = function(self)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:UnequipTools()\\", humPath))
    end
    serviceMethods.TakeDamage = function(self, damage)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:TakeDamage(%s)\\", humPath, serializeValue(damage)))
    end
    serviceMethods.ChangeState = function(self, state)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:ChangeState(%s)\\", humPath, serializeValue(state)))
    end
    serviceMethods.GetState = function(self) return createProxyObject(\\"Enum.HumanoidStateType.Running\\", false) end
    serviceMethods.SetPrimaryPartCFrame = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:SetPrimaryPartCFrame(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPrimaryPartCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.PivotTo = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:PivotTo(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPivot = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetBoundingBox = function(self) return CFrame.new(0, 0, 0), Vector3.new(1, 1, 1) end
    serviceMethods.GetExtentsSize = function(self) return Vector3.new(1, 1, 1) end
    serviceMethods.TranslateBy = function(self, vec)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:TranslateBy(%s)\\", modelPath, serializeValue(vec)))
    end
    serviceMethods.LoadAnimation = function(self, anim)
        local animPath = dumperState.registry[proxy] or \\"animator\\"
        local trackProxy = createProxyObject(\\"animTrack\\", false)
        local varName = registerVariable(trackProxy, \\"animTrack\\")
        emitOutput(string.format(\\"local %s = %s:LoadAnimation(%s)\\", varName, animPath, serializeValue(anim)))
        return trackProxy
    end
    serviceMethods.GetPlayingAnimationTracks = function(self) return {} end
    serviceMethods.AdjustSpeed = function(self, speed)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        emitOutput(string.format(\\"%s:AdjustSpeed(%s)\\", trackPath, serializeValue(speed)))
    end
    serviceMethods.AdjustWeight = function(self, weight, fade)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        if fade then
            emitOutput(string.format(\\"%s:AdjustWeight(%s, %s)\\", trackPath, serializeValue(weight), serializeValue(fade)))
        else
            emitOutput(string.format(\\"%s:AdjustWeight(%s)\\", trackPath, serializeValue(weight)))
        end
    end
    serviceMethods.Teleport = function(self, placeId, player, spawn, customTeleportData)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:Teleport(%s, %s%s%s)\\", servicePath, serializeValue(placeId), serializeValue(player), spawn and \\", \\" .. serializeValue(spawn) or '\\"', customTeleportData and \\", \\" .. serializeValue(customTeleportData) or '\\"'))
    end
    serviceMethods.TeleportToPlaceInstance = function(self, placeId, instanceId, player)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:TeleportToPlaceInstance(%s, %s, %s)\\", servicePath, serializeValue(placeId), serializeValue(instanceId), serializeValue(player)))
    end
    serviceMethods.PlayLocalSound = function(self, sound)
        local servicePath = dumperState.registry[proxy] or \\"SoundService\\"
        emitOutput(string.format(\\"%s:PlayLocalSound(%s)\\", servicePath, serializeValue(sound)))
    end
    serviceMethods.IsAvailable = function(self) return true end
    serviceMethods.HasAchieved = function(self) return false end
    serviceMethods.GrantAchievement = function(self) return true end
    serviceMethods.GetDeviceCameraCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetDeviceCameraCFrameForSelfView = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.UpdateDeviceCFrame = function(self) return nil end
    serviceMethods.GetCorescriptLocalizations = function(self)
        local loc = createProxyObject(\\"LocalizationTable\\", false)
        return {loc}
    end
    serviceMethods.GetTranslatorForLocaleAsync = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = formatValue(locale or \\"en-us\\")}
        return translator
    end
    serviceMethods.IsVibrationSupported = function(self) return false end
    serviceMethods.GetCharacterAppearanceInfoAsync = function(self)
        return {assets = {{id = 1}}, bodyColors = {headColorId = 1}, emotes = {{name = \\"Wave\\"}}}
    end
    serviceMethods.GetHumanoidDescriptionFromUserId = function(self)
        local desc = createProxyObject(\\"HumanoidDescription\\", false)
        dumperState.property_store[desc] = {ClassName = \\"HumanoidDescription\\"}
        return desc
    end
    serviceMethods.GetEmotes = function(self) return {Wave = {{1}}} end
    serviceMethods.GetGroupsAsync = function(self, userId) return {} end
    serviceMethods.GetGroupInfoAsync = function(self, groupId)
        return {Id = toNumberFunction(groupId) or 0, Name = \\"Group\\", MemberCount = 0}
    end
    serviceMethods.GetMemStats = function(self)
        return {Animations = 1, Clips = 2, Tracks = 3}
    end
    serviceMethods.SetItem = function(self, key, value)
        _at.mem[formatValue(key)] = formatValue(value)
    end
    serviceMethods.GetItem = function(self, key)
        return _at.mem[formatValue(key)]
    end
    serviceMethods.RemoveItem = function(self, key)
        _at.mem[formatValue(key)] = nil
    end
    serviceMethods.AddTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        _at.tags[tagName] = _at.tags[tagName] or {}
        _at.tags[tagName][target] = true
        _at.instTags[target] = _at.instTags[target] or {}
        _at.instTags[target][tagName] = true
    end
    serviceMethods.RemoveTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        if _at.tags[tagName] then _at.tags[tagName][target] = nil end
        if _at.instTags[target] then _at.instTags[target][tagName] = nil end
    end
    serviceMethods.HasTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        return _at.instTags[target] and _at.instTags[target][tagName] == true or false
    end
    serviceMethods.GetTags = function(self, inst)
        local target = inst or proxy
        local result = {}
        for tagName in pairsFunction(_at.instTags[target] or {}) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetTagged = function(self, tag)
        local tagName = formatValue(tag)
        local result = {}
        if _at.tags[tagName] then
            for inst in pairsFunction(_at.tags[tagName]) do
                table.insert(result, inst)
            end
        end
        return result
    end
    serviceMethods.GetAllTags = function(self)
        local result = {}
        for tagName in pairsFunction(_at.tags) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetInstanceAddedSignal = function(self, tag)
        local tagName = formatValue(tag)
        if not _at.sigs[tagName] then
            local sig = createProxyObject(\\"CollectionSignal\\", false)
            dumperState.registry[sig] = \\"CollectionService:GetInstanceAddedSignal(\\" .. formatStringLiteral(tagName) .. \\")\\"
            _at.typeOverride[sig] = \\"RBXScriptSignal\\"
            _at.sigs[tagName] = sig
        end
        return _at.sigs[tagName]
    end
    serviceMethods.GetInstanceRemovedSignal = function(self, tag)
        return serviceMethods.GetInstanceAddedSignal(self, \\"__removed_\\" .. formatValue(tag))
    end
    serviceMethods.CheckForUpdate = function(self) return false end
    serviceMethods.BindAction = function(self, name, callback, createTouchButton, ...)
        local actionName = formatValue(name)
        local inputs = {...}
        _at.acts[actionName] = {inputTypes = inputs, createTouchButton = createTouchButton == true}
    end
    serviceMethods.UnbindAction = function(self, name)
        _at.acts[formatValue(name)] = nil
    end
    serviceMethods.GetAllBoundActionInfo = function(self) return _at.acts end
    serviceMethods.GetAsync = function(self, url) return \\"{}\\" end
    serviceMethods.PostAsync = function(self, url, data) return \\"{}\\" end
    serviceMethods.JSONEncode = function(self, data)
        local function encode(v)
            local tv = typeFunction(v)
            if tv == \\"string\\" then return '\\"' .. v:gsub(\\"\\\\\\", \\"\\\\\\\\\\"):gsub('\\"', '\\\\\\"') .. '\\"' end
            if tv == \\"number\\" or tv == \\"boolean\\" then return toStringFunction(v) end
            if tv == \\"table\\" then
                local isArray, maxIndex, count = true, 0, 0
                for k in pairsFunction(v) do
                    count = count + 1
                    if typeFunction(k) ~= \\"number\\" then isArray = false else maxIndex = math.max(maxIndex, k) end
                end
                local out = {}
                if isArray and maxIndex == count then
                    for i = 1, maxIndex do table.insert(out, encode(v[i])) end
                    return \\"[\\" .. table.concat(out, \\",\\") .. \\"]\\"
                end
                for k, val in pairsFunction(v) do table.insert(out, '\\"' .. toStringFunction(k) .. '\\":' .. encode(val)) end
                return \\"{\\" .. table.concat(out, \\",\\") .. \\"}\\"
            end
            return \\"null\\"
        end
        local encoded = encode(data)
        _at.json[encoded] = data
        return encoded
    end
    serviceMethods.JSONDecode = function(self, json)
        local key = formatValue(json)
        if _at.json[key] then return _at.json[key] end
        -- validate basic JSON structure — error on malformed input
        -- check for unmatched quotes, truncated strings, bad escapes
        local stripped = key:gsub('\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*\\"', '\\"\\"')
        local unmatched = key:match('\\"[^\\"]*$') -- unterminated string
        if unmatched then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        -- check for common malformed patterns
        if key:match('\\"\\\\\\"}') or key:match('[^\\\\]\\\\[^\\"\\\\/bfnrtu]') then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        if key:match(\\"^%s*%[\\") then
            local result = {}
            for value in key:gmatch('\\"?([^,\\"%[%]%s]+)\\"?') do
                local n = toNumberFunction(value)
                table.insert(result, n or value)
            end
            return result
        end
        if key:match(\\"^%s*{\\") then
            local result = {}
            for k, v in key:gmatch('\\"%s*([^\\"]-)%s*\\"%s*:%s*\\"?([^\\",}]+)\\"?') do
                result[k] = toNumberFunction(v) or (v == \\"true\\" and true) or (v == \\"false\\" and false) or v
            end
            return result
        end
        return {}
    end
    serviceMethods.GetCountryRegionForPlayerAsync = function(self, player)
        -- must be a real Player instance proxy, not coroutine/userdata/etc
        if not isProxy(player) then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        local props = dumperState.property_store[player] or {}
        if props.ClassName ~= \\"Player\\" and props.ClassName ~= \\"LocalPlayer\\" then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        return \\"US\\"
    end
    serviceMethods.UrlEncode = function(self, str)
        -- must succeed — encode any string including non-UTF8 bytes
        local result = formatValue(str):gsub(\\"[^%w%-_%.!~%*'%(%)]\\", function(c)
            return string.format(\\"%%%02X\\", string.byte(c))
        end)
        return result
    end
    serviceMethods.GetTextSize = function(self, text, size, font, frameSize)
        local width = math.max(1, #(formatValue(text or \\"\\")) * (toNumberFunction(size) or 14) * 0.5)
        return Vector2.new(width, toNumberFunction(size) or 14)
    end
    serviceMethods.GetGuiInset = function(self)
        return Vector2.new(0, 36), Vector2.new(0, 0)
    end
    serviceMethods.GetRequestQueueSize = function(self) return 0 end
    serviceMethods.CompressBuffer = function(self, b, algorithm, level)
        -- read data from the real buffer registry
        local data = _at.buffers[b] or \\"\\"
        -- return a new proper buffer object registered in _at.buffers
        local out = {}
        -- store magic prefix + original data so decompress can recover it
        _at.buffers[out] = \\"\x1f\x8b\\" .. data
        return out
    end
    serviceMethods.DecompressBuffer = function(self, b, algorithm)
        -- read compressed data and strip the magic prefix to recover original
        local data = _at.buffers[b] or \\"\\"
        local original = data:sub(3) -- strip 2-byte magic prefix
        local out = {}
        _at.buffers[out] = original
        return out
    end
    serviceMethods.GetRealPhysicsFPS = function(self) return 60 end
    serviceMethods.GetEnumItems = function(self)
        local enumPath = dumperState.registry[proxy] or \\"\\"
        local enumTypeName = enumPath:match(\\"Enum%.(.+)\\") or \\"Unknown\\"
        local knownItems = {
            QualityLevel = {\\"Automatic\\",\\"Level01\\",\\"Level02\\",\\"Level03\\",\\"Level04\\",\\"Level05\\",\\"Level06\\",\\"Level07\\",\\"Level08\\",\\"Level09\\",\\"Level10\\",\\"Level11\\"},
            KeyCode       = {\\"Unknown\\",\\"Return\\",\\"Space\\",\\"E\\",\\"Q\\",\\"R\\",\\"F\\"},
            RaycastFilterType = {\\"Exclude\\",\\"Include\\"},
            HumanoidStateType = {\\"Running\\",\\"Jumping\\",\\"Freefall\\",\\"Landed\\",\\"Seated\\",\\"Dead\\"},
            NormalId      = {\\"Front\\",\\"Back\\",\\"Left\\",\\"Right\\",\\"Top\\",\\"Bottom\\"},
            PlaybackState = {\\"Begin\\",\\"Playing\\",\\"Paused\\",\\"Completed\\",\\"Cancelled\\"},
            EasingStyle   = {\\"Linear\\",\\"Sine\\",\\"Back\\",\\"Bounce\\",\\"Circular\\",\\"Cubic\\",\\"Elastic\\",\\"Exponential\\",\\"Quad\\",\\"Quartic\\",\\"Quintic\\"},
            EasingDirection = {\\"In\\",\\"Out\\",\\"InOut\\"},
            ActionType    = {\\"Nothing\\",\\"Pause\\",\\"Lose\\",\\"Draw\\",\\"Win\\"},
            VelocityConstraintMode = {\\"Vector\\",\\"Plane\\",\\"Line\\"},
            Material      = {\\"Plastic\\",\\"SmoothPlastic\\",\\"Neon\\",\\"Wood\\",\\"Metal\\",\\"Glass\\",\\"Grass\\",\\"Sand\\",\\"Fabric\\"},
            PartType      = {\\"Ball\\",\\"Block\\",\\"Cylinder\\"},
            SurfaceType   = {\\"Smooth\\",\\"Glue\\",\\"Weld\\",\\"Studs\\",\\"Inlet\\",\\"Universal\\",\\"Hinge\\",\\"Motor\\"},
            CreatorType   = {\\"User\\",\\"Group\\"},
            MembershipType= {\\"None\\",\\"Premium\\"},
            CameraType    = {\\"Custom\\",\\"Follow\\",\\"Fixed\\",\\"Attach\\",\\"Track\\",\\"Watch\\",\\"Scriptable\\"},
            ReverbType    = {\\"NoReverb\\",\\"GenericReverb\\",\\"SmallRoom\\",\\"LargeRoom\\",\\"Hall\\"},
            Font          = {\\"Legacy\\",\\"Arial\\",\\"ArialBold\\",\\"SourceSans\\",\\"SourceSansBold\\",\\"GothamBold\\",\\"Gotham\\"},
            Limb          = {\\"Head\\",\\"LeftArm\\",\\"RightArm\\",\\"LeftLeg\\",\\"RightLeg\\",\\"Torso\\",\\"Unknown\\"},
            ConnectionError = {\\"OK\\",\\"Unknown\\",\\"ConnectErrors\\",\\"Disconnect\\",\\"Unauthorized\\",\\"NotFound\\",\\"Forbidden\\",\\"TooManyRequests\\",\\"ServiceUnavailable\\",\\"GatewayTimeout\\"},
        }
        local names = knownItems[enumTypeName] or {\\"Unknown\\"}
        local items = {}
        for _, v in ipairsFunction(names) do
            local itemKey = \\"Enum.\\" .. enumTypeName .. \\".\\" .. v
            if not _at.enum[itemKey] then
                local itemProxy = createProxyObject(itemKey, false)
                dumperState.registry[itemProxy] = itemKey
                _at.typeOverride[itemProxy] = \\"EnumItem\\"
                _at.enum[itemKey] = itemProxy
            end
            items[#items + 1] = _at.enum[itemKey]
        end
        return items
    end
    serviceMethods.GenerateGUID = function(self, includeBraces)
        local t = {}
        local template = \\"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\\"
        for c in template:gmatch(\\".\\") do
            if c == \\"x\\" then t[#t+1] = string.format(\\"%x\\", math.random(0, 15))
            elseif c == \\"y\\" then t[#t+1] = string.format(\\"%x\\", math.random(8, 11))
            else t[#t+1] = c end
        end
        local guid = table.concat(t):upper()
        return includeBraces and (\\"{\\" .. guid .. \\"}\\") or guid
    end
    serviceMethods.HttpGet = function(self, url)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP URL\\"})
        dumperState.last_http_url = resolvedUrl
        return resolvedUrl
    end
    serviceMethods.HttpPost = function(self, url, data, contentType)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP POST URL\\"})
        local resultProxy = createProxyObject(\\"HttpResponse\\", false)
        local varName = registerVariable(resultProxy, \\"httpResponse\\")
        local servicePath = dumperState.registry[proxy] or \\"HttpService\\"
        emitOutput(string.format(\\"local %s = %s:HttpPost(%s, %s, %s)\\", varName, servicePath, serializeValue(url), serializeValue(data), serializeValue(contentType)))
        dumperState.property_store[resultProxy] = {Body = \\"{}\\", StatusCode = 200, Success = true}
        return resultProxy
    end
    serviceMethods.AddItem = function(self, item, delayTime)
        local servicePath = dumperState.registry[proxy] or \\"Debris\\"
        emitOutput(string.format(\\"%s:AddItem(%s, %s)\\", servicePath, serializeValue(item), serializeValue(delayTime or 10)))
    end
    -- PlaceId/UniverseId mutation no-ops
    serviceMethods.SetPlaceId = function() end
    serviceMethods.SetUniverseId = function() end
    -- TeleportService
    serviceMethods.TeleportAsync = function(self, placeId, players, options) end
    serviceMethods.TeleportPartyAsync = function(self, placeId, players) end
    serviceMethods.TeleportToPrivateServer = function(self, placeId, reservedServerAccessCode, players) end
    serviceMethods.ReserveServer = function(self, placeId) return \\"reserved_\\"..tostring(placeId), os.time() end
    serviceMethods.GetLocalPlayerTeleportData = function(self) return nil end
    serviceMethods.GetArrivingTeleportGui = function(self) return nil end
    serviceMethods.SetTeleportGui = function(self, gui) end
    serviceMethods.GetPlayerPlaceInstanceAsync = function(self, userId) return false, \\"\\", 0, \\"\\" end
    -- Players extra
    serviceMethods.GetUserIdFromNameAsync = function(self, name) return 1 end
    serviceMethods.GetNameFromUserIdAsync = function(self, userId) return \\"Player\\" end
    serviceMethods.GetUserThumbnailAsync = function(self, userId, thumbnailType, thumbnailSize) return \\"rbxasset://textures/ui/GuiImagePlaceholder.png\\", true end
    serviceMethods.GetFriendsAsync = function(self, userId) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    serviceMethods.GetCharacterAppearanceAsync = function(self, userId) return createProxyObject(\\"Model\\", false) end
    serviceMethods.ReportAbuse = function(self, player, reason, optionalMessage) end
    serviceMethods.BanAsync = function(self, config) end
    serviceMethods.UnbanAsync = function(self, config) end
    -- Chat
    serviceMethods.Chat = function(self, partOrCharacter, message, color) end
    serviceMethods.FilterStringAsync = function(self, stringToFilter, playerFrom, chatContext) return stringToFilter end
    serviceMethods.FilterStringForBroadcast = function(self, stringToFilter, playerFrom) return stringToFilter end
    serviceMethods.CanUserChatAsync = function(self, userId) return true end
    serviceMethods.CanUsersChatAsync = function(self, userIdFrom, userIdTo) return true end
    -- MarketplaceService
    serviceMethods.PromptPurchase = function(self, player, assetId) end
    serviceMethods.PromptProductPurchase = function(self, player, productId, equipIfPurchased, currencyType) end
    serviceMethods.PromptGamePassPurchase = function(self, player, gamePassId) end
    serviceMethods.PromptPremiumPurchase = function(self, player) end
    serviceMethods.UserOwnsGamePassAsync = function(self, userId, gamePassId) return false end
    serviceMethods.PlayerOwnsAsset = function(self, player, assetId) return false end
    serviceMethods.GetProductInfo = function(self, assetId, infoType, ...)
        -- error on extra arguments
        if select(\\"#\\", ...) > 0 then
            errorFunction(\\"GetProductInfo: too many arguments\\", 2)
        end
        -- error on invalid assetId types
        local idType = typeFunction(assetId)
        if idType ~= \\"number\\" then
            errorFunction(\\"GetProductInfo: assetId must be a number, got \\" .. idType, 2)
        end
        -- error on invalid numeric IDs (negative, non-integer, out of range)
        if assetId < 1 or assetId ~= math.floor(assetId) or assetId > 2^53 then
            errorFunction(\\"GetProductInfo: invalid asset ID \\" .. tostring(assetId), 2)
        end
        return {Name=\\"Product\\", Description=\\"\\", PriceInRobux=0, AssetId=assetId, IsForSale=false, IsLimited=false, IsLimitedUnique=false, IsNew=false, IsPublicDomain=false, IsForRent=false, MinimumMembershipLevel=0, ContentRatingTypeId=0, Creator={Id=1, Name=\\"Roblox\\", CreatorType=\\"User\\"}}
    end
    serviceMethods.GetDeveloperProductsAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- BadgeService
    serviceMethods.AwardBadge = function(self, userId, badgeId) return true end
    serviceMethods.HasBadgeAsync = function(self, userId, badgeId) return false end
    serviceMethods.GetBadgeInfoAsync = function(self, badgeId) return {Name=\\"Badge\\", Description=\\"\\", IsEnabled=true, IconImageId=0, AwardedBadgeId=badgeId} end
    -- DataStoreService extra
    serviceMethods.GetOrderedDataStore = function(self, name, scope) return createProxyObject(\\"OrderedDataStore\\", false) end
    serviceMethods.ListDataStoresAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- ContentProvider
    serviceMethods.PreloadAsync = function(self, instances, callback) end
    serviceMethods.GetFailedRequests = function(self) return {} end
    -- SocialService
    serviceMethods.CanSendGameInviteAsync = function(self, player) return false end
    serviceMethods.PromptGameInvite = function(self, player) end
    serviceMethods.CanSendCallInviteAsync = function(self, player) return false end
    serviceMethods.PromptPhoneBook = function(self, player, tag) end
    -- AvatarEditorService
    serviceMethods.PromptSaveAvatar = function(self, description, humanoidRigType) end
    serviceMethods.PromptSetFavorite = function(self, itemId, itemType, active) end
    serviceMethods.GetInventoryAsync = function(self, pageSize, assetTypes) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- VoiceChatService
    serviceMethods.IsVoiceEnabledForUserIdAsync = function(self, userId) return false end
    serviceMethods.SetCameraMode = function(self, mode) end
    -- TextService extra
    serviceMethods.GetFamilyInfoAsync = function(self, assetId) return {Name=\\"Font\\", Faces={}} end
    -- PolicyService
    serviceMethods.GetPolicyInfoForPlayerAsync = function(self, player)
        return {IsSubjectToChinaPolicies=false, ArePaidRandomItemsRestricted=false, IsPaidItemTradingAllowed=true, AreAdsAllowed=true, AllowedExternalLinkReferences={}}
    end
    -- AnalyticsService
    serviceMethods.LogCustomEvent = function(self, player, eventName, customData) end
    serviceMethods.LogEconomyEvent = function(self, player, flow, currencyType, amount, endingPlayerBalance, transactionType, itemSku) end
    serviceMethods.LogFunnelStepEvent = function(self, player, funnelName, funnelSessionId, step, stepName) end
    serviceMethods.LogOnboardingFunnelStepEvent = function(self, player, step, stepName) end
    serviceMethods.LogProgressionCompleteEvent = function(self, player, progressionPathName, progressionName) end
    serviceMethods.LogProgressionEvent = function(self, player, progressionPathName, progressionName, progressionIndex) end
    -- Instance general
    serviceMethods.GetNetworkOwner = function(self) return _at.localPlayer end
    serviceMethods.SetNetworkOwner = function(self, player) end
    serviceMethods.SetNetworkOwnershipAuto = function(self) end
    serviceMethods.CanSetNetworkOwnership = function(self) return true, nil end
    serviceMethods.GetNetworkOwnershipAuto = function(self) return true end
    serviceMethods.ApplyDescription = function(self, humanoidDescription) end
    serviceMethods.GetAppliedDescription = function(self) return createProxyObject(\\"HumanoidDescription\\", false) end
    serviceMethods.ReplaceContentIds = function(self, ids, newIds) end
    serviceMethods.GetConnectedParts = function(self, recursive) return {} end
    serviceMethods.GetJoints = function(self) return {} end
    serviceMethods.GetTouchingParts = function(self) return {} end
    serviceMethods.GetNoCollisionConstraints = function(self) return {} end
    serviceMethods.SubtractAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.UnionAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.IntersectAsync = function(self, parts, cs, ms) return createProxyObject(\\"IntersectOperation\\", false) end
    serviceMethods.SeparateAsync = function(self, parts) return {} end
    serviceMethods.BreakJoints = function(self) end
    serviceMethods.MakeJoints = function(self) end
    serviceMethods.ResetOrientationToIdentity = function(self) end
    serviceMethods.GetRootPart = function(self) return proxy end
    serviceMethods.GetModelCFrame = function(self) return CFrame.new(0,0,0) end
    serviceMethods.GetModelSize = function(self) return Vector3.new(1,1,1) end
    serviceMethods.FindPartOnRay = function(self, ray, ignore, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithIgnoreList = function(self, ray, ignoreList, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithWhitelist = function(self, ray, whitelist, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.ArePartsTouchingOthers = function(self, parts, overlapIgnored) return false end
    serviceMethods.GetPartsInPart = function(self, part, overlapParams) return {} end
    -- Humanoid extra
    serviceMethods.AddAccessory = function(self, accessory) end
    serviceMethods.RemoveAccessories = function(self) end
    serviceMethods.GetAccessories = function(self) return {} end
    serviceMethods.GetLimb = function(self, part) return createProxyObject(\\"Enum.Limb.Unknown\\", false) end
    serviceMethods.GetBodyPartR15 = function(self, part) return nil end
    serviceMethods.ReplaceBodyPartR15 = function(self, bodyPart, part) return false end
    serviceMethods.BuildRigFromAttachments = function(self) end
    -- Sound extra
    serviceMethods.Resume = function(self) end
    -- Gui
    serviceMethods.TweenPosition = function(self, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSize = function(self, endSize, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSizeAndPosition = function(self, endSize, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    -- ContextActionService extra
    serviceMethods.GetButton = function(self, actionName) return nil end
    serviceMethods.LocalToolEquipped = function(self, toolEquipped) end
    serviceMethods.LocalToolUnequipped = function(self, toolUnequipped) end
    -- PathfindingService extra
    serviceMethods.FindPathAsync = function(self, start, finish) return createProxyObject(\\"Path\\", false) end
    serviceMethods.ComputeAsync = function(self, start, finish) end
    serviceMethods.GetWaypoints = function(self) return {} end
    serviceMethods.CheckOcclusionAsync = function(self, start) return {} end
    -- Camera extra
    serviceMethods.ScreenPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.ViewportPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.WorldToScreenPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.WorldToViewportPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.GetPartsObscuringTarget = function(self, castPoints, ignoreList) return {} end
    serviceMethods.Interpolate = function(self, endPos, endFocus, duration) end
    -- UserInputService extra
    serviceMethods.GetMouseLocation = function(self) return Vector2.new(0,0) end
    serviceMethods.GetMouseDelta = function(self) return Vector2.new(0,0) end
    serviceMethods.GetKeysPressed = function(self) return {} end
    serviceMethods.GetMouseButtonsPressed = function(self) return {} end
    serviceMethods.GetGamepadState = function(self, gamepadNum) return {} end
    serviceMethods.GetSupportedGamepadKeyCodes = function(self, gamepadNum) return {} end
    serviceMethods.GetConnectedGamepads = function(self) return {} end
    serviceMethods.GetLastInputType = function(self) return createProxyObject(\\"Enum.UserInputType.None\\", false) end
    serviceMethods.GetFocusedTextBox = function(self) return nil end
    serviceMethods.IsGamepadButtonDown = function(self, gamepadNum, keyCode) return false end
    serviceMethods.IsKeyDown = function(self, keyCode) return false end
    serviceMethods.IsMouseButtonPressed = function(self, mouseButton) return false end
    serviceMethods.RecenterUserHeadCFrame = function(self) end
    serviceMethods.GetDeviceRotation = function(self) return createProxyObject(\\"InputObject\\", false), CFrame.new(0,0,0) end
    serviceMethods.GetDeviceGravity = function(self) return createProxyObject(\\"InputObject\\", false) end
    -- PhysicsService
    serviceMethods.CreateCollisionGroup = function(self, name) return 0 end
    serviceMethods.RemoveCollisionGroup = function(self, name) end
    serviceMethods.CollisionGroupSetCollidable = function(self, name1, name2, collidable) end
    serviceMethods.CollisionGroupsAreCollidable = function(self, name1, name2) return true end
    serviceMethods.GetCollisionGroupId = function(self, name) return 0 end
    serviceMethods.GetCollisionGroupName = function(self, id) return \\"Default\\" end
    serviceMethods.SetPartCollisionGroup = function(self, part, name) end
    serviceMethods.GetMaxCollisionGroups = function(self) return 32 end
    serviceMethods.GetRegisteredCollisionGroups = function(self) return {} end
    -- StarterGui extra
    serviceMethods.GetCoreGuiEnabled = function(self, coreGuiType) return true end
    serviceMethods.RegisterGetCore = function(self, parameterName, getFunction) end
    serviceMethods.RegisterSetCore = function(self, parameterName, setFunction) end
    -- Lighting extra
    serviceMethods.GetAtmosphere = function(self) return nil end
    serviceMethods.GetSky = function(self) return nil end
    -- Workspace extra
    serviceMethods.GetServerTimeNow = function(self) return os.time() end
    serviceMethods.PGSIsEnabled = function(self) return true end
    serviceMethods.SetInsertPoint = function(self, point) end
    -- NetworkClient/NetworkServer
    serviceMethods.GetClientTicket = function(self) return \\"\\" end
    -- ScriptContext
    serviceMethods.AddCoreScriptLocal = function(self, name, parent) end
    serviceMethods.GetCoreScriptVersion = function(self) return \\"1.0.0\\" end
    meta.__namecall = function(self, ...) return nil end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        -- fast path: string key, check property_store and common properties before formatValue
        if typeFunction(key) == \\"string\\" then
            local ps = dumperState.property_store[proxy]
            if ps then
                local v = ps[key]
                if v ~= nil then return v end
            end
            if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
            if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
            if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
            if key == \\"Name\\" then
                if _at.typeOverride[proxy] == \\"EnumItem\\" then
                    return (formattedName or \\"\\"):match(\\"%.([^%.]+)$\\") or formattedName or \\"Object\\"
                end
                return formattedName or \\"Object\\"
            end
            if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
            if not _at.metaHooks[\\"__index\\"] then
                local sm = serviceMethods[key]
                if sm ~= nil then
                    if typeFunction(sm) == \\"function\\" then
                        local previousMethod
                        return function(_, ...)
                            previousMethod = _at.currentNamecallMethod
                            _at.currentNamecallMethod = key
                            local results = {sm(proxy, ...)}
                            _at.currentNamecallMethod = previousMethod
                            return table.unpack(results)
                        end
                    end
                    return sm
                end
            end
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local propertyName = formatValue(key)
        if _at.metaHooks[\\"__index\\"] and not _at.inMetaHook then
            _at.inMetaHook = true
            local ok, result = pcallFunction(_at.metaHooks[\\"__index\\"], proxy, key)
            _at.inMetaHook = false
            if ok and result ~= nil then return result end
        end
        if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
        if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
        if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
        -- DistributedGameTime ticking (must be before property_store read)
        if key == \\"DistributedGameTime\\" then
            if not _at._dgtClock then
                -- initialize ticking from current stored value on first access
                local props = dumperState.property_store[proxy]
                _at._dgtBase = (props and props[key]) or 1
                _at._dgtClock = osLibrary.clock()
            end
            return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
        end
        -- AT6: SurfaceAppearance ContentId properties
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName
        if className == \\"SurfaceAppearance\\" and (key == \\"ColorMap\\" or key == \\"NormalMap\\" or key == \\"RoughnessMap\\" or key == \\"MetalnessMap\\") then
            return _makeContentId(\\"\\")
        end
        if dumperState.property_store[proxy] and dumperState.property_store[proxy][key] ~= nil then
            return dumperState.property_store[proxy][key]
        end
        if serviceMethods[propertyName] then
            return function(_, ...)
                if _at.metaHooks[\\"__namecall\\"] and not _at.inMetaHook then
                    local previousMethod = _at.currentNamecallMethod
                    _at.currentNamecallMethod = propertyName
                    _at.inMetaHook = true
                    local ok, result = pcallFunction(_at.metaHooks[\\"__namecall\\"], proxy, ...)
                    _at.inMetaHook = false
                    _at.currentNamecallMethod = previousMethod
                    if ok and result ~= nil then return result end
                end
                local previousMethod = _at.currentNamecallMethod
                _at.currentNamecallMethod = propertyName
                local results = {serviceMethods[propertyName](proxy, ...)}
                _at.currentNamecallMethod = previousMethod
                return table.unpack(results)
            end
        end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName == \\"_G\\" then
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            if _G[key] ~= nil then return _G[key] end
            return nil
        end
        if key == \\"Name\\" then return formattedName or \\"Object\\" end
        if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
        if key == \\"Players\\" then return serviceMethods.GetService(game, \\"Players\\") end
        if key == \\"Workspace\\" then return workspace end
        if key == \\"LocalPlayer\\" then
            if _at.localPlayer then return _at.localPlayer end
            local lpProxy = createProxyObject(\\"LocalPlayer\\", false, proxy)
            dumperState.property_store[lpProxy] = {Name = \\"Player\\", ClassName = \\"Player\\", UserId = 1}
            _at.localPlayer = lpProxy
            local varName = registerVariable(lpProxy, \\"LocalPlayer\\")
            emitOutput(string.format(\\"local %s = %s.LocalPlayer\\", varName, pathName))
            return lpProxy
        end
        if key == \\"PlayerGui\\" then return createProxyObject(\\"PlayerGui\\", false, proxy) end
        if key == \\"Backpack\\" then return createProxyObject(\\"Backpack\\", false, proxy) end
        if key == \\"PlayerScripts\\" then return createProxyObject(\\"PlayerScripts\\", false, proxy) end
        if key == \\"UserId\\" then return 1 end
        if key == \\"DisplayName\\" then return \\"Player\\" end
        if key == \\"AccountAge\\" then return 1000 end
        if key == \\"LocaleId\\" then return \\"en-us\\" end
        if key == \\"RobloxLocaleId\\" or key == \\"SystemLocaleId\\" then return \\"en-us\\" end
        if key == \\"CharacterMaxSlopeAngle\\" then return 89 end
        if key == \\"DistanceFactor\\" then return 3.33 end
        if key == \\"CaptureBegan\\" then
            local sigProxy = createProxyObject(pathName .. \\".CaptureBegan\\", false, proxy)
            dumperState.registry[sigProxy] = pathName .. \\".CaptureBegan\\"
            _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
            return sigProxy
        end
        if key == \\"Connected\\" and _at.connState[proxy] ~= nil then return _at.connState[proxy] end
        if key == \\"Team\\" then return createProxyObject(\\"Team\\", false, proxy) end
        if key == \\"TeamColor\\" then return BrickColor.new(\\"White\\") end
        if key == \\"Character\\" then
            local charProxy = createProxyObject(\\"Character\\", false, proxy)
            dumperState.property_store[charProxy] = {Name = \\"Character\\", ClassName = \\"Model\\"}
            -- AT3: seed Animate LocalScript as child of character
            if not _at.animateScript then
                local animProxy = createProxyObject(\\"Animate\\", false, charProxy)
                dumperState.registry[animProxy] = \\"Animate\\"
                dumperState.property_store[animProxy] = {Name = \\"Animate\\", ClassName = \\"LocalScript\\", Parent = charProxy}
                _setParent(animProxy, charProxy)
                _at.animateScript = animProxy
            end
            return charProxy
        end
        if key == \\"Humanoid\\" then
            local humProxy = createProxyObject(\\"Humanoid\\", false, proxy)
            dumperState.property_store[humProxy] = {Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2}
            return humProxy
        end
        if key == \\"HumanoidRootPart\\" or key == \\"PrimaryPart\\" or key == \\"RootPart\\" then
            local rootProxy = createProxyObject(\\"HumanoidRootPart\\", false, proxy)
            dumperState.property_store[rootProxy] = {Position = Vector3.new(0, 5, 0), CFrame = CFrame.new(0, 5, 0)}
            return rootProxy
        end
        local limbNames = {\\"Head\\", \\"Torso\\", \\"UpperTorso\\", \\"LowerTorso\\", \\"RightArm\\", \\"LeftArm\\", \\"RightLeg\\", \\"LeftLeg\\", \\"RightHand\\", \\"LeftHand\\", \\"RightFoot\\", \\"LeftFoot\\"}
        for _, limb in ipairsFunction(limbNames) do
            if key == limb then return createProxyObject(key, false, proxy) end
        end
        if key == \\"Animator\\" then return createProxyObject(\\"Animator\\", false, proxy) end
        if key == \\"CurrentCamera\\" or key == \\"Camera\\" then
            local camProxy = createProxyObject(\\"Camera\\", false, proxy)
            dumperState.property_store[camProxy] = {CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080)}
            return camProxy
        end
        if key == \\"Terrain\\" then
            if not _at.terrainProxy then
                local tp = createProxyObject(\\"Terrain\\", false, proxy)
                dumperState.property_store[tp] = {ClassName=\\"Terrain\\",Name=\\"Terrain\\",Parent=proxy,WaterWaveSpeed=100,WaterWaveSize=0.5}
                _at.terrainProxy = tp
            end
            return _at.terrainProxy
        end
        if key == \\"CameraType\\" then return Enum.CameraType.Custom end
        if key == \\"CameraSubject\\" then return createProxyObject(\\"Humanoid\\", false, proxy) end
        if key == \\"DistributedGameTime\\" then
            if _at._dgtBase and _at._dgtClock then
                return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
            end
        end
        local constants = {
            Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2, HipHeight = 2,
            Transparency = 0, Mass = 1, Value = 0, TimePosition = 0, TimeLength = 1, Volume = 0.5,
            PlaybackSpeed = 1, Brightness = 1, Range = 60, Angle = 90, FieldOfView = 70, Thickness = 1,
            ZIndex = 1, LayoutOrder = 0, Gravity = 196.2, DistributedGameTime = 1, ClockTime = 14,
            FogEnd = 100000, RolloffScale = 1, MaxPlayers = 12, RespawnTime = 5, PlaceVersion = 1,
            CreatorId = 0, FollowUserId = 0, NearPlaneZ = -0.1
        }
        if constants[key] ~= nil then return constants[key] end
        if key == \\"Size\\" and not (formattedName and formattedName:match(\\"Part\\")) then return UDim2.new(1, 0, 1, 0) end
        local boolConstants = {Visible = true, Enabled = true, Anchored = false, CanCollide = true, Locked = false, Active = true, Draggable = false, Modal = false, Playing = false, Looped = false, IsPlaying = false, AutoPlay = false, Archivable = true, ClipsDescendants = false, RichText = false, TextWrapped = false, TextScaled = false, PlatformStand = false, AutoRotate = true, Sit = false}
        boolConstants.StreamingEnabled = false
        boolConstants.HttpEnabled = false
        boolConstants.Sandboxed = false
        if boolConstants[key] ~= nil then return boolConstants[key] end
        if key == \\"JobId\\" then return \\"00000000-0000-4000-8000-000000000001\\" end
        if key == \\"CreatorType\\" then return Enum.CreatorType.User end
        if key == \\"MembershipType\\" then return Enum.MembershipType.None end
        if key == \\"AmbientReverb\\" then return Enum.ReverbType.NoReverb end
        if key == \\"Ambient\\" or key == \\"OutdoorAmbient\\" then return Color3.fromRGB(128, 128, 128) end
        if key == \\"UniqueId\\" then return _getDebugId(proxy) end
        if key == \\"AbsoluteSize\\" or key == \\"ViewportSize\\" then return Vector2.new(1920, 1080) end
        if key == \\"AbsolutePosition\\" then return Vector2.new(0, 0) end
        if key == \\"Position\\" then
            if formattedName and (formattedName:match(\\"Part\\") or formattedName:match(\\"Model\\") or formattedName:match(\\"Character\\") or formattedName:match(\\"Root\\")) then return Vector3.new(0, 5, 0) end
            return UDim2.new(0, 0, 0, 0)
        end
        if key == \\"Size\\" then
            if formattedName and formattedName:match(\\"Part\\") then return Vector3.new(4, 1, 2) end
            return UDim2.new(1, 0, 1, 0)
        end
        if key == \\"CFrame\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Velocity\\" or key == \\"AssemblyLinearVelocity\\" then
            -- AT4: if a LinearVelocity constraint is attached to this part, reflect its VectorVelocity
            for _, child in ipairsFunction(_at.children[proxy] or {}) do
                local cprops = dumperState.property_store[child]
                if cprops and cprops.ClassName == \\"LinearVelocity\\" then
                    local vv = cprops.VectorVelocity
                    if vv and typeof(vv) == \\"Vector3\\" then return vv end
                end
            end
            return Vector3.new(0, 0, 0)
        end
        if key == \\"RotVelocity\\" or key == \\"AssemblyAngularVelocity\\" then
            local imp = dumperState.property_store[proxy] and dumperState.property_store[proxy][\\"_angularImpulse\\"]
            if imp and _at.vectors[imp] then
                local d = _at.vectors[imp]
                return _makeVector3(d.x, d.y, d.z)
            end
            return _makeVector3(0, 0, 0)
        end
        if key == \\"Orientation\\" or key == \\"Rotation\\" then return Vector3.new(0, 0, 0) end
        if key == \\"LookVector\\" then return Vector3.new(0, 0, -1) end
        if key == \\"RightVector\\" then return Vector3.new(1, 0, 0) end
        if key == \\"UpVector\\" then return Vector3.new(0, 1, 0) end
        if key == \\"Color\\" or key == \\"Color3\\" or key == \\"BackgroundColor3\\" or key == \\"BorderColor3\\" or key == \\"TextColor3\\" or key == \\"PlaceholderColor3\\" or key == \\"ImageColor3\\" then return Color3.new(1, 1, 1) end
        if key == \\"BrickColor\\" then return BrickColor.new(\\"Medium stone grey\\") end
        if key == \\"Material\\" then return createProxyObject(\\"Enum.Material.Plastic\\", false) end
        if key == \\"Hit\\" then return CFrame.new(0, 0, -10) end
        if key == \\"Origin\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Target\\" then return createProxyObject(\\"Target\\", false, proxy) end
        if key == \\"X\\" or key == \\"Y\\" then return 0 end
        if key == \\"UnitRay\\" then return Ray.new(Vector3.new(0, 5, 0), Vector3.new(0, 0, -1)) end
        if key == \\"ViewSizeX\\" then return 1920 end
        if key == \\"ViewSizeY\\" then return 1080 end
        if key == \\"Text\\" or key == \\"PlaceholderText\\" or key == \\"ContentText\\" or key == \\"Value\\" then
            if inputKey then return inputKey end
            if key == \\"Value\\" then return \\"input\\" end
            return '\\"'
        end
        if key == \\"TextBounds\\" then return Vector2.new(0, 0) end
        if key == \\"Font\\" then return createProxyObject(\\"Enum.Font.SourceSans\\", false) end
        if key == \\"TextSize\\" then return 14 end
        if key == \\"Image\\" or key == \\"ImageContent\\" then return '\\"' end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        local signalNames = {\\"Changed\\", \\"ChildAdded\\", \\"ChildRemoved\\", \\"DescendantAdded\\", \\"DescendantRemoving\\", \\"Touched\\", \\"TouchEnded\\", \\"InputBegan\\", \\"InputEnded\\", \\"InputChanged\\", \\"MouseButton1Click\\", \\"MouseButton1Down\\", \\"MouseButton1Up\\", \\"MouseButton2Click\\", \\"MouseButton2Down\\", \\"MouseButton2Up\\", \\"MouseEnter\\", \\"MouseLeave\\", \\"MouseMoved\\", \\"MouseWheelForward\\", \\"MouseWheelBackward\\", \\"Activated\\", \\"Deactivated\\", \\"FocusLost\\", \\"FocusGained\\", \\"Focused\\", \\"Heartbeat\\", \\"RenderStepped\\", \\"Stepped\\", \\"CharacterAdded\\", \\"CharacterRemoving\\", \\"CharacterAppearanceLoaded\\", \\"PlayerAdded\\", \\"PlayerRemoving\\", \\"AncestryChanged\\", \\"AttributeChanged\\", \\"Died\\", \\"FreeFalling\\", \\"GettingUp\\", \\"Jumping\\", \\"Running\\", \\"Seated\\", \\"Swimming\\", \\"StateChanged\\", \\"HealthChanged\\", \\"MoveToFinished\\", \\"OnClientEvent\\", \\"OnServerEvent\\", \\"OnClientInvoke\\", \\"OnServerInvoke\\", \\"Completed\\", \\"DidLoop\\", \\"Stopped\\", \\"CaptureBegan\\", \\"Button1Down\\", \\"Button1Up\\", \\"Button2Down\\", \\"Button2Up\\", \\"Idle\\", \\"Move\\", \\"TextChanged\\", \\"ReturnPressedFromOnScreenKeyboard\\", \\"Triggered\\", \\"TriggerEnded\\", \\"Error\\", \\"Event\\", \\"AxisChanged\\", \\"JumpRequest\\", \\"DevTouchMovementModeChanged\\", \\"DevComputerMovementModeChanged\\", \\"GraphicsQualityChangeRequest\\", \\"MenuOpened\\", \\"MenuClosed\\", \\"PointerAction\\", \\"TouchStarted\\", \\"TouchMoved\\", \\"TouchEnded\\", \\"TouchTap\\", \\"TouchLongPress\\", \\"TouchPinch\\", \\"TouchRotate\\", \\"TouchSwipe\\", \\"GamepadConnected\\", \\"GamepadDisconnected\\", \\"WindowFocused\\", \\"WindowFocusReleased\\"}
        for _, sig in ipairsFunction(signalNames) do
            if key == sig then
                local sigProxy = createProxyObject(pathName .. \\".\\" .. key, false, nil)
                dumperState.registry[sigProxy] = pathName .. \\".\\" .. key
                _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
                _at.signalOwner = _at.signalOwner or {}
                _at.signalOwner[sigProxy] = proxy  -- track owner without triggering _setParent
                return sigProxy
            end
        end
        return createProxyMethod(propertyName, proxy)
    end
    meta.__newindex = function(tbl, key, val)
        if key == proxyList or key == \\"__proxy_id\\" then
            rawset(tbl, key, val)
            return
        end
        -- locked: never allow mutation regardless of method
        local _lockedProps = {PlaceId=true, placeId=true, GameId=true, gameId=true, UniverseId=true}
        if _lockedProps[key] then return end
        -- read-only properties: error like real Roblox does
        local _readOnlyProps = {
            PlaybackLoudness = true,
            AbsolutePosition = true,
            AbsoluteSize = true,
            AbsoluteRotation = true,
            TextBounds = true,
            ContentText = true,
            SimulationRadius = true,
            MaxSimulationRadius = true,
            RootPriority = true,
            NativeIndex = true,
            ReceiveAge = true,
            AssemblyAngularVelocity = true,
            AssemblyLinearVelocity = true,
            AssemblyMass = true,
            AssemblyRootPart = true,
            CurrentCamera = true,
            PrivateServerOwnerId = true,
            PrivateServerId = true,
            JobId = true,
            PlaceId = true,
            GameId = true,
            PlaceVersion = true,
            UserId = true,
            FloorMaterial = true,
            MoveDirection = true,
            SeatPart = true,
        }
        if _readOnlyProps[key] then
            errorFunction(toStringFunction(key) .. \\" is not a valid member of \\" .. (dumperState.registry[proxy] or formattedName or \\"Instance\\"), 2)
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local prop = formatValue(key)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][key] = val
        local _cls2 = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if key == \\"CameraMinZoomDistance\\" then
            local n = tonumber(val) or 0; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif key == \\"CameraMaxZoomDistance\\" then
            local n = tonumber(val) or 400; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif _cls2 == \\"Terrain\\" and key == \\"WaterWaveSpeed\\" then
            local n = tonumber(val) or 100; if n > 100 then n = 100 end; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        end
        if key == \\"Parent\\" then
            _setParent(proxy, isProxy(val) and val or nil)
        end
        local className = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if className == \\"WeldConstraint\\" or className == \\"Weld\\" or className == \\"Motor6D\\" then
            if key == \\"Part0\\" or key == \\"Part1\\" then
                _at.weldRegistry[proxy] = _at.weldRegistry[proxy] or {}
                _at.weldRegistry[proxy][key] = val
                local wr = _at.weldRegistry[proxy]
                if wr.Part0 and wr.Part1 then
                    local cf0 = (dumperState.property_store[wr.Part0] or {}).CFrame
                    local cf1 = (dumperState.property_store[wr.Part1] or {}).CFrame
                    if cf0 and cf1 then
                        wr.offset = {X = (cf1.X or 0) - (cf0.X or 0), Y = (cf1.Y or 0) - (cf0.Y or 0), Z = (cf1.Z or 0) - (cf0.Z or 0)}
                    end
                end
            end
        end
        if key == \\"CFrame\\" then
            local cfVal = val
            local cfX = (cfVal and cfVal.X) or 0
            local cfY = (cfVal and cfVal.Y) or 0
            local cfZ = (cfVal and cfVal.Z) or 0
            for _, wr in pairs(_at.weldRegistry) do
                if wr.Part0 == proxy and wr.Part1 and wr.offset then
                    local nx = cfX + wr.offset.X
                    local ny = cfY + wr.offset.Y
                    local nz = cfZ + wr.offset.Z
                    local newCF
                    if type(CFrame) == \\"table\\" and type(CFrame.new) == \\"function\\" then
                        newCF = CFrame.new(nx, ny, nz)
                    elseif _makeCFrame then
                        newCF = _makeCFrame(nx, ny, nz)
                    else
                        newCF = {X = nx, Y = ny, Z = nz, Position = {X = nx, Y = ny, Z = nz}}
                    end
                    dumperState.property_store[wr.Part1] = dumperState.property_store[wr.Part1] or {}
                    dumperState.property_store[wr.Part1].CFrame = newCF
                    local posV = newCF.Position
                    dumperState.property_store[wr.Part1].Position = posV
                end
            end
        end
        emitOutput(string.format(\\"%s.%s = %s\\", pathName, prop, serializeValue(val)))
    end
    meta.__call = function(tbl, ...)
        local pathName = dumperState.registry[proxy] or formattedName or \\"func\\"
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName:match(\\"env\\") then
            return proxy
        end
        if pathName == \\"game\\" then
            errorFunction(\\"attempt to call an Instance value\\", 0)
        end
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"result\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s(%s)\\", varName, pathName, table.concat(serializedArgs, \\", \\")))
        return resultProxy
    end
    local function operatorMeta(opSymbol)
        local function metaCall(a, b)
            local proxy, meta = createProxy()
            local strA = \\"0\\"
            if a ~= nil then strA = dumperState.registry[a] or serializeValue(a) end
            local strB = \\"0\\"
            if b ~= nil then strB = dumperState.registry[b] or serializeValue(b) end
            local expression = \\"(\\" .. strA .. \\" \\" .. opSymbol .. \\" \\" .. strB .. \\")\\"
            dumperState.registry[proxy] = expression
            meta.__tostring = function() return expression end
            meta.__call = function() return proxy end
            meta.__index = function(_, k)
                if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
            end
            meta.__add = operatorMeta(\\"+\\")
            meta.__sub = operatorMeta(\\"-\\")
            meta.__mul = operatorMeta(\\"*\\")
            meta.__div = operatorMeta(\\"/\\")
            meta.__mod = operatorMeta(\\"%\\")
            meta.__pow = operatorMeta(\\"^\\")
            meta.__concat = operatorMeta(\\"..\\")
            meta.__eq = function() return false end
            meta.__lt = function() return false end
            meta.__le = function() return false end
            return proxy
        end
        return metaCall
    end
    meta.__add = operatorMeta(\\"+\\")
    meta.__sub = operatorMeta(\\"-\\")
    meta.__mul = operatorMeta(\\"*\\")
    meta.__div = operatorMeta(\\"/\\")
    meta.__mod = operatorMeta(\\"%\\")
    meta.__pow = operatorMeta(\\"^\\")
    meta.__concat = operatorMeta(\\"..\\")
    meta.__eq = function(a, b) return rawequal(a, b) end
    meta.__lt = function() return false end
    meta.__le = function() return false end
    meta.__unm = function(a)
        local proxy, meta = createProxy()
        dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
        meta.__tostring = function() return dumperState.registry[proxy] end
        return proxy
    end
    meta.__len = function() return 0 end
    meta.__tostring = function() return dumperState.registry[proxy] or formattedName or \\"Object\\" end
    meta.__pairs = function() return function() return nil end, proxy, nil end
    meta.__ipairs = meta.__pairs
    return proxy
end
local function createTypeDa(typeName, methods)
    local dc = {}
    local dd = {}
    dd.__index = function(_, key)
        if key == \\"new\\" or methods and methods[key] then
            return function(...)
                local args = {...}
                local serializedArgs = {}
                for _, val in ipairsFunction(args) do
                    table.insert(serializedArgs, serializeValue(val))
                end
                local expression = typeName .. \\".\\" .. key .. \\"(\\" .. table.concat(serializedArgs, \\", \\") .. \\")\\"
                local proxy, meta = createProxy()
                dumperState.registry[proxy] = expression
                meta.__tostring = function() return expression end
                meta.__index = function(_, k)
                    if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                    if k == \\"X\\" or k == \\"Y\\" or k == \\"Z\\" or k == \\"W\\" then return 0 end
                    if k == \\"Magnitude\\" then return 0 end
                    if k == \\"Unit\\" or k == \\"Position\\" or k == \\"CFrame\\" or k == \\"LookVector\\" or k == \\"RightVector\\" or k == \\"UpVector\\" or k == \\"Rotation\\" or k == \\"p\\" then return proxy end
                    if k == \\"R\\" or k == \\"G\\" or k == \\"B\\" then return 1 end
                    if k == \\"Width\\" or k == \\"Height\\" then return UDim.new(0, 0) end
                    if k == \\"Min\\" or k == \\"Max\\" or k == \\"Scale\\" or k == \\"Offset\\" then return 0 end
                    return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
                end
                local function opMeta(symbol)
                    return function(a, b)
                        local proxy, meta = createProxy()
                        local expr = \\"(\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\" \\" .. symbol .. \\" \\" .. (dumperState.registry[b] or serializeValue(b)) .. \\")\\"
                        dumperState.registry[proxy] = expr
                        meta.__tostring = function() return expr end
                        meta.__index = meta.__index
                        meta.__add = opMeta(\\"+\\")
                        meta.__sub = opMeta(\\"-\\")
                        meta.__mul = opMeta(\\"*\\")
                        meta.__div = opMeta(\\"/\\")
                        return proxy
                    end
                end
                meta.__add = opMeta(\\"+\\")
                meta.__sub = opMeta(\\"-\\")
                meta.__mul = opMeta(\\"*\\")
                meta.__div = opMeta(\\"/\\")
                meta.__unm = function(a)
                    local proxy, meta = createProxy()
                    dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
                    meta.__tostring = function() return dumperState.registry[proxy] end
                    return proxy
                end
                meta.__eq = function() return false end
                meta.__typeof = typeName
                return proxy
            end
        end
        return nil
    end
    dd.__call = function(_, ...) return _.new(...) end
    return setmetatable(dc, dd)
end
Vector3 = createTypeDa(\\"Vector3\\", {new = true, zero = true, one = true})
Vector2 = createTypeDa(\\"Vector2\\", {new = true, zero = true, one = true})
UDim = createTypeDa(\\"UDim\\", {new = true})
UDim2 = createTypeDa(\\"UDim2\\", {new = true, fromScale = true, fromOffset = true})
CFrame = createTypeDa(\\"CFrame\\", {new = true, Angles = true, lookAt = true, fromEulerAnglesXYZ = true, fromEulerAnglesYXZ = true, fromAxisAngle = true, fromMatrix = true, fromOrientation = true, identity = true})
Color3 = createTypeDa(\\"Color3\\", {new = true, fromRGB = true, fromHSV = true, fromHex = true})
BrickColor = createTypeDa(\\"BrickColor\\", {new = true, random = true, White = true, Black = true, Red = true, Blue = true, Green = true, Yellow = true, palette = true})
TweenInfo = createTypeDa(\\"TweenInfo\\", {new = true})
Rect = createTypeDa(\\"Rect\\", {new = true})
Region3 = createTypeDa(\\"Region3\\", {new = true})
Region3int16 = createTypeDa(\\"Region3int16\\", {new = true})
Ray = createTypeDa(\\"Ray\\", {new = true})
NumberRange = createTypeDa(\\"NumberRange\\", {new = true})
NumberSequence = createTypeDa(\\"NumberSequence\\", {new = true})
NumberSequenceKeypoint = createTypeDa(\\"NumberSequenceKeypoint\\", {new = true})
ColorSequence = createTypeDa(\\"ColorSequence\\", {new = true})
ColorSequence.new = function(...)
    local args = {...}
    local keypoints = {}
    if #args == 1 and typeFunction(args[1]) == \\"table\\" and args[1][1] ~= nil then
        keypoints = args[1]
    elseif #args == 1 then
        keypoints = {args[1], args[1]}
    elseif #args >= 2 then
        keypoints = args
    end
    local t = setmetatable({Keypoints = keypoints}, {
        __typeof = \\"ColorSequence\\",
        __tostring = function() return \\"ColorSequence\\" end,
    })
    return t
end
ColorSequenceKeypoint = createTypeDa(\\"ColorSequenceKeypoint\\", {new = true})
PhysicalProperties = createTypeDa(\\"PhysicalProperties\\", {new = true})
Font = createTypeDa(\\"Font\\", {new = true, fromEnum = true, fromName = true, fromId = true})
RaycastParams = createTypeDa(\\"RaycastParams\\", {new = true})
OverlapParams = {new = function()
        local params = {MaxParts = 0, FilterType = Enum.RaycastFilterType.Exclude, FilterDescendantsInstances = {}}
        return setmetatable(params, {__typeof = \\"OverlapParams\\"})
    end}
_makeVector3 = function(x, y, z, expr)
    x, y, z = toNumberFunction(x) or 0, toNumberFunction(y) or 0, toNumberFunction(z) or 0
    local proxy, meta = createProxy()
    local expression = expr or (\\"Vector3.new(\\" .. serializeValue(x) .. \\", \\" .. serializeValue(y) .. \\", \\" .. serializeValue(z) .. \\")\\")
    dumperState.registry[proxy] = expression
    _at.vectors[proxy] = {x = x, y = y, z = z}
    local function component(v, axis)
        local data = _at.vectors[v]
        if not data then return 0 end
        return axis == \\"X\\" and data.x or axis == \\"Y\\" and data.y or data.z
    end
    local function binary(a, b, symbol)
        local ax, ay, az = component(a, \\"X\\"), component(a, \\"Y\\"), component(a, \\"Z\\")
        local bx, by, bz
        if typeFunction(b) == \\"number\\" then bx, by, bz = b, b, b else bx, by, bz = component(b, \\"X\\"), component(b, \\"Y\\"), component(b, \\"Z\\") end
        if symbol == \\"+\\" then return _makeVector3(ax + bx, ay + by, az + bz, \\"(\\" .. serializeValue(a) .. \\" + \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"-\\" then return _makeVector3(ax - bx, ay - by, az - bz, \\"(\\" .. serializeValue(a) .. \\" - \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"*\\" then return _makeVector3(ax * bx, ay * by, az * bz, \\"(\\" .. serializeValue(a) .. \\" * \\" .. serializeValue(b) .. \\")\\") end
        return _makeVector3(bx ~= 0 and ax / bx or 0, by ~= 0 and ay / by or 0, bz ~= 0 and az / bz or 0, \\"(\\" .. serializeValue(a) .. \\" / \\" .. serializeValue(b) .. \\")\\")
    end
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(proxy, key) end
        if key == \\"X\\" then return x end
        if key == \\"Y\\" then return y end
        if key == \\"Z\\" then return z end
        if key == \\"Magnitude\\" then return math.sqrt(x * x + y * y + z * z) end
        if key == \\"Unit\\" then
            local mag = math.sqrt(x * x + y * y + z * z)
            if mag == 0 then return _makeVector3(0, 0, 0, expression .. \\".Unit\\") end
            return _makeVector3(x / mag, y / mag, z / mag, expression .. \\".Unit\\")
        end
        if key == \\"Dot\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return x * ox + y * oy + z * oz
            end
        end
        if key == \\"Cross\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return _makeVector3(y*oz - z*oy, z*ox - x*oz, x*oy - y*ox)
            end
        end
        if key == \\"Lerp\\" then
            return function(self, other, alpha)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                local a = toNumberFunction(alpha) or 0
                return _makeVector3(x + (ox-x)*a, y + (oy-y)*a, z + (oz-z)*a)
            end
        end
        if key == \\"FuzzyEq\\" then
            return function(self, other, epsilon)
                local eps = toNumberFunction(epsilon) or 1e-5
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return math.abs(x-ox) <= eps and math.abs(y-oy) <= eps and math.abs(z-oz) <= eps
            end
        end
        return 0
    end
    meta.__add = function(a, b) return binary(a, b, \\"+\\") end
    meta.__sub = function(a, b) return binary(a, b, \\"-\\") end
    meta.__mul = function(a, b) return binary(a, b, \\"*\\") end
    meta.__div = function(a, b) return binary(a, b, \\"/\\") end
    meta.__unm = function(a) return _makeVector3(-component(a, \\"X\\"), -component(a, \\"Y\\"), -component(a, \\"Z\\"), \\"(-\\" .. serializeValue(a) .. \\")\\") end
    meta.__eq = function(a, b) return component(a, \\"X\\") == component(b, \\"X\\") and component(a, \\"Y\\") == component(b, \\"Y\\") and component(a, \\"Z\\") == component(b, \\"Z\\") end
    meta.__tostring = function() return toStringFunction(x) .. \\", \\" .. toStringFunction(y) .. \\", \\" .. toStringFunction(z) end
    return proxy
end
Vector3 = {
    new = function(x, y, z) return _makeVector3(x, y, z) end,
    zero = _makeVector3(0, 0, 0, \\"Vector3.zero\\"),
    one = _makeVector3(1, 1, 1, \\"Vector3.one\\"),
    fromNormalId = function(normalId)
        local name = toStringFunction(normalId)
        if name:find(\\"Right\\")  then return _makeVector3( 1,  0,  0) end
        if name:find(\\"Left\\")   then return _makeVector3(-1,  0,  0) end
        if name:find(\\"Top\\")    then return _makeVector3( 0,  1,  0) end
        if name:find(\\"Bottom\\") then return _makeVector3( 0, -1,  0) end
        if name:find(\\"Back\\")   then return _makeVector3( 0,  0,  1) end
        if name:find(\\"Front\\")  then return _makeVector3( 0,  0, -1) end
        return _makeVector3(0, 0, 0)
    end,
    fromAxis = function(axis)
        local name = toStringFunction(axis)
        if name:find(\\"X\\") then return _makeVector3(1, 0, 0) end
        if name:find(\\"Y\\") then return _makeVector3(0, 1, 0) end
        if name:find(\\"Z\\") then return _makeVector3(0, 0, 1) end
        return _makeVector3(0, 0, 0)
    end,
}
setmetatable(Vector3, {__call = function(_, x, y, z) return _.new(x, y, z) end})
local function _valueType(typeName, fields, methods)
    local obj = fields or {}
    return setmetatable(obj, {
        __typeof = typeName,
        __index = methods or {},
        __tostring = function() return typeName end,
        __eq = function(a, b)
            if typeFunction(a) ~= \\"table\\" or typeFunction(b) ~= \\"table\\" then return false end
            local ma, mb = getMetatableFunction(a), getMetatableFunction(b)
            if not ma or not mb or ma.__typeof ~= mb.__typeof then return false end
            for k, v in pairsFunction(a) do
                if b[k] ~= v then return false end
            end
            for k, v in pairsFunction(b) do
                if a[k] ~= v then return false end
            end
            return true
        end
    })
end
local function _num(v, default) return toNumberFunction(v) or default or 0 end
local function _makeVector2(x, y)
    x, y = _num(x), _num(y)
    local methods = {}
    function methods:Dot(other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) end
    local mt
    mt = {
        __typeof = \\"Vector2\\",
        __index = function(self, key)
            if key == \\"Magnitude\\" then return math.sqrt(self.X * self.X + self.Y * self.Y) end
            if key == \\"Unit\\" then
                local mag = math.sqrt(self.X * self.X + self.Y * self.Y)
                return mag == 0 and _makeVector2(0, 0) or _makeVector2(self.X / mag, self.Y / mag)
            end
            return methods[key]
        end,
        __add = function(a, b) return _makeVector2(a.X + b.X, a.Y + b.Y) end,
        __sub = function(a, b) return _makeVector2(a.X - b.X, a.Y - b.Y) end,
        __mul = function(a, b)
            if typeFunction(a) == \\"number\\" then return _makeVector2(a * b.X, a * b.Y) end
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X * b, a.Y * b) end
            return _makeVector2(a.X * b.X, a.Y * b.Y)
        end,
        __div = function(a, b)
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X / b, a.Y / b) end
            return _makeVector2(a.X / b.X, a.Y / b.Y)
        end,
        __unm = function(a) return _makeVector2(-a.X, -a.Y) end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y end,
        __tostring = function(a) return (\\"Vector2.new(%s, %s)\\"):format(a.X, a.Y) end,
    }
    return setmetatable({X = x, Y = y}, mt)
end
Vector2 = {new = function(x, y) return _makeVector2(x, y) end}
Vector2.zero = Vector2.new(0, 0)
Vector2.one = Vector2.new(1, 1)
setmetatable(Vector2, {__call = function(_, x, y) return _.new(x, y) end})
local _oldVector3New = Vector3.new
Vector3.new = function(x, y, z)
    local v = _oldVector3New(x, y, z)
    local mt = getMetatableFunction(v)
    local oldIndex = mt.__index
    mt.__index = function(self, key)
        if key == \\"Dot\\" then
            return function(_, other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) + self.Z * (other and other.Z or 0) end
        end
        if key == \\"Cross\\" then
            return function(_, other)
                return Vector3.new(
                    self.Y * (other and other.Z or 0) - self.Z * (other and other.Y or 0),
                    self.Z * (other and other.X or 0) - self.X * (other and other.Z or 0),
                    self.X * (other and other.Y or 0) - self.Y * (other and other.X or 0)
                )
            end
        end
        return oldIndex(self, key)
    end
    return v
end
Vector3.zero = Vector3.new(0, 0, 0)
Vector3.one = Vector3.new(1, 1, 1)
UDim = {new = function(scale, offset) return _valueType(\\"UDim\\", {Scale = _num(scale), Offset = _num(offset)}) end}
setmetatable(UDim, {__call = function(_, scale, offset) return _.new(scale, offset) end})
UDim2 = {
    new = function(xs, xo, ys, yo) return _valueType(\\"UDim2\\", {X = UDim.new(xs, xo), Y = UDim.new(ys, yo)}) end,
    fromScale = function(x, y) return UDim2.new(x, 0, y, 0) end,
    fromOffset = function(x, y) return UDim2.new(0, x, 0, y) end,
}
setmetatable(UDim2, {__call = function(_, ...) return _.new(...) end})
Color3 = {
    new = function(r, g, b)
        local rv, gv, bv = _num(r), _num(g), _num(b)
        if rv < 0 or rv > 1 or gv < 0 or gv > 1 or bv < 0 or bv > 1 then
            errorFunction(\\"R, G, and B must each be in the range [0, 1]\\", 2)
        end
        return setmetatable({R = rv, G = gv, B = bv}, {
            __typeof = \\"Color3\\",
            __tostring = function(self) return string.format(\\"[R:%g, G:%g, B:%g]\\", self.R, self.G, self.B) end,
            __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.R == b.R and a.G == b.G and a.B == b.B end,
        })
    end,
    fromRGB = function(r, g, b) return Color3.new(_num(r) / 255, _num(g) / 255, _num(b) / 255) end,
    fromHSV = function(h, s, v) return Color3.new(v or 1, v or 1, v or 1) end,
    fromHex = function(hex) return Color3.fromRGB(255, 255, 255) end,
}
setmetatable(Color3, {__call = function(_, ...) return _.new(...) end})
BrickColor = {
    new = function(name)
        name = formatValue(name or \\"Medium stone grey\\")
        return _valueType(\\"BrickColor\\", {Name = name, Number = 1, Color = Color3.fromRGB(255, 0, 0)})
    end,
    random = function() return BrickColor.new(\\"Medium stone grey\\") end,
}
setmetatable(BrickColor, {__call = function(_, ...) return _.new(...) end})
NumberRange = {new = function(min, max) return _valueType(\\"NumberRange\\", {Min = _num(min), Max = max ~= nil and _num(max) or _num(min)}) end}
NumberSequence = {new = function(value) return _valueType(\\"NumberSequence\\", {Keypoints = typeFunction(value) == \\"table\\" and value or {{Time = 0, Value = _num(value)}, {Time = 1, Value = _num(value)}}}) end}
TweenInfo = {new = function(timeValue, style, direction, repeatCount, reverses, delayTime) return _valueType(\\"TweenInfo\\", {Time = _num(timeValue), EasingStyle = style or Enum.EasingStyle.Quad, EasingDirection = direction or Enum.EasingDirection.Out, RepeatCount = repeatCount or 0, Reverses = reverses or false, DelayTime = delayTime or 0}) end}
Ray = {new = function(origin, direction) return _valueType(\\"Ray\\", {Origin = origin or Vector3.zero, Direction = direction or Vector3.new(0, 0, -1)}) end}
Rect = {new = function(a, b, c, d)
    local minV = typeFunction(a) == \\"table\\" and a or Vector2.new(a, b)
    local maxV = typeFunction(c) == \\"table\\" and c or Vector2.new(c, d)
    return _valueType(\\"Rect\\", {Min = minV, Max = maxV, Width = maxV.X - minV.X, Height = maxV.Y - minV.Y})
end}
Region3 = {new = function(minVec, maxVec)
    local mn = minVec or Vector3.new(0,0,0)
    local mx = maxVec or Vector3.new(0,0,0)
    local sz = Vector3.new(mx.X - mn.X, mx.Y - mn.Y, mx.Z - mn.Z)
    return _valueType(\\"Region3\\", {CFrame = CFrame.new((mn.X+mx.X)/2,(mn.Y+mx.Y)/2,(mn.Z+mx.Z)/2), Size = sz})
end}
PhysicalProperties = {new = function(density, friction, elasticity, frictionWeight, elasticityWeight) return _valueType(\\"PhysicalProperties\\", {Density = _num(density, 1), Friction = _num(friction, 0.3), Elasticity = _num(elasticity, 0.5), FrictionWeight = _num(frictionWeight, 1), ElasticityWeight = _num(elasticityWeight, 1)}) end}
_makeCFrame = function(x, y, z)
    local ox, oy, oz = _num(x), _num(y), _num(z)
    local obj = {X = ox, Y = oy, Z = oz}
    obj.Position = Vector3.new(ox, oy, oz)
    obj.p = obj.Position
    obj.LookVector = Vector3.new(0, 0, -1)
    obj.RightVector = Vector3.new(1, 0, 0)
    obj.UpVector = Vector3.new(0, 1, 0)
    obj.Inverse = function(self) return _makeCFrame(-ox, -oy, -oz) end
    obj.ToObjectSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox2 - ox, oy2 - oy, oz2 - oz)
    end
    obj.ToWorldSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox + ox2, oy + oy2, oz + oz2)
    end
    obj.PointToObjectSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) - ox,
            (point and point.Y or 0) - oy,
            (point and point.Z or 0) - oz
        )
    end
    obj.PointToWorldSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) + ox,
            (point and point.Y or 0) + oy,
            (point and point.Z or 0) + oz
        )
    end
    return setmetatable(obj, {
        __typeof = \\"CFrame\\",
        __index = function(self, key) return rawget(self, key) end,
        __mul = function(a, b)
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"CFrame\\" then
                return _makeCFrame(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"Vector3\\" then
                return Vector3.new(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            return a
        end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y and a.Z == b.Z end,
        __tostring = function(a) return (\\"CFrame.new(%s, %s, %s)\\"):format(a.X, a.Y, a.Z) end,
    })
end
CFrame = {
    new = function(x, y, z) return _makeCFrame(x, y, z) end,
    Angles = function() return _makeCFrame(0, 0, 0) end,
    lookAt = function(origin, target) return _makeCFrame(origin and origin.X or 0, origin and origin.Y or 0, origin and origin.Z or 0) end,
    LookAt = function(origin, target) return CFrame.lookAt(origin, target) end,
    fromEulerAnglesXYZ = function() return _makeCFrame(0, 0, 0) end,
    fromEulerAnglesYXZ = function() return _makeCFrame(0, 0, 0) end,
    fromAxisAngle = function() return _makeCFrame(0, 0, 0) end,
    fromMatrix = function(pos) return _makeCFrame(pos and pos.X or 0, pos and pos.Y or 0, pos and pos.Z or 0) end,
    fromOrientation = function() return _makeCFrame(0, 0, 0) end,
}
CFrame.identity = CFrame.new(0, 0, 0)
setmetatable(CFrame, {__call = function(_, ...) return _.new(...) end})
PathWaypoint = createTypeDa(\\"PathWaypoint\\", {new = true})
Axes = createTypeDa(\\"Axes\\", {new = true})
Faces = createTypeDa(\\"Faces\\", {new = true})
Vector3int16 = createTypeDa(\\"Vector3int16\\", {new = true})
Vector2int16 = createTypeDa(\\"Vector2int16\\", {new = true})
CatalogSearchParams = createTypeDa(\\"CatalogSearchParams\\", {new = true})
DateTime = {
    now = function()
        return DateTime.fromUnixTimestamp(os.time())
    end,
    fromUnixTimestamp = function(ts)
        ts = toNumberFunction(ts) or 0
        local dt = setmetatable({UnixTimestamp = ts, UnixTimestampMillis = ts * 1000}, {
            __typeof = \\"DateTime\\",
            __index = function(self, key)
                if key == \\"UnixTimestamp\\" then return ts end
                if key == \\"UnixTimestampMillis\\" then return ts * 1000 end
                if key == \\"FormatUniversalTime\\" then
                    return function(self2, fmt, locale)
                        -- convert unix timestamp to date components
                        local t = os.date(\\"!*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"FormatLocalTime\\" then
                    return function(self2, fmt, locale)
                        local t = os.date(\\"*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"ToIsoDate\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return string.format(\\"%04d-%02d-%02dT%02d:%02d:%02dZ\\", t.year, t.month, t.day, t.hour, t.min, t.sec)
                    end
                end
                if key == \\"ToUniversalTime\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return {Year=t.year,Month=t.month,Day=t.day,Hour=t.hour,Minute=t.min,Second=t.sec,Millisecond=0}
                    end
                end
            end,
        })
        return dt
    end,
    fromUnixTimestampMillis = function(ms)
        return DateTime.fromUnixTimestamp(math.floor((toNumberFunction(ms) or 0) / 1000))
    end,
    fromIsoDate = function(iso)
        return DateTime.fromUnixTimestamp(0)
    end,
}
Random = {new = function(seed)
        local obj = {}
        function obj:NextNumber(min, max) return (min or 0) + 0.5 * ((max or 1) - (min or 0)) end
        function obj:NextInteger(min, max) return math.floor((min or 1) + 0.5 * ((max or 100) - (min or 1))) end
        function obj:NextUnitVector() return Vector3.new(0.577, 0.577, 0.577) end
        function obj:Shuffle(tab) return tab end
        function obj:Clone() return Random.new() end
        return obj
    end}
setmetatable(Random, {__call = function(_, seed) return _.new(seed) end})
Enum = createProxyObject(\\"Enum\\", true)
local enumMeta = debugLibrary.getmetatable(Enum)
enumMeta.__index = function(_, key)
    if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
    local enumName = \\"Enum.\\" .. formatValue(key)
    if not _at.enum[enumName] then
        local enumProxy = createProxyObject(enumName, false)
        dumperState.registry[enumProxy] = enumName
        _at.enum[enumName] = enumProxy
    end
    return _at.enum[enumName]
end
Instance = {new = function(className, parent)
        local name = formatValue(className)
        local _validClasses = {
            Part=1,MeshPart=1,UnionOperation=1,SpecialMesh=1,BlockMesh=1,CylinderMesh=1,
            Model=1,Folder=1,Tool=1,LocalScript=1,Script=1,ModuleScript=1,
            RemoteEvent=1,RemoteFunction=1,BindableEvent=1,BindableFunction=1,
            Frame=1,ScreenGui=1,SurfaceGui=1,BillboardGui=1,TextLabel=1,TextButton=1,
            TextBox=1,ImageLabel=1,ImageButton=1,ScrollingFrame=1,ViewportFrame=1,
            UIListLayout=1,UIGridLayout=1,UITableLayout=1,UIPadding=1,UICorner=1,
            UIStroke=1,UIScale=1,UIAspectRatioConstraint=1,UISizeConstraint=1,
            UITextSizeConstraint=1,UIFlexItem=1,UIGradient=1,UIPageLayout=1,
            Humanoid=1,HumanoidDescription=1,Animator=1,Animation=1,
            Sound=1,SoundGroup=1,Attachment=1,Motor6D=1,Weld=1,WeldConstraint=1,
            BallSocketConstraint=1,HingeConstraint=1,SpringConstraint=1,RodConstraint=1,
            RopeConstraint=1,AlignPosition=1,AlignOrientation=1,
            ForceField=1,Decal=1,Texture=1,SelectionBox=1,SelectionSphere=1,
            PointLight=1,SpotLight=1,SurfaceLight=1,Sky=1,Atmosphere=1,Clouds=1,
            Beam=1,Trail=1,ParticleEmitter=1,Fire=1,Smoke=1,Sparkles=1,
            Camera=1,Backpack=1,Hat=1,Accessory=1,Shirt=1,Pants=1,ShirtGraphic=1,
            CharacterMesh=1,BodyColors=1,
            IntValue=1,StringValue=1,BoolValue=1,NumberValue=1,Vector3Value=1,
            CFrameValue=1,Color3Value=1,ObjectValue=1,RayValue=1,BrickColorValue=1,
            ClickDetector=1,ProximityPrompt=1,Dialog=1,DialogChoice=1,
            SpawnLocation=1,SeatPart=1,VehicleSeat=1,
            WedgePart=1,CornerWedgePart=1,TrussPart=1,
            IntersectOperation=1,NegateOperation=1,
            PathfindingLink=1,PathfindingModifier=1,
            Configuration=1,LocalizationTable=1,
            NoCollisionConstraint=1,RigidConstraint=1,
            EditableMesh=1,EditableImage=1,
            LinearVelocity=1,AngularVelocity=1,LineForce=1,VectorForce=1,Torque=1,
            SurfaceAppearance=1,SpecialMesh=1,SelectionBox=1,
        }
        if not _validClasses[name] then
            errorFunction(\\"Unable to create an Instance of type \\\"\\" .. name .. \\"\\\"\\", 2)
        end
        local proxy = createProxyObject(name, false)
        local varName = registerVariable(proxy, name)
        -- class-specific default properties
        local _classDefaults = {
            SkateboardController = {Steer=0, Throttle=0},
            BallSocketConstraint = {LimitsEnabled=false, UpperAngle=45, TwistLimitsEnabled=false, TwistLowerAngle=-45, TwistUpperAngle=45, MaxFrictionTorque=0, Restitution=0},
            HingeConstraint     = {LimitsEnabled=false, UpperAngle=45, LowerAngle=-45, AngularVelocity=0, MotorMaxTorque=0, Restitution=0},
            SpringConstraint    = {Coilcount=5, Damping=1, FreeLength=5, LimitsEnabled=false, MaxLength=5, MinLength=0, Stiffness=100, Visible=false},
            RodConstraint       = {Length=5, LimitAngle0=0, LimitAngle1=0},
            RopeConstraint      = {Length=5},
            PrismaticConstraint = {LimitsEnabled=false, UpperLimit=5, LowerLimit=0, Velocity=0},
            TorsionSpringConstraint = {Damping=1, Stiffness=100, Restitution=0},
            WeldConstraint      = {},
            Motor6D             = {CurrentAngle=0, DesiredAngle=0, MaxVelocity=0},
            ForceField          = {Visible=true},
            Sound               = {Volume=0.5, PlaybackSpeed=1, TimePosition=0, IsPlaying=false, IsPaused=false, Looped=false, RollOffMaxDistance=10000, RollOffMinDistance=10},
            ScreenGui           = {Enabled=true, DisplayOrder=0, IgnoreGuiInset=false, ResetOnSpawn=true},
            Frame               = {BackgroundTransparency=0, BorderSizePixel=1, Visible=true, ZIndex=1, LayoutOrder=0},
            TextLabel           = {Text=\\"\\", TextTransparency=0, TextSize=14, TextWrapped=false, RichText=false, BackgroundTransparency=0, Visible=true, ZIndex=1},
            TextButton          = {Text=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, Modal=false},
            TextBox             = {Text=\\"\\", PlaceholderText=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, ClearTextOnFocus=true},
            ImageLabel          = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            ImageButton         = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            Part                = {Anchored=false, CanCollide=true, Locked=false, Transparency=0, Reflectance=0, Mass=1},
            MeshPart            = {Anchored=false, CanCollide=true, Transparency=0},
            Humanoid            = {Health=100, MaxHealth=100, WalkSpeed=16, JumpPower=50, JumpHeight=7.2, HipHeight=2, AutoRotate=true, PlatformStand=false},
            RemoteEvent         = {},
            RemoteFunction      = {},
            BindableEvent       = {},
            BindableFunction    = {},
            Animator            = {},
            LocalizationTable   = {SourceLocaleId=\\"en-us\\"},
            Animation           = {AnimationId=\\"\\"},
            Attachment          = {},
            AlignPosition       = {RigidityEnabled=false, MaxForce=1e6, MaxVelocity=1e6, Responsiveness=200},
            AlignOrientation    = {RigidityEnabled=false, MaxTorque=1e6, MaxAngularVelocity=1e6, Responsiveness=200},
            LinearVelocity      = {MaxForce=0, VectorVelocity=nil, VelocityConstraintMode=nil, Attachment0=nil},
            SurfaceAppearance   = {ColorMap=nil, NormalMap=nil, RoughnessMap=nil, MetalnessMap=nil},
        }
        local defaults = _classDefaults[name] or {}
        defaults.ClassName = name
        defaults.Name = name
        defaults.Archivable = true
        dumperState.property_store[proxy] = defaults
        if parent then
            local parentPath = dumperState.registry[parent] or serializeValue(parent)
            emitOutput(string.format(\\"local %s = Instance.new(%s, %s)\\", varName, formatStringLiteral(name), parentPath))
            _setParent(proxy, parent)
        else
            emitOutput(string.format(\\"local %s = Instance.new(%s)\\", varName, formatStringLiteral(name)))
        end
        return proxy
    end}
game = createProxyObject(\\"game\\", true)
workspace = createProxyObject(\\"workspace\\", true)
script = createProxyObject(\\"script\\", true)
dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
local function seedCoreRobloxInstances()
    dumperState.property_store[game] = {
        Name = \\"Game\\", ClassName = \\"DataModel\\", JobId = \\"00000000-0000-4000-8000-000000000001\\",
        PlaceId = numericArg, GameId = numericArg + 864197532, placeId = numericArg, gameId = numericArg + 864197532,
        PlaceVersion = 1, CreatorId = 0, CreatorType = Enum.CreatorType.User
    }
    dumperState.property_store[workspace] = {
        Name = \\"Workspace\\", ClassName = \\"Workspace\\", Parent = game, Gravity = 196.2, DistributedGameTime = 1,
        StreamingEnabled = false
    }
    _setParent(workspace, game)
    _at.svcCache.Workspace = workspace

    local players = _at.svcCache.Players or createProxyObject(\\"Players\\", false, game)
    _at.svcCache.Players = players
    dumperState.registry[players] = \\"Players\\"
    dumperState.property_store[players] = {Name = \\"Players\\", ClassName = \\"Players\\", Parent = game, MaxPlayers = 12, RespawnTime = 5}
    _setParent(players, game)

    local lp = _at.localPlayer or createProxyObject(\\"LocalPlayer\\", false, players)
    _at.localPlayer = lp
    dumperState.registry[lp] = \\"LocalPlayer\\"
    dumperState.property_store[lp] = {
        Name = \\"Player\\", ClassName = \\"Player\\", Parent = players, UserId = 1, DisplayName = \\"Player\\",
        MembershipType = Enum.MembershipType.None, FollowUserId = 0, AccountAge = 1000,
        CameraMinZoomDistance = 0, CameraMaxZoomDistance = 400,
        AutoJumpEnabled = true, Neutral = true, Team = nil, LocaleId = \\"en-us\\",
        SimulationRadius = 0, MaxSimulationRadius = 0,
    }
    _setParent(lp, players)

    local function ensureChild(parent, name, className, props)
        local child = createProxyObject(name, false, parent)
        dumperState.registry[child] = name
        props = props or {}
        props.Name = props.Name or name
        props.ClassName = props.ClassName or className or name
        props.Parent = parent
        dumperState.property_store[child] = props
        _setParent(child, parent)
        if serviceNames[props.ClassName] then
            _at.svcCache[props.ClassName] = child
        end
        return child
    end

    ensureChild(lp, \\"PlayerGui\\", \\"PlayerGui\\")
    ensureChild(lp, \\"Backpack\\", \\"Backpack\\")
    local playerScripts = ensureChild(lp, \\"PlayerScripts\\", \\"PlayerScripts\\")
    ensureChild(playerScripts, \\"PlayerModule\\", \\"ModuleScript\\")
    ensureChild(playerScripts, \\"RbxCharacterSounds\\", \\"LocalScript\\")
    ensureChild(workspace, \\"Camera\\", \\"Camera\\", {
        CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080),
        CameraType = Enum.CameraType.Custom, NearPlaneZ = -0.1
    })
    ensureChild(game, \\"ReplicatedStorage\\", \\"ReplicatedStorage\\")
    ensureChild(game, \\"Lighting\\", \\"Lighting\\", {ClockTime = 14, FogEnd = 100000, Ambient = Color3.fromRGB(128, 128, 128), OutdoorAmbient = Color3.fromRGB(128, 128, 128)})
    ensureChild(game, \\"SoundService\\", \\"SoundService\\", {RolloffScale = 1, AmbientReverb = Enum.ReverbType.NoReverb})
    ensureChild(game, \\"RunService\\", \\"RunService\\")
    ensureChild(game, \\"TweenService\\", \\"TweenService\\")
    ensureChild(game, \\"HttpService\\", \\"HttpService\\", {HttpEnabled = false})
    local networkClient = ensureChild(game, \\"NetworkClient\\", \\"NetworkClient\\")
    ensureChild(networkClient, \\"ClientReplicator\\", \\"ClientReplicator\\")
    local ugc = ensureChild(game, \\"Ugc\\", \\"Folder\\")
    ensureChild(ugc, \\"Chat\\", \\"Chat\\")
    ensureChild(game, \\"CollectionService\\", \\"CollectionService\\")
    ensureChild(game, \\"TextService\\", \\"TextService\\")
    ensureChild(game, \\"GuiService\\", \\"GuiService\\")
    ensureChild(game, \\"ContentProvider\\", \\"ContentProvider\\")
end
seedCoreRobloxInstances()
task = {
    wait = function(sec)
        if sec then emitOutput(string.format(\\"task.wait(%s)\\", serializeValue(sec))) else emitOutput(\\"task.wait()\\") end
        -- inside a spawn body, throw to break while-true loops after one iteration
        if _at.spawnDepth and _at.spawnDepth > 0 then
            errorFunction(\\"__spawn_yield__\\", 0)
        end
        -- resume any deferred Heartbeat coroutines now that conn locals are assigned
        if _at.pendingHeartbeat and #_at.pendingHeartbeat > 0 then
            local pending = _at.pendingHeartbeat
            _at.pendingHeartbeat = {}
            for _, co in ipairs(pending) do
                pcall(coroutine.resume, co)
            end
        end
        for inst, props in pairsFunction(dumperState.property_store) do
            if props.ClassName == \\"Part\\" and props.Anchored == false and _at.vectors[props.Position] then
                local v = _at.vectors[props.Position]
                props.Position = Vector3.new(v.x, v.y - 1, v.z)
            end
        end
        return sec or 0.03, osLibrary.clock()
    end,
    spawn = function(func, ...)
        local args = {...}
        emitOutput(\\"task.spawn(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        elseif typeFunction(func) == \\"thread\\" then
            xpcallFunction( function() coroutine.resume(func, table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        local co = coroutine.create(function() end)
        _at.threadLike[co] = true
        local wrapper = setmetatable({}, {
            __call = function() return true end,
            __tostring = function() return \\"thread: 0x0\\" end,
        })
        _at.threadLike[wrapper] = true
        return wrapper
    end,
    delay = function(sec, func, ...)
        local args = {...}
        emitOutput(string.format(\\"task.delay(%s, function()\\", serializeValue(sec or 0)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    defer = function(func, ...)
        local args = {...}
        emitOutput(\\"task.defer(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    cancel = function(thread) emitOutput(\\"task.cancel(thread)\\") end,
    synchronize = function() emitOutput(\\"task.synchronize()\\") end,
    desynchronize = function() emitOutput(\\"task.desynchronize()\\") end
}
wait = function(sec)
    if sec then emitOutput(string.format(\\"wait(%s)\\", serializeValue(sec))) else emitOutput(\\"wait()\\") end
    task.wait(sec)
    return sec or 0.03, osLibrary.clock()
end
delay = function(sec, func)
    emitOutput(string.format(\\"delay(%s, function()\\", serializeValue(sec or 0)))
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then xpcallFunction(func, function() end) end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
spawn = function(func)
    emitOutput(\\"spawn(function()\\")
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then
        -- limit spawn bodies: run once then break out of any while true
        local _spawnDepth = (_at.spawnDepth or 0) + 1
        if _spawnDepth <= 2 then
            _at.spawnDepth = _spawnDepth
            xpcallFunction(func, function() end)
            _at.spawnDepth = _spawnDepth - 1
        end
    end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
tick = function() return osLibrary.time() end
time = function() return osLibrary.clock() end
elapsedTime = function() return osLibrary.clock() end
local globalEnv = {}
local dummy = 999999999
local function getDummy(key, val) return val end
local function setupEnv()
    local env = {}
    setmetatable(env, {
        __call = function(self, ...) return self end,
        __index = function(self, key)
            if _G[key] ~= nil then return getDummy(key, _G[key]) end
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            return nil
        end,
        __newindex = function(self, key, val)
            _G[key] = val
            globalEnv[key] = 0
            emitOutput(string.format(\\"_G.%s = %s\\", formatValue(key), serializeValue(val)))
        end
    })
    return env
end
_G.G = setupEnv()
_G.g = setupEnv()
_G.ENV = setupEnv()
_G.env = setupEnv()
_G.E = setupEnv()
_G.e = setupEnv()
_G.L = setupEnv()
_G.l = setupEnv()
_G.F = setupEnv()
_G.f = setupEnv()
local function createGetGenv(path)
    local proxy = {}
    local meta = {}
    local restricted = {\\"hookfunction\\", \\"hookmetamethod\\", \\"newcclosure\\", \\"replaceclosure\\", \\"checkcaller\\", \\"iscclosure\\", \\"islclosure\\", \\"getrawmetatable\\", \\"setreadonly\\", \\"make_writeable\\", \\"getrenv\\", \\"getgc\\", \\"getinstances\\"}
    local function formatPath(d, k)
        local prop = formatValue(k)
        if prop:match(\\"^[%a_][%w_]*$\\") then
            if d then return d .. \\".\\" .. prop end
            return prop
        else
            local escaped = prop:gsub(\\"'\\", \\"\\\\\\\\'\\")
            if d then return d .. \\"['\\" .. escaped .. \\"']\\" end
            return \\"['\\" .. escaped .. \\"']\\"
        end
    end
    meta.__index = function(_, key)
        if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
        return _G[key]
    end
    meta.__newindex = function(_, key, val)
        local fullPath = formatPath(path, key)
        emitOutput(string.format(\\"getgenv().%s = %s\\", fullPath, serializeValue(val)))
    end
    meta.__call = function() return proxy end
    meta.__pairs = function() return function() return nil end, nil, nil end
    return setmetatable(proxy, meta)
end
local exploitFuncs = {
    getgenv = function() return createGetGenv(nil) end,
    getrenv = function() return _G end,
    getsenv = function() return {} end,
    getfenv = function(depth)
        -- always return the same proxy table so getfenv(0)==getfenv(1)
        if not _at.fenvCache then
            _at.fenvCache = setmetatable({}, {
                __index = function(_, key)
                    if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
                    return _G[key]
                end,
                __newindex = function(_, k, v) rawset(_, k, v) end
            })
        end
        return _at.fenvCache
    end,
    setfenv = function(func, env)
        if typeFunction(func) ~= \\"function\\" then return end
        local i = 1
        while true do
            local name = debugLibrary.getupvalue(func, i)
            if name == \\"_ENV\\" then debugLibrary.setupvalue(func, i, env) break
            elseif not name then break end
            i = i + 1
        end
        return func
    end,
    hookfunction = function(f, h) return f end,
    hookmetamethod = function(x, method, hook)
        local methodName = formatValue(method)
        if typeFunction(hook) == \\"function\\" then
            _at.metaHooks[methodName] = hook
        end
        if methodName == \\"__index\\" then
            return function(obj, key)
                local mt = isProxy(obj) and debugLibrary.getmetatable(obj)
                if mt and typeFunction(mt.__index) == \\"function\\" then
                    local saved = _at.metaHooks[methodName]
                    _at.metaHooks[methodName] = nil
                    local ok, result = pcallFunction(mt.__index, obj, key)
                    _at.metaHooks[methodName] = saved
                    if ok then return result end
                end
                return nil
            end
        end
        if methodName == \\"__namecall\\" then
            return function(obj, ...)
                local methodToCall = _at.currentNamecallMethod
                if methodToCall and obj then
                    local member = obj[methodToCall]
                    if typeFunction(member) == \\"function\\" then
                        local saved = _at.metaHooks[methodName]
                        _at.metaHooks[methodName] = nil
                        local ok, result = pcallFunction(member, obj, ...)
                        _at.metaHooks[methodName] = saved
                        if ok then return result end
                    end
                end
                return nil
            end
        end
        return function() end
    end,
    getrawmetatable = function(x)
        if isProxy(x) then
            -- all Instance proxies share ONE metatable so rawequal(mt1,mt2)==true
            if not _at.sharedInstanceMeta then
                local mt = {}
                -- __index must be a C function so debug.getinfo says what==\\"C\\"
                -- use a newproxy userdata with a C-backed metatable trick:
                -- we tag a wrapper as cclosure so getinfo returns \\"C\\"
                local indexFn = function() end
                if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
                _at.cclosureSet[indexFn] = true
                mt.__index = indexFn
                mt.__newindex = function() end
                mt.__namecall = function() end
                mt.__len = function() return 0 end
                mt.__tostring = function() return \\"Instance\\" end
                _at.sharedInstanceMeta = mt
            end
            return _at.sharedInstanceMeta
        end
        return getmetatable(x) or {}
    end,
    setrawmetatable = function(x, mt) return x end,
    getnamecallmethod = function() return _at.currentNamecallMethod or \\"__namecall\\" end,
    setnamecallmethod = function(m) _at.currentNamecallMethod = formatValue(m) end,
    checkcaller = function() return true end,
    islclosure = function(f)
        if isProxy(f) then return false end
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return false end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return false end
        return false
    end,
    iscclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return true end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return true end
        return false
    end,
    newcclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return f end
        if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
        local wrapper = function(...) return f(...) end
        _at.cclosureSet[wrapper] = true
        return wrapper
    end,
    clonefunction = function(f) return f end,
    request = function(req)
        emitOutput(string.format(\\"request(%s)\\", serializeValue(req)))
        table.insert(dumperState.string_refs, {value = req.Url or req.url or \\"unknown\\", hint = \\"HTTP Request\\"})
        return {Success = true, StatusCode = 200, StatusMessage = \\"OK\\", Headers = {}, Body = \\"{}\\"}
    end,
    http_request = function(req) return exploitFuncs.request(req) end,
    syn = {request = function(req) return exploitFuncs.request(req) end},
    http = {request = function(req) return exploitFuncs.request(req) end},
    HttpPost = function(url, data)
        emitOutput(string.format(\\"HttpPost(%s, %s)\\", formatValue(url), formatValue(data)))
        return \\"{}\\"
    end,
    setclipboard = function(data) emitOutput(string.format(\\"setclipboard(%s)\\", serializeValue(data))) end,
    getclipboard = function() return '\\"' end,
    identifyexecutor = function() return \\"FlameDumperV1\\", \\"1.0\\" end,
    getexecutorname = function() return \\"FlameDumperV1\\" end,
    gethui = function()
        local hui = createProxyObject(\\"HiddenUI\\", false)
        registerVariable(hui, \\"HiddenUI\\")
        emitOutput(string.format(\\"local %s = gethui()\\", dumperState.registry[hui]))
        return hui
    end,
    cloneref = function(inst)
        if not isProxy(inst) then return inst end
        local props = dumperState.property_store[inst] or {}
        local className = props.ClassName or dumperState.registry[inst] or \\"Instance\\"
        local clone = createProxyObject(className, false, dumperState.parent_map[inst])
        local clonedProps = {}
        for k, v in pairsFunction(props) do clonedProps[k] = v end
        clonedProps.ClassName = clonedProps.ClassName or className
        clonedProps.Name = clonedProps.Name or props.Name or className
        dumperState.property_store[clone] = clonedProps
        dumperState.registry[clone] = (dumperState.registry[inst] or className) .. \\"_cloneref\\"
        _at.refBase[clone] = _at.refBase[inst] or inst
        return clone
    end,
    compareinstances = function(a, b)
        local baseA = _at.refBase[a] or a
        local baseB = _at.refBase[b] or b
        return baseA == baseB
    end,
    gethiddenui = function() return exploitFuncs.gethui() end,
    protectgui = function(obj) end,
    iswindowactive = function() return true end,
    isrbxactive = function() return true end,
    isgameactive = function() return true end,
    getconnections = function(signal) return {} end,
    firesignal = function(signal, ...) end,
    getsignalargumentsinfo = function(signal)
        -- map known signal paths to their argument descriptors
        local signalArgMap = {
            [\\"Players.PlayerAdded\\"]          = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerRemoving\\"]       = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerMembershipChanged\\"] = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Humanoid.Died\\"]                = {},
            [\\"Humanoid.HealthChanged\\"]       = {{Name=\\"health\\", Type=\\"number\\"}},
            [\\"Humanoid.StateChanged\\"]        = {{Name=\\"old\\", Type=\\"EnumItem\\"}, {Name=\\"new\\", Type=\\"EnumItem\\"}},
            [\\"BasePart.Touched\\"]             = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"BasePart.TouchEnded\\"]          = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"RunService.Heartbeat\\"]         = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.RenderStepped\\"]     = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.Stepped\\"]           = {{Name=\\"time\\", Type=\\"number\\"}, {Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"UserInputService.InputBegan\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputEnded\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputChanged\\"]= {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"RemoteEvent.OnClientEvent\\"]    = {{Name=\\"args\\", Type=\\"Tuple\\"}},
            [\\"BindableEvent.Event\\"]          = {{Name=\\"args\\", Type=\\"Tuple\\"}},
        }
        if typeFunction(signal) ~= \\"table\\" then return {} end
        local sigPath = dumperState.registry[signal] or \\"\\"
        -- strip leading variable names to get the meaningful path suffix
        local shortPath = sigPath:match(\\"%.(.+)$\\") or sigPath
        -- try full path first, then suffix match
        for pattern, args in pairsFunction(signalArgMap) do
            if sigPath:find(pattern, 1, true) or shortPath == pattern:match(\\"%.(.+)$\\") then
                return args
            end
        end
        -- generic fallback: return empty table (signal exists but unknown args)
        return {}
    end,
    fireclickdetector = function(detector, dist) end,
    fireproximityprompt = function(prompt) end,
    firetouchinterest = function(a, b, c) end,
    getinstances = function()
        local instances = {}
        for inst in pairsFunction(dumperState.property_store) do
            if isProxy(inst) and (dumperState.property_store[inst].ClassName or dumperState.registry[inst]) then
                table.insert(instances, inst)
            end
        end
        if #instances == 0 then table.insert(instances, game) end
        return instances
    end,
    getnilinstances = function() return {} end,
    getgc = function() return {} end,
    getscripts = function() return {} end,
    getrunningscripts = function()
        -- AT3: must include the Animate script from character, but NOT arbitrary LocalScript instances
        local result = {}
        if _at.animateScript then result[#result+1] = _at.animateScript end
        return result
    end,
    getloadedmodules = function() return {} end,
    getcallingscript = function() return script end,
    readfile = function(file)
        emitOutput(string.format(\\"readfile(%s)\\", formatStringLiteral(file)))
        return _at.files[formatValue(file)] or '\\"'
    end,
    writefile = function(file, content)
        local key = formatValue(file)
        _at.files[key] = formatValue(content)
        _at.files_hidden = _at.files_hidden or {}
        _at.files_hidden[key] = true  -- mark as hidden from listfiles
        emitOutput(string.format(\\"writefile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    appendfile = function(file, content)
        local name = formatValue(file)
        _at.files[name] = (_at.files[name] or \\"\\") .. formatValue(content)
        emitOutput(string.format(\\"appendfile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    loadfile = function(file) return function() return createProxyObject(\\"loaded_file\\", false) end end,
    listfiles = function(folder)
        local base = formatValue(folder or \\"\\")
        -- normalize: strip leading slash so \\"/\\" matches all files
        base = base:gsub(\\"^/+\\", \\"\\")
        local result = {}
        for name in pairsFunction(_at.folders) do
            if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
        end
        for name in pairsFunction(_at.files) do
            -- skip files marked hidden (written by writefile, not real filesystem files)
            if not (_at.files_hidden and _at.files_hidden[name]) then
                if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
            end
        end
        return result
    end,
    isfile = function(file) return _at.files[formatValue(file)] ~= nil end,
    isfolder = function(folder) return _at.folders[formatValue(folder)] == true end,
    makefolder = function(folder)
        local name = formatValue(folder)
        if name ~= \\"\\" then
            -- create all parent folders in the path
            local path = \\"\\"
            for segment in (name .. \\"/\\"):gmatch(\\"([^/]+)/\\") do
                path = path == \\"\\" and segment or (path .. \\"/\\" .. segment)
                _at.folders[path] = true
            end
        end
        emitOutput(string.format(\\"makefolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfolder = function(folder)
        local name = formatValue(folder)
        _at.folders[name] = nil
        emitOutput(string.format(\\"delfolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfile = function(file)
        _at.files[formatValue(file)] = nil
        emitOutput(string.format(\\"delfile(%s)\\", formatStringLiteral(file)))
    end,
    DrawingImmediate = (function()
        local function makePaint()
            local cbs = {}
            return {
                Connect = function(self, fn)
                    cbs[#cbs+1] = fn
                    -- return plain table so typeof(cn)==\\"table\\" passes the AT check
                    return {
                        Disconnect = function(self)
                            for i,v in ipairs(cbs) do if v==fn then table.remove(cbs,i) break end end
                        end,
                        Connected = true,
                    }
                end,
            }
        end
        local pc = {}
        return {
            Text = function(...) emitOutput(\\"DrawingImmediate.Text(...)\\") end,
            Line = function(...) emitOutput(\\"DrawingImmediate.Line(...)\\") end,
            Circle = function(...) emitOutput(\\"DrawingImmediate.Circle(...)\\") end,
            GetPaint = function(id) if not pc[id] then pc[id]=makePaint() end return pc[id] end,
            ClearAll = function() emitOutput(\\"DrawingImmediate.ClearAll()\\") end,
        }
    end)(),
    Drawing = {
        new = function(type)
            local t = formatValue(type)
            local proxy = createProxyObject(\\"Drawing_\\" .. t, false)
            registerVariable(proxy, t)
            _at.userdata[proxy] = \\"renderobj\\"
            emitOutput(string.format(\\"local %s = Drawing.new(%s)\\", dumperState.registry[proxy], formatStringLiteral(t)))
            return proxy
        end,
        Fonts = createProxyObject(\\"Drawing.Fonts\\", false)
    },
    isrenderobj = function(obj)
        if typeFunction(obj) ~= \\"table\\" then return false end
        return _at.userdata[obj] == \\"renderobj\\"
    end,
    crypt = {
        base64encode = function(s) return s end,
        base64decode = function(s) return s end,
        base64_encode = function(s) return s end,
        base64_decode = function(s) return s end,
        encrypt = function(s, k) return s end,
        decrypt = function(s, k) return s end,
        hash = function(s) return \\"hash\\" end,
        generatekey = function(len) return string.rep(\\"0\\", len or 32) end,
        generatebytes = function(len) return string.rep(\\"\\\\0\\", len or 16) end
    },
    base64_encode = function(s) return s end,
    base64_decode = function(s) return s end,
    base64encode = function(s) return s end,
    base64decode = function(s) return s end,
    mouse1click = function() emitOutput(\\"mouse1click()\\") end,
    mouse1press = function() emitOutput(\\"mouse1press()\\") end,
    mouse1release = function() emitOutput(\\"mouse1release()\\") end,
    mouse2click = function() emitOutput(\\"mouse2click()\\") end,
    mouse2press = function() emitOutput(\\"mouse2press()\\") end,
    mouse2release = function() emitOutput(\\"mouse2release()\\") end,
    mousemoverel = function(x, y) emitOutput(string.format(\\"mousemoverel(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousemoveabs = function(x, y) emitOutput(string.format(\\"mousemoveabs(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousescroll = function(delta) emitOutput(string.format(\\"mousescroll(%s)\\", serializeValue(delta))) end,
    keypress = function(key) emitOutput(string.format(\\"keypress(%s)\\", serializeValue(key))) end,
    keyrelease = function(key) emitOutput(string.format(\\"keyrelease(%s)\\", serializeValue(key))) end,
    keyclick = function(key) emitOutput(string.format(\\"keyclick(%s)\\", serializeValue(key))) end,
    isreadonly = function(t) return false end,
    setreadonly = function(t, val) return t end,
    make_writeable = function(t) return t end,
    make_readonly = function(t) return t end,
    getthreadidentity = function() return 7 end,
    setthreadidentity = function(id) end,
    getidentity = function() return 7 end,
    setidentity = function(id) end,
    getthreadcontext = function() return 7 end,
    setthreadcontext = function(id) end,
    getcustomasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getsynasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getinfo = function(func) return {source = \\"=\\", what = \\"Lua\\", name = \\"unknown\\", short_src = \\"dumper\\"} end,
    getconstants = function(func) return {} end,
    getupvalues = function(func) return {} end,
    getprotos = function(func) return {} end,
    getupvalue = function(func, i) return nil end,
    setupvalue = function(func, i, val) end,
    setconstant = function(func, i, val) end,
    getconstant = function(func, i) return nil end,
    getproto = function(func, i) return function() end end,
    setproto = function(func, i, f) end,
    getstack = function(level, i) return nil end,
    setstack = function(level, i, val) end,
    debug = {
        getinfo = function(func, ...)
            if func == print or func == _G.print or func == warn or func == _G.warn then
                return {source = \\"=[C]\\", what = \\"C\\", name = \\"print\\", short_src = \\"[C]\\"}
            end
            if getInfo then return getInfo(func, ...) end
            return {source = \\"=[C]\\", what = \\"C\\", short_src = \\"[C]\\"}
        end,
        getupvalue = debugLibrary.getupvalue or function() return nil end,
        setupvalue = debugLibrary.setupvalue or function() end,
        getmetatable = debugLibrary.getmetatable,
        setmetatable = debugLibrary.setmetatable or setmetatable,
        traceback = getTraceback or function() return '\\"' end,
        profilebegin = function() end,
        profileend = function() end,
        sethook = function() end
    },
    rconsoleprint = function(s) end,
    rconsoleclear = function() end,
    rconsolecreate = function() end,
    rconsoledestroy = function() end,
    rconsoleinput = function() return \\"\\" end,
    rconsoleinfo = function(s) end,
    rconsolewarn = function(s) end,
    rconsoleerr = function(s) end,
    rconsolename = function(name) end,
    printconsole = function(s) end,
    setfflag = function(flag, val) end,
    getfflag = function(flag) return \\"\\" end,
    setfpscap = function(cap) emitOutput(string.format(\\"setfpscap(%s)\\", serializeValue(cap))) end,
    getfpscap = function() return 60 end,
    isnetworkowner = function(part) return true end,
    gethiddenproperty = function(instance, prop)
        if not isProxy(instance) then return nil, false end
        local props = dumperState.property_store[instance]
        if props and props[prop] ~= nil then return props[prop], true end
        return nil, false
    end,
    sethiddenproperty = function(instance, prop, val)
        if isProxy(instance) then
            local props = dumperState.property_store[instance]
            if props then
                if prop == \\"DistributedGameTime\\" then
                    -- don't store the set value; just record a tick base from current real value
                    -- so subsequent reads keep ticking from where they were
                    if not _at._dgtClock then
                        _at._dgtBase = (props[prop] or 1)
                        _at._dgtClock = osLibrary.clock()
                    end
                    -- intentionally do NOT store val - real Roblox ignores the set
                else
                    props[prop] = val
                end
            end
        end
        emitOutput(string.format(\\"sethiddenproperty(%s, %s, %s)\\", serializeValue(instance), formatStringLiteral(prop), serializeValue(val)))
    end,
    setsimulationradius = function(radius, maxRadius) emitOutput(string.format(\\"setsimulationradius(%s%s)\\", serializeValue(radius), maxRadius and \\", \\" .. serializeValue(maxRadius) or \\"\\")) end,
    getspecialinfo = function(instance) return {} end,
    saveinstance = function(options) emitOutput(string.format(\\"saveinstance(%s)\\", serializeValue(options or {}))) end,
    decompile = function(script) return \\"-- decompiled\\" end,
    lz4compress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4compress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        local lenBytes = string.char(
            math.floor(#s / 16777216) % 256,
            math.floor(#s / 65536) % 256,
            math.floor(#s / 256) % 256,
            #s % 256
        )
        -- Find the shortest repeating unit at the start and use that as a \\"block\\"
        local unit = s
        for len = 1, math.floor(#s / 2) do
            local candidate = s:sub(1, len)
            local repeated = string.rep(candidate, math.floor(#s / len))
            local remainder = s:sub(#repeated + 1)
            if repeated .. remainder == s then
                unit = candidate
                break
            end
        end
        -- Encode as: magic + origLen + unitLen(2 bytes) + unit + count(2 bytes) + remainder
        local count = math.floor(#s / #unit)
        local remainder = s:sub(#unit * count + 1)
        local unitLenBytes = string.char(math.floor(#unit / 256) % 256, #unit % 256)
        local countBytes = string.char(math.floor(count / 256) % 256, count % 256)
        local remLenBytes = string.char(math.floor(#remainder / 256) % 256, #remainder % 256)
        return magic .. lenBytes .. unitLenBytes .. unit .. countBytes .. remLenBytes .. remainder
    end,
    lz4decompress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4decompress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        if #s < 12 or s:sub(1, 4) ~= magic then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local b1, b2, b3, b4 = s:byte(5), s:byte(6), s:byte(7), s:byte(8)
        local origLen = b1 * 16777216 + b2 * 65536 + b3 * 256 + b4
        local unitLenHi, unitLenLo = s:byte(9), s:byte(10)
        local unitLen = unitLenHi * 256 + unitLenLo
        if #s < 10 + unitLen + 4 then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local unit = s:sub(11, 10 + unitLen)
        local countHi, countLo = s:byte(11 + unitLen), s:byte(12 + unitLen)
        local count = countHi * 256 + countLo
        local remLenHi, remLenLo = s:byte(13 + unitLen), s:byte(14 + unitLen)
        local remLen = remLenHi * 256 + remLenLo
        local remainder = s:sub(15 + unitLen, 14 + unitLen + remLen)
        return (string.rep(unit, count) .. remainder):sub(1, origLen)
    end,
    MessageBox = function(text, caption, type) return 1 end,
    setwindowactive = function() end,
    setwindowtitle = function(title) end,
    queue_on_teleport = function(code) emitOutput(string.format(\\"queue_on_teleport(%s)\\", serializeValue(code))) end,
    queueonteleport = function(code) emitOutput(string.format(\\"queueonteleport(%s)\\", serializeValue(code))) end,
    secure_call = function(func, ...) return func(...) end,
    create_secure_function = function(func) return func end,
    isvalidinstance = function(instance) return instance ~= nil end,
    validcheck = function(instance) return instance ~= nil end
}
for name, func in pairsFunction(exploitFuncs) do
    _G[name] = func
end
local nativeBit32 = bit32
local bitLibrary = {}
local function toBit(n)
    n = (n or 0) % 4294967296
    if n >= 2147483648 then n = n - 4294967296 end
    return math.floor(n)
end
local function toU32(n) return math.floor((n or 0) % 4294967296) end

local function _band(a, b)
    if nativeBit32 then return nativeBit32.band(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 and b > 0 do
        if a % 2 == 1 and b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bor(a, b)
    if nativeBit32 then return nativeBit32.bor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 == 1 or b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bxor(a, b)
    if nativeBit32 then return nativeBit32.bxor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 ~= b % 2 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _lshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return toU32(toU32(n) * (2 ^ bits))
end
local function _rshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return math.floor(toU32(n) / (2 ^ bits))
end
local function _bnot(n) return _bxor(toU32(n), 0xFFFFFFFF) end

bitLibrary.tobit = toBit
bitLibrary.tohex = function(n, len)
    return string.format(\\"%0\\" .. (len or 8) .. \\"x\\", toU32(n))
end
bitLibrary.band = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _band(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bxor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bxor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bnot    = function(n) return toBit(_bnot(n or 0)) end
bitLibrary.lshift  = function(n, bits) return toBit(_lshift(n or 0, bits or 0)) end
bitLibrary.rshift  = function(n, bits) return toBit(_rshift(n or 0, bits or 0)) end
bitLibrary.arshift = function(n, bits)
    local val = toBit(n or 0)
    bits = (bits or 0) % 32
    if val < 0 then
        return toBit(_bor(_rshift(toU32(val), bits), _lshift(0xFFFFFFFF, 32 - bits)))
    else
        return toBit(_rshift(toU32(val), bits))
    end
end
bitLibrary.rol = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_lshift(n, bits), _rshift(n, 32 - bits)))
end
bitLibrary.ror = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_rshift(n, bits), _lshift(n, 32 - bits)))
end
bitLibrary.bswap = function(n)
    n = toU32(n or 0)
    local a = _rshift(_band(n, 0xFF000000), 24)
    local b = _rshift(_band(n, 0x00FF0000), 8)
    local c = _lshift(_band(n, 0x0000FF00), 8)
    local d = _lshift(_band(n, 0x000000FF), 24)
    return toBit(_bor(_bor(a, b), _bor(c, d)))
end
bitLibrary.countlz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    if _band(n, 0xFFFF0000) == 0 then count = count + 16; n = _lshift(n, 16) end
    if _band(n, 0xFF000000) == 0 then count = count + 8;  n = _lshift(n, 8)  end
    if _band(n, 0xF0000000) == 0 then count = count + 4;  n = _lshift(n, 4)  end
    if _band(n, 0xC0000000) == 0 then count = count + 2;  n = _lshift(n, 2)  end
    if _band(n, 0x80000000) == 0 then count = count + 1   end
    return count
end
bitLibrary.countrz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    while _band(n, 1) == 0 do n = _rshift(n, 1); count = count + 1 end
    return count
end
bitLibrary.lrotate = bitLibrary.rol
bitLibrary.rrotate = bitLibrary.ror
bitLibrary.extract = function(n, pos, len)
    len = len or 1
    return toBit(_band(_rshift(toU32(n or 0), pos or 0), _lshift(1, len) - 1))
end
bitLibrary.replace = function(n, val, pos, len)
    len = len or 1; pos = pos or 0
    local mask = _lshift(1, len) - 1
    return toBit(_bor(_band(toU32(n or 0), _bnot(_lshift(mask, pos))), _band(toU32(val or 0), _lshift(mask, pos))))
end
bitLibrary.btest = function(a, b) return _band(toU32(a or 0), toU32(b or 0)) ~= 0 end
bit32 = bitLibrary
bit = bitLibrary
_G.bit = bitLibrary
_G.bit32 = bitLibrary
table.getn = table.getn or function(t) return #t end
table.foreach = table.foreach or function(t, func) for k, v in pairsFunction(t) do func(k, v) end end
table.foreachi = table.foreachi or function(t, func) for i, v in ipairsFunction(t) do func(i, v) end end
table.find = table.find or function(t, value, init)
    for i = (init or 1), #t do
        if t[i] == value then return i end
    end
    return nil
end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairsFunction(t) do out[k] = v end
    return out
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function(t) return false end
table.clear = table.clear or function(t) for k in pairsFunction(t) do t[k] = nil end end
table.find = table.find or function(t, val, init)
    for i = init or 1, #t do
        if t[i] == val then return i end
    end
    return nil
end
table.clear = table.clear or function(t)
    for k in pairs(t) do t[k] = nil end
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function() return false end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairs(t) do out[k] = v end
    return out
end
table.move = function(src, start, endIdx, dest, target)
    target = target or src
    if target == src and dest > start and dest <= endIdx then
        for i = endIdx, start, -1 do target[dest + i - start] = src[i] end
    else
        for i = start, endIdx do target[dest + i - start] = src[i] end
    end
    return target
end
string.split = string.split or function(str, sep)
    local t = {}
    for match in string.gmatch(str, \\"([^\\" .. (sep or \\"%s\\") .. \\"]+)\\") do table.insert(t, match) end
    return t
end
if not math.frexp then
    math.frexp = function(x)
        if x == 0 then return 0, 0 end
        local exp = math.floor(math.log(math.abs(x)) / math.log(2)) + 1
        local m = x / 2 ^ exp
        return m, exp
    end
end
if not math.ldexp then math.ldexp = function(m, e) return m * 2 ^ e end end
if not utf8 then
    utf8 = {}
    utf8.char = function(...)
        local args = {...}
        local chars = {}
        for _, byte in ipairsFunction(args) do table.insert(chars, string.char(byte % 256)) end
        return table.concat(chars)
    end
    utf8.len = function(s) return #s end
    utf8.codes = function(s)
        local i = 0
        return function() i = i + 1; if i <= #s then return i, string.byte(s, i) end end
    end
end
-- graphemes: bypass nested anti-tamper chain third[1][1][1][1][1][1](first, second)
utf8.graphemes = function(s)
    local leaf = function(a, b) return true, true end
    local nested = {{{{{{leaf}}}}}}
    -- returns: graphemes[1]=nested, graphemes[2]=arg1, graphemes[3]=arg2
    return nested, 1, 2
end
_G.utf8 = utf8
pairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return pairsFunction(t) end
    return function() return nil end, t, nil
end
ipairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return ipairsFunction(t) end
    return function() return nil end, t, 0
end
_G.pairs = pairs
_G.ipairs = ipairs
_G.math = math
_G.table = table
-- override string.dump to error on exploit/proxy functions like real Roblox
local _realStringDump = string.dump
string.dump = function(f, ...)
    if isProxy(f) then
        errorFunction(\\"unable to dump given function\\", 2)
    end
    -- exploit funcs registered in _G are not dumpable
    for name, val in pairsFunction(exploitFuncs) do
        if val == f then errorFunction(\\"unable to dump given function\\", 2) end
    end
    return _realStringDump(f, ...)
end
_G.string = string
_G.os = os
os.execute = function() return nil end
os.exit = function() return nil end
os.remove = function() return nil, \\"disabled\\" end
os.rename = function() return nil, \\"disabled\\" end
_G.coroutine = coroutine
_G.io = nil
_G.debug = exploitFuncs.debug
_G._realSetHook = setHook
_G.utf8 = utf8
_G.next = next
_G.tostring = tostring
_G.tonumber = tonumber
_G.getmetatable = getmetatable
_G.setmetatable = setmetatable
_G.pcall = function(f, ...)
    local results = {pcallFunction(f, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.xpcall = function(f, errFunc, ...)
    local function wrapper(err)
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then return err end
        if errFunc then return errFunc(err) end
        return err
    end
    local results = {xpcallFunction(f, wrapper, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.error = errorFunction
if _G.originalError == nil then _G.originalError = errorFunction end
_G.assert = assert
_G.select = select
_G.type = typeFunction
_G.rawget = rawget
_G.rawset = rawset
_G.rawequal = rawEqualFunction
_G.rawlen = rawlen or function(t) return #t end
_G.unpack = table.unpack or unpack
_G.pack = table.pack or function(...) return {n = select(\\"#\\", ...), ...} end
_G.task = task
_G.wait = wait
_G.Wait = wait
_G.delay = delay
_G.Delay = delay
_G.spawn = spawn
_G.Spawn = spawn
_G.tick = tick
_G.time = time
_G.elapsedTime = elapsedTime
_G.game = game
_G.Game = game
_G.workspace = workspace
_G.Workspace = workspace
_G.script = script
_G.Enum = Enum
_G.Instance = Instance
_G.Random = Random
_G.Vector3 = Vector3
_G.Vector2 = Vector2
_G.CFrame = CFrame
_G.Color3 = Color3
_G.BrickColor = BrickColor
_G.UDim = UDim
_G.UDim2 = UDim2
_G.TweenInfo = TweenInfo
_G.Rect = Rect
_G.Region3 = Region3
_G.Region3int16 = Region3int16
_G.Ray = Ray
_G.NumberRange = NumberRange
_G.NumberSequence = NumberSequence
_G.NumberSequenceKeypoint = NumberSequenceKeypoint
_G.ColorSequence = ColorSequence
_G.ColorSequenceKeypoint = ColorSequenceKeypoint
_G.PhysicalProperties = PhysicalProperties
_G.Font = Font
_G.RaycastParams = RaycastParams
_G.OverlapParams = OverlapParams
_G.PathWaypoint = PathWaypoint
_G.Axes = Axes
_G.Faces = Faces
_G.Vector3int16 = Vector3int16
_G.Vector2int16 = Vector2int16
_G.CatalogSearchParams = CatalogSearchParams
_G.DateTime = DateTime
settings = function()
    local enumKey = \\"Enum.QualityLevel.Automatic\\"
    if not _at.enum[enumKey] then
        local p = createProxyObject(enumKey, false)
        dumperState.registry[p] = enumKey
        _at.enum[enumKey] = p
    end
    local qualityProxy = _at.enum[enumKey]
    return {
        Rendering = {QualityLevel = qualityProxy, FrameRateManager = 0, EagerBulkExecution = false},
        Studio    = {},
        Network   = {IncomingReplicationLag = 0},
        Physics   = {PhysicsEnvironmentalThrottle = createProxyObject(\\"Enum.EnviromentalPhysicsThrottle.DefaultAuto\\", false)},
    }
end
_G.settings = settings
getmetatable = function(x)
    if _at.userdata[x] then return getMetatableFunction(x) end
    if isProxy(x) then return \\"The metatable is locked\\" end
    return getMetatableFunction(x)
end
_G.getmetatable = getmetatable
type = function(x)
    if _at.threadLike[x] then return \\"thread\\" end
    if _at.userdata[x] then return \\"userdata\\" end
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then return \\"userdata\\" end
    return typeFunction(x)
end
_G.type = type
buffer = {
    create = function(size)
        local b = {}
        _at.buffers[b] = string.rep(\\"\0\\", size or 0)
        return b
    end,
    fromstring = function(s)
        local b = {}
        _at.buffers[b] = formatValue(s)
        return b
    end,
    tostring = function(b)
        return _at.buffers[b] or \\"\\"
    end,
    len = function(b)
        return #(_at.buffers[b] or \\"\\")
    end,
    copy = function(dst, dstOffset, src, srcOffset, count)
        local srcData = _at.buffers[src] or \\"\\"
        local dstData = _at.buffers[dst] or \\"\\"
        srcOffset = (srcOffset or 0) + 1
        dstOffset = (dstOffset or 0) + 1
        local chunk = srcData:sub(srcOffset, count and srcOffset + count - 1 or -1)
        local before = dstData:sub(1, dstOffset - 1)
        local after  = dstData:sub(dstOffset + #chunk)
        _at.buffers[dst] = before .. chunk .. after
    end,
    fill = function(b, offset, value, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        count  = count or (#data - offset + 1)
        local fill = string.rep(string.char(value % 256), count)
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + count)
        _at.buffers[b] = before .. fill .. after
    end,
    writestring = function(b, offset, s, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        s = formatValue(s)
        if count then s = s:sub(1, count) end
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + #s)
        _at.buffers[b] = before .. s .. after
    end,
    readstring = function(b, offset, len)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        return data:sub(offset, len and offset + len - 1 or -1)
    end,
    writeu8  = function(b, offset, v) local d=_at.buffers[b] or\\"\\"; offset=(offset or 0)+1; _at.buffers[b]=d:sub(1,offset-1)..string.char(v%256)..d:sub(offset+1) end,
    readu8   = function(b, offset) local d=_at.buffers[b] or\\"\\"; return string.byte(d,(offset or 0)+1) or 0 end,
    writeu16 = function(b, offset, v) offset=(offset or 0); buffer.writeu8(b,offset,v%256); buffer.writeu8(b,offset+1,math.floor(v/256)%256) end,
    readu16  = function(b, offset) return buffer.readu8(b,offset) + buffer.readu8(b,(offset or 0)+1)*256 end,
    writeu32 = function(b, offset, v) offset=(offset or 0); for i=0,3 do buffer.writeu8(b,offset+i,math.floor(v/(256^i))%256) end end,
    readu32  = function(b, offset) local v=0; for i=0,3 do v=v+buffer.readu8(b,(offset or 0)+i)*(256^i) end; return v end,
    writei8  = function(b, offset, v) buffer.writeu8(b, offset, v < 0 and v+256 or v) end,
    readi8   = function(b, offset) local v=buffer.readu8(b,offset); return v>=128 and v-256 or v end,
    writei16 = function(b, offset, v) buffer.writeu16(b, offset, v < 0 and v+65536 or v) end,
    readi16  = function(b, offset) local v=buffer.readu16(b,offset); return v>=32768 and v-65536 or v end,
    writei32 = function(b, offset, v) buffer.writeu32(b, offset, v < 0 and v+4294967296 or v) end,
    readi32  = function(b, offset) local v=buffer.readu32(b,offset); return v>=2147483648 and v-4294967296 or v end,
    writef32 = function(b, offset, v) buffer.writeu32(b, offset, math.floor(math.abs(v)*1000)%4294967296) end,
    readf32  = function(b, offset) return buffer.readu32(b,offset)/1000 end,
    writef64 = function(b, offset, v) buffer.writeu32(b, offset, 0); buffer.writeu32(b, (offset or 0)+4, math.floor(math.abs(v)*1000)%4294967296) end,
    readf64  = function(b, offset) return buffer.readu32(b,(offset or 0)+4)/1000 end,
}
_G.buffer = buffer
typeof = function(x)
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then
        if _at.typeOverride[x] then return _at.typeOverride[x] end
        local regName = dumperState.registry[x]
        if regName then
            if regName == \\"Enum\\" then return \\"Enums\\" end
            if regName:match(\\"^Enum%.[^%.]+$\\") then return \\"Enum\\" end
            if regName:match(\\"^Enum%.[^%.]+%.[^%.]+$\\") then return \\"EnumItem\\" end
            if regName:match(\\"Vector3\\") then return \\"Vector3\\" end
            if regName:match(\\"CFrame\\") then return \\"CFrame\\" end
            if regName:match(\\"Color3\\") then return \\"Color3\\" end
            if regName:match(\\"UDim\\") then return \\"UDim2\\" end
        end
        return \\"Instance\\"
    end
    if _at.threadLike[x] then return \\"thread\\" end
    local mt = getMetatableFunction(x)
    if mt and mt.__typeof then return mt.__typeof end
    return typeFunction(x) == \\"table\\" and \\"table\\" or typeFunction(x)
end
_G.typeof = typeof
newproxy = function(withMeta)
    local proxy = {}
    _at.userdata[proxy] = true
    if withMeta then
        setmetatable(proxy, {})
    end
    return proxy
end
_G.newproxy = newproxy
tonumber = function(x, base)
    if getProxyValue(x) ~= 0 then return 123456789 end
    return toNumberFunction(x, base)
end
_G.tonumber = tonumber
rawequal = function(a, b) return rawEqualFunction(a, b) end
_G.rawequal = rawequal
tostring = function(x)
    if isProxy(x) then
        local mt = getMetatableFunction(x)
        if mt and mt.__tostring then
            local ok, r = pcallFunction(mt.__tostring, x)
            if ok and r then return r end
        end
        local regName = dumperState.registry[x]
        return regName or \\"Instance\\"
    end
    local mt = getMetatableFunction(x)
    if mt and mt.__tostring then
        local ok, r = pcallFunction(mt.__tostring, x)
        if ok and r then return r end
    end
    return toStringFunction(x)
end
_G.tostring = tostring
dumperState.last_http_url = nil
loadstring = function(code, chunkName)
    if typeFunction(code) ~= \\"string\\" then return function() return createProxyObject(\\"loaded\\", false) end end
    local url = dumperState.last_http_url or code
    dumperState.last_http_url = nil
    local libName = nil
    local lowerCode = url:lower()
    local libs = {{pattern = \\"rayfield\\", name = \\"Rayfield\\"}, {pattern = \\"orion\\", name = \\"OrionLib\\"}, {pattern = \\"kavo\\", name = \\"Kavo\\"}, {pattern = \\"venyx\\", name = \\"Venyx\\"}, {pattern = \\"sirius\\", name = \\"Sirius\\"}, {pattern = \\"linoria\\", name = \\"Linoria\\"}, {pattern = \\"wally\\", name = \\"Wally\\"}, {pattern = \\"dex\\", name = \\"Dex\\"}, {pattern = \\"infinite\\", name = \\"InfiniteYield\\"}, {pattern = \\"hydroxide\\", name = \\"Hydroxide\\"}, {pattern = \\"simplespy\\", name = \\"SimpleSpy\\"}, {pattern = \\"remotespy\\", name = \\"RemoteSpy\\"}}
    for _, lib in ipairsFunction(libs) do if lowerCode:find(lib.pattern) then libName = lib.name; break end end
    if libName then
        local proxy = createProxyObject(libName, false)
        dumperState.registry[proxy] = libName
        dumperState.names_used[libName] = true
        if url:match(\\"^https?://\\") then emitOutput(string.format('local %s = loadstring(game:HttpGet(\\"%s\\"))()', libName, url)) end
        return function() return proxy end
    end
    if url:match(\\"^https?://\\") then
        local proxy = createProxyObject(\\"Library\\", false)
        emitOutput(string.format('local loadstring = loadstring(game:HttpGet(\\"%s\\"))()', url))
        return function() return proxy end
    end
    if code:match(\\"local%s+a%s*=%s*if%s+true%s+then\\") then return nil, \\"attempt to call a nil value\\" end
    if typeFunction(code) == \\"string\\" then code = processString(code) end
    local func, err = loadFunction(code)
    if func then return func end
    local proxy = createProxyObject(\\"LoadedChunk\\", false)
    return function() return proxy end
end
load = loadstring
_G.loadstring = loadstring
_G.load = loadstring
require = function(module)
    local modName = dumperState.registry[module] or serializeValue(module)
    local proxy = createProxyObject(\\"RequiredModule\\", false)
    local varName = registerVariable(proxy, \\"module\\")
    emitOutput(string.format(\\"local %s = require(%s)\\", varName, modName))
    return proxy
end
_G.require = require
print = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"print(%s)\\", table.concat(items, \\", \\")))
end
_G.print = print
warn = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"warn(%s)\\", table.concat(items, \\", \\")))
end
_G.warn = warn
-- Tag Roblox-like builtins as C closures so iscclosure() returns true for them
do
    if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
    local _cbuiltins = {
        print, warn, tick, time, elapsedTime, pcall, xpcall, error, assert,
        tostring, tonumber, type, typeof, rawget, rawset, rawequal, rawlen,
        setmetatable, getmetatable, ipairs, pairs, next, select, unpack,
        require, loadstring, load,
    }
    for _, fn in ipairs(_cbuiltins) do
        if typeFunction(fn) == \\"function\\" then
            _at.cclosureSet[fn] = true
        end
    end
end
_G.shared = shared
local globalBase = _G
local globalMeta = setmetatable({}, {
    __index = function(tbl, key)
        if configuration.VERBOSE then printFunction(\\"[VERBOSE] Accessing field: \\" .. toStringFunction(key)) end
        local val = rawget(globalBase, key)
        if val == nil then val = rawget(_G, key) end
        if configuration.VERBOSE then
            if val ~= nil then
                if typeFunction(val) == \\"table\\" then printFunction(\\"[VERBOSE] Found global table: \\" .. toStringFunction(key))
                elseif typeFunction(val) == \\"function\\" then printFunction(\\"[VERBOSE] Found global function: \\" .. toStringFunction(key))
                else printFunction(\\"[VERBOSE] Found global value: \\" .. toStringFunction(key) .. \\" = \\" .. toStringFunction(val)) end
            else
                printFunction(\\"[VERBOSE] Missing field, providing dummy function: \\" .. toStringFunction(key))
                val = function() if configuration.VERBOSE then printFunction(\\"[Missing Function] Called: \\" .. toStringFunction(key) .. \\" with 0 arguments\\") end return nil end
            end
        end
        return val
    end,
    __newindex = function(tbl, key, val) rawset(globalBase, key, val) end
})
_G._G = globalMeta
function proxyTable.reset()
    dumperState = {output = {}, indent = 0, registry = {}, reverse_registry = {}, names_used = {}, parent_map = {}, property_store = {}, call_graph = {}, variable_types = {}, string_refs = {}, proxy_id = 0, callback_depth = 0, pending_iterator = false, last_http_url = nil, last_emitted_line = nil, repetition_count = 0, current_size = 0, limit_reached = false, ls_counter = 0, captured_constants = {}}
    _at.mem = {}
    _at.tags = {}
    _at.sigs = {}
    _at.acts = {}
    _at.json = {}
    _at.enum = {}
    _at.svcCache = {}
    _at.typeOverride = {}
    _at.connState = {}
    _at.pendingHeartbeat = {}
    _at.locEntries = {}
    _at.userdata = {}
    _at.localPlayer = nil
    setmetatable(_at.userdata, {__mode = \\"k\\"})
    _at.debugIds = {}
    setmetatable(_at.debugIds, {__mode = \\"k\\"})
    _at.debugIdCtr = 0
    uiCounters = {}
    game = createProxyObject(\\"game\\", true)
    workspace = createProxyObject(\\"workspace\\", true)
    script = createProxyObject(\\"script\\", true)
    Enum = createProxyObject(\\"Enum\\", true)
    shared = createProxyObject(\\"shared\\", true)
    dumperState.property_store[game] = {PlaceId = numericArg, GameId = numericArg, placeId = numericArg, gameId = numericArg}
    dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
    _G.game = game; _G.Game = game; _G.workspace = workspace; _G.Workspace = workspace; _G.script = script; _G.Enum = Enum; _G.shared = shared
    local meta = debugLibrary.getmetatable(Enum)
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
        local enumName = \\"Enum.\\" .. formatValue(key)
        if not _at.enum[enumName] then
            local enumProxy = createProxyObject(enumName, false)
            dumperState.registry[enumProxy] = enumName
            _at.enum[enumName] = enumProxy
        end
        return _at.enum[enumName]
    end
    seedCoreRobloxInstances()
    if type(_G._bypassOnReset) == \\"function\\" then
        local prevOutput = dumperState.output
        local prevOutputCount = #prevOutput
        local prevIndent = dumperState.indent
        local prevLast = dumperState.last_emitted_line
        local prevRep = dumperState.repetition_count
        local prevSize = dumperState.current_size
        local prevLimit = dumperState.limit_reached
        pcall(_G._bypassOnReset)
        for i = #prevOutput, prevOutputCount + 1, -1 do
            prevOutput[i] = nil
        end
        dumperState.output = prevOutput
        dumperState.indent = prevIndent
        dumperState.last_emitted_line = prevLast
        dumperState.repetition_count = prevRep
        dumperState.current_size = prevSize
        dumperState.limit_reached = prevLimit
    end
end
function proxyTable.get_output() return getFullOutput() end
function proxyTable.save(file) return saveToFile(file) end
function proxyTable.get_call_graph() return dumperState.call_graph end
function proxyTable.get_string_refs() return dumperState.string_refs end
function proxyTable.get_stats() return {total_lines = #dumperState.output, remote_calls = #dumperState.call_graph, suspicious_strings = #dumperState.string_refs, proxies_created = dumperState.proxy_id} end
local dumper = {callId = \\"LUASPLOIT_\\", binaryOperatorNames = {[\\"and\\"] = \\"AND\\", [\\"or\\"] = \\"OR\\", [\\">\\"] = \\"GT\\", [\\"<\\"] = \\"LT\\", [\\">=\\"] = \\"GE\\", [\\"<=\\"] = \\"LE\\", [\\"==\\"] = \\"EQ\\", [\\"~=\\"] = \\"NEQ\\", [\\"..\\"] = \\"CAT\\"}}
function dumper:hook(code) return self.callId .. code end
function dumper:process_expr(expr)
    if not expr then return \\"nil\\" end
    if typeFunction(expr) == \\"string\\" then return expr end
    local tag = expr.tag or expr.kind
    if tag == \\"number\\" or tag == \\"string\\" then
        local val = tag == \\"string\\" and string.format(\\"%q\\", expr.text) or (expr.value or expr.text)
        if configuration.CONSTANT_COLLECTION then return string.format(\\"%sGET(%s)\\", self.callId, val) end
        return val
    end
    if tag == \\"local\\" or tag == \\"global\\" then return (expr.name or expr.token).text
    elseif tag == \\"boolean\\" or tag == \\"bool\\" then return toStringFunction(expr.value)
    elseif tag == \\"binary\\" then
        local lhs = self:process_expr(expr.lhsoperand)
        local rhs = self:process_expr(expr.rhsoperand)
        local op = expr.operator.text
        local opName = self.binaryOperatorNames[op]
        if opName then return string.format(\\"%s%s(%s, %s)\\", self.callId, opName, lhs, rhs) end
        return string.format(\\"(%s %s %s)\\", lhs, op, rhs)
    elseif tag == \\"call\\" then
        local func = self:process_expr(expr.func)
        local args = {}
        for i, node in ipairsFunction(expr.arguments) do args[i] = self:process_expr(node.node or node) end
        return string.format(\\"%sCALL(%s, %s)\\", self.callId, func, table.concat(args, \\", \\"))
    elseif tag == \\"indexname\\" or tag == \\"index\\" then
        local exprStr = self:process_expr(expr.expression)
        local keyStr = tag == \\"indexname\\" and string.format(\\"%q\\", expr.index.text) or self:process_expr(expr.index)
        return string.format(\\"%sCHECKINDEX(%s, %s)\\", self.callId, exprStr, keyStr)
    end
    return \\"nil\\"
end
function dumper:process_statement(stmt)
    if not stmt then return \\"\\" end
    local tag = stmt.tag
    if tag == \\"local\\" or tag == \\"assign\\" then
        local vars, vals = {}, {}
        for _, node in ipairsFunction(stmt.variables or {}) do table.insert(vars, self:process_expr(node.node or node)) end
        for _, node in ipairsFunction(stmt.values or {}) do table.insert(vals, self:process_expr(node.node or node)) end
        return (tag == \\"local\\" and \\"local \\" or \\"\\") .. table.concat(vars, \\", \\") .. \\" = \\" .. table.concat(vals, \\", \\")
    elseif tag == \\"block\\" then
        local stmts = {}
        for _, s in ipairsFunction(stmt.statements or {}) do table.insert(stmts, self:process_statement(s)) end
        return table.concat(stmts, \\"; \\")
    end
    return self:process_expr(stmt) or \\"\\"
end
local function _loosePasteCode(code)
    if typeFunction(code) ~= \\"string\\" then return code end
    code = code:gsub(\\"```lua\\", \\"\\"):gsub(\\"```\\", \\"\\")
    return code
end
local function _loadLooseChunk(code, chunkName)
    local sanitized = processString(_loosePasteCode(code))
    local lines = {}
    sanitized:gsub(\\"([^\n]*)\n?\\", function(line)
        if line ~= \\"\\" or #lines == 0 or sanitized:sub(-1) == \\"\n\\" then table.insert(lines, line) end
    end)
    local skipped = {}
    for _ = 1, 400 do
        local current = table.concat(lines, \\"\n\\")
        local func, err = loadFunction(current, chunkName)
        if func then return func, nil, current, skipped end
        local lineNo = toNumberFunction(toStringFunction(err):match(\\"%]:(%d+):\\") or toStringFunction(err):match(\\":(%d+):\\"))
        if not lineNo or not lines[lineNo] or skipped[lineNo] then return nil, err, current, skipped end
        skipped[lineNo] = lines[lineNo]
        lines[lineNo] = \\"-- \\" .. lines[lineNo]
    end
    return nil, \\"too many invalid loose-paste lines\\", table.concat(lines, \\"\n\\"), skipped
end
function proxyTable.dump_file(inputPath, outputPath)
    proxyTable.reset()
    local file = ioLibrary.open(inputPath, \\"rb\\")
    if not file then
    printFunction(\\"error: cannot open input\\")
        return false
    end
    local code = file:read(\\"*a\\")
    file:close()
    printFunction(\\"input: normalize\\")
    local func, err, sanitized, skipped = _loadLooseChunk(code, \\"Obfuscated_Script\\")
    if not func then
        printFunction(\\"error: load \\" .. toStringFunction(err))
        return false
    end
    if skipped then
        local skippedCount = 0
        for _ in pairsFunction(skipped) do skippedCount = skippedCount + 1 end
        if skippedCount > 0 then printFunction(\\"input: skipped-lines=\\" .. toStringFunction(skippedCount)) end
    end
    local _SANDBOX_BLOCK = {
        io=true, os=true, debug=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true,
    }
    local _rawTb = debugLibrary and debugLibrary.traceback
    local _badTbWords = {
        \\"sandbox\\",\\"hook\\",\\"intercept\\",\\"mock\\",\\"proxy\\",\\"virtual_env\\",
        \\"decompil\\",\\"emulat\\",\\"simulat\\",\\"fake_\\",\\"getupval\\",\\"hookfunc\\",
        \\"replaceclos\\",\\"newcclos\\",\\"restorefunction\\",\\"bypass\\",\\"dumper\\",
    }
    local _tbWrapper = function(thread, msg, level)
        local ok, tb
        if _rawTb then
            if typeFunction(thread) == \\"thread\\" then
                ok, tb = pcallFunction(_rawTb, thread, msg, level)
            else
                ok, tb = pcallFunction(_rawTb, thread, msg)
            end
        end
        if not ok or typeFunction(tb) ~= \\"string\\" then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        local lines = {}
        for line in (tb .. \\"\n\\"):gmatch(\\"([^\n]*)\n\\") do
            local lo = line:lower()
            local bad = false
            for _, w in next, _badTbWords do
                if lo:find(w, 1, true) then bad = true; break end
            end
            if not bad then lines[#lines + 1] = line end
        end
        local cleaned = table.concat(lines, \\"\n\\")
        cleaned = cleaned:gsub(\\"%[([%w%+%/]+)%]\\", function(inner)
            if #inner + 2 < 10 then return \\"[RobloxGameScript]\\" end
            return \\"[\\" .. inner .. \\"]\\"
        end)
        if #cleaned < 20 then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        return cleaned
    end
    local _SAFE_DEBUG = {
        getinfo = function(func, ...)
            if typeFunction(func) == \\"number\\" then
                return nil
            end
            return {source = \\"=[C]\\", what = \\"C\\", name = \\"C function\\", short_src = \\"[C]\\"}
        end,
        traceback  = _tbWrapper,
        getupvalue = function(fn, i) return nil end,
    }
    local _SAFE_OS = {
        clock = function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end,
        time  = osLibrary.time,
        date  = osLibrary.date,
    }
    local env = setmetatable({
        _VERSION = \\"Luau\\",
        LuraphContinue = nil,
        __LC__ = function() end,
        script = script, game = game, workspace = workspace,
        io      = nil,
        os      = _SAFE_OS,
        debug   = _SAFE_DEBUG,
        error   = _origError,
        dofile  = nil,
        loadfile = nil,
        require = nil,
        package = nil,
        socket  = nil,
        ffi     = nil,
        collectgarbage = nil,
        newproxy = newproxy,
        -- hide _G metatable from scripts
        getmetatable = function(obj)
            if obj == _G or obj == env then return nil end
            if _at.userdata[obj] then return getMetatableFunction(obj) end
            if isProxy(obj) then return \\"The metatable is locked\\" end
            return getMetatableFunction(obj)
        end,
        LUASPLOIT_CHECKINDEX = function(tbl, key)
            local val = tbl[key]
            if typeFunction(val) == \\"table\\" and not dumperState.registry[val] then
                dumperState.ls_counter = dumperState.ls_counter + 1
                dumperState.registry[val] = \\"v\\" .. dumperState.ls_counter
            end
            return val
        end,
        LUASPLOIT_GET = function(v) return v end,
        LS_CALL = function(f, ...)
            if typeFunction(f) ~= \\"function\\" then return nil end
            return f(...)
        end,
        LS_NAMECALL = function(t, method, ...)
            if typeFunction(t) ~= \\"table\\" then return nil end
            if typeFunction(t[method]) ~= \\"function\\" then return nil end
            return t[method](t, ...)
        end,
        LUASPLOIT_CALL = function(f, ...) return f(...) end,
        LUASPLOIT_NAMECALL = function(t, method, ...) return t[method](t, ...) end,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end
    }, {
        __index = function(_, k)
            if _SANDBOX_BLOCK[k] then return nil end
            -- block dumper internal globals from leaking into script env
            if k == \\"LuraphContinue\\" or k == \\"__FLAMEDUMPER_REQUIRE_ONLY\\"
            or k == \\"proxyTable\\" or k == \\"dumperState\\" or k == \\"_at\\" then
                return nil
            end
            return _G[k]
        end,
        __newindex = _G
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, env)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, env) end
        end
    end
    printFunction(\\"vm: running\\")
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    local success, runErr = xpcallFunction(function() func() end, function(e) return toStringFunction(e) end)
    setHook()
    if not success and not toStringFunction(runErr):match(\\"TIMEOUT\\") then
        emitComment(\\"Runtime: \\" .. toStringFunction(runErr))
    end
    local saved = proxyTable.save(outputPath or configuration.OUTPUT_FILE)
    if saved then
        local stats = proxyTable.get_stats()
        printFunction(string.format(\\"done: lines=%d remotes=%d strings=%d\\",
            stats.total_lines, stats.remote_calls, stats.suspicious_strings))
    else
        printFunction(\\"error: write failed\\")
    end
    return saved
end
function proxyTable.dump_string(code, outputPath)
    proxyTable.reset()
    if code then code = processString(code) end
    local func, err = loadFunction(code)
    if not func then
        emitComment(\\"Load Error: \\" .. (err or \\"unknown\\"))
        if outputPath then proxyTable.save(outputPath) end
        return false, err
    end
    local _DS_BLOCK = {
        io=true, os=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true, debug=true,
    }
    local _DS_OS = { clock=function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end, time=osLibrary.time, date=osLibrary.date }
    local dsEnv = setmetatable({
        _VERSION=\\"Luau\\",
        io=nil, os=_DS_OS, debug=nil, dofile=nil, loadfile=nil,
        require=nil, package=nil, socket=nil, ffi=nil,
        collectgarbage=nil, newproxy=newproxy,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end,
    }, {
        __index = function(_, k)
            if _DS_BLOCK[k] then return nil end
            return _G[k]
        end,
        __newindex = _G,
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, dsEnv)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, dsEnv) end
        end
    end
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    xpcallFunction(function() func() end, function(e)
        emitComment(\\"Runtime: \\" .. toStringFunction(e))
    end)
    setHook()
    if outputPath then return proxyTable.save(outputPath) end
    return true, getFullOutput()
end
do
    local bypassPath = (arg and arg[0] and arg[0]:match(\\"^(.+[\\\\/])\\")) or \\"\\"
    local ok, err = pcall(dofile, bypassPath .. \\"bypass.lua\\")
    if not ok then
        local ok2 = pcall(dofile, \\"bypass.lua\\")
        if not ok2 then
            printFunction(\\"[dumper] bypass.lua not found, continuing without supplement\\")
        end
    end
end

_G.LuraphContinue = nil
if not rawget(_G, \\"__FLAMEDUMPER_REQUIRE_ONLY\\") then
    if arg and arg[1] then
        local success = proxyTable.dump_file(arg[1], arg[2])
        if success then end
    else
        local file = ioLibrary.open(\\"obfuscated.lua\\", \\"rb\\")
        if file then
            file:close()
            local success = proxyTable.dump_file(\\"obfuscated.lua\\")
            if success then
                printFunction(proxyTable.get_output())
            end
        else
            printFunction(\\"Usage: lua dumper.lua <input> [output] [key]\\")
        end
    end
end
return proxyTable
 (linedefined 4462)")
print("  Stack 4: --[[ v1.0.0 https://wearedevs.net/obfuscator ]]--[[ v1.0.0 https://wearedevs.net/obfuscator ]] return(function(...)local v={\\"\102\047\072\083\090\065\061\061\\";\\"\051\065\061\061\\";\\"\118\111\104\107\118\110\100\061\\";\\"\080\110\082\106\056\055\113\119\055\115\107\051\121\100\113\070\057\066\074\107\057\052\109\056\116\067\057\113\054\069\049\114\106\077\116\076\085\065\061\061\\",\\"\082\076\078\065\047\067\068\101\\",\\"\098\073\121\054\056\043\069\057\\",\\"\115\047\078\108\079\052\104\099\079\104\104\117\054\119\082\089\079\122\061\061\\",\\"\053\085\078\050\097\080\104\081\105\052\065\076\048\109\100\047\\",\\"\104\043\090\074\099\066\119\054\116\047\068\076\070\099\078\107\112\066\066\110\119\050\067\080\069\107\069\114\074\048\114\065\075\053\049\119\047\099\111\118\083\072\108\055\122\115\075\079\071\118\071\104\100\056\119\099\090\080\055\118\113\054\081\088\113\121\088\061\\",\\"\118\075\104\099\078\056\080\119\\";\\"\073\085\109\102\065\110\049\105\067\112\100\067\078\116\107\074\072\052\057\081\067\105\053\104\098\053\048\056\086\089\048\117\076\047\115\114\120\069\116\102\048\103\043\048\086\097\097\114\076\119\081\118\082\066\051\066\083\112\114\120\111\108\048\057\080\099\099\113\086\081\110\107\081\049\120\110\\",\\"\049\052\052\056\082\122\061\061\\";\\"\075\070\121\067\111\080\069\078\077\109\122\085\074\085\112\054\099\121\051\053\065\099\053\111\114\072\070\067\101\076\077\061\\",\\"\051\109\078\081\054\119\067\090\053\110\104\085\115\111\054\107\079\111\077\061\\",\\"\068\097\086\055\082\053\079\054\050\108\106\061\\";\\"\065\065\061\061\\";\\"\050\074\067\072\105\097\098\111\\";\\"\075\070\097\114\051\107\100\069\065\097\061\061\\";\\"\072\111\098\099\078\109\070\061\\",\\"\083\090\053\114\079\113\050\121\068\109\080\118\106\072\122\061\\",\\"\109\047\098\086\078\109\054\068\105\111\104\114\072\111\090\061\\",\\"\089\101\105\121\115\101\068\049\079\080\078\086\097\056\105\085\090\065\061\061\\",\\"\109\099\118\101\077\057\073\116\\",\\"\107\076\117\051\071\051\107\112\118\055\052\109\057\088\065\107\111\057\069\081\077\108\086\115\115\084\082\113\072\106\108\120\104\098\085\067\049\056\051\089\122\076\078\067\081\056\077\110\072\055\077\061\\",\\"\107\122\061\061\\",\\"\118\119\086\119\100\106\104\077\079\104\108\112\118\052\117\054\051\097\061\061\\";\\"\089\080\078\117\078\056\098\099\072\110\117\068\072\103\068\111\100\106\068\080\\";\\"\084\079\105\047\051\052\118\087\051\111\104\110\078\110\122\099\079\122\061\061\\";\\"\067\055\087\077\086\122\061\061\\";\\"\110\072\104\122\071\083\088\054\\";\\"\084\066\048\111\117\105\108\076\107\103\083\073\053\052\102\061\\";\\"\065\074\052\050\053\068\049\061\\",\\"\049\109\070\090\097\107\053\112\069\052\070\102\051\106\111\057\106\052\050\110\055\080\117\087\122\104\083\097\048\115\107\085\075\100\047\090\\";\\"\049\097\110\101\051\114\086\081\053\088\097\061\\",\\"\100\089\047\090\056\052\116\087\075\105\110\121\074\083\049\061\\";\\"\053\090\112\076\053\112\065\119\085\106\082\066\048\080\078\074\\",\\"\089\067\122\119\090\047\078\050\\";\\"\070\119\049\097\120\072\079\056\\",\\"\082\068\102\103\078\122\075\048\\",\\"\108\120\075\119\054\065\106\097\\";\\"\070\121\069\084\066\087\061\061\\";\\"\105\056\104\066\072\065\061\061\\";\\"\118\075\080\086\072\099\078\067\\";\\"\102\121\052\106\089\085\113\087\070\047\072\078\103\108\080\088\\",\\"\077\088\121\079\083\121\047\043\\";\\"\105\103\112\119\122\070\103\089\066\084\122\121\079\071\098\075\112\122\053\047\051\101\067\113\071\054\049\049\113\086\073\069\083\114\100\122\076\122\116\054\108\077\085\122\109\076\111\109\099\077\103\121\101\049\077\103\053\088\106\052\115\098\050\080\080\111\104\098\082\099\119\085\106\122\061\061\\",\\"\080\111\104\086\118\111\080\066\070\106\054\067\105\111\080\103\105\111\080\112\070\097\061\061\\";\\"\089\081\052\118\083\107\071\077\106\090\065\061\\",\\"\097\066\043\110\098\085\076\048\\",\\"\075\122\061\061\\";\\"\105\111\098\116\105\079\047\114\078\109\070\061\\",\\"\108\112\082\066\051\056\068\090\050\074\090\082\084\087\061\061\\";\\"\114\099\071\043\085\051\088\061\\";\\"\074\120\056\085\068\087\061\061\\";\\"\085\108\067\075\068\074\051\117\\";\\"\111\043\119\087\115\051\078\080\076\065\061\061\\",\\"\118\122\057\075\\",\\"\078\099\089\047\084\065\061\061\\";\\"\090\104\119\061\\",\\"\055\103\083\048\109\098\109\053\\",\\"\078\111\080\114\105\079\118\061\\";\\"\084\110\082\115\054\048\070\103\071\121\079\081\049\087\100\061\\";\\"\089\106\098\051\105\111\105\111\072\101\080\101\048\085\068\066\\";\\"\097\072\090\077\119\121\089\080\\",\\"\054\119\078\101\072\112\067\119\085\119\089\076\079\090\086\068\090\065\061\061\\",\\"\120\116\118\088\057\088\053\111\\",\\"\053\114\109\110\069\087\061\061\\",\\"\118\099\080\114\\";\\"\118\047\077\061\\",\\"\098\053\090\118\101\111\047\057\\";\\"\079\051\048\111\072\104\084\070\\",\\"\084\115\065\078\057\043\080\070\\",\\"\088\103\105\106\080\068\102\078\054\080\097\061\\",\\"\072\090\086\099\084\047\105\084\051\079\089\115\080\075\054\048\089\103\118\061\\",\\"\078\075\050\055\072\099\070\061\\";\\"\049\114\110\097\074\079\048\097\\";\\"\078\090\082\080\053\052\054\090\078\101\105\074\048\109\104\054\\",\\"\105\111\104\114\072\111\090\061\\",\\"\069\090\105\053\087\056\097\076\054\121\081\102\080\068\120\067\101\086\121\078\049\085\097\101\068\100\106\050\112\047\112\074\053\082\107\083\101\116\115\057\107\086\099\090\048\099\119\061\\",\\"\118\056\080\049\078\079\089\119\\",\\"\\",\\"\090\079\119\081\104\117\087\079\\";\\"\109\048\049\098\068\051\102\070\\",\\"\085\098\106\075\120\103\102\073\108\121\079\105\048\050\101\086\090\066\077\066\088\100\097\120\\",\\"\073\067\056\084\066\075\079\119\070\066\050\112\116\079\105\089\106\102\074\116\106\090\065\047\109\085\104\099\055\097\119\108\090\100\070\116\110\118\088\079\\",\\"\047\088\107\100\112\118\056\086\\";\\"\084\056\098\116\084\056\104\119\\",\\"\052\057\071\072\076\090\102\101\\";\\"\105\104\054\050\115\110\108\049\054\106\078\112\078\075\047\075\\";\\"\119\115\106\068\108\066\052\043\103\122\061\061\\";\\"\052\100\106\074\052\066\067\115\070\076\121\076\048\100\108\103\109\084\077\066\047\086\079\097\119\076\075\086\055\119\049\117\075\081\077\081\117\097\061\061\\";\\"\118\111\089\068\072\111\087\061\\",\\"\084\056\068\068\118\065\061\061\\",\\"\072\106\105\080\082\108\111\117\\";\\"\099\084\055\088\106\051\083\076\086\107\102\115\114\053\116\105\076\081\070\047\098\076\114\065\073\088\066\104\088\055\049\118\081\089\111\101\071\056\082\076\073\053\090\115\072\047\067\088\107\068\049\061\\";\\"\047\078\121\084\108\050\120\101\090\079\075\077\104\084\121\102\073\113\106\077\099\049\053\103\071\054\043\103\087\099\098\073\109\121\112\082\052\121\122\061\\",\\"\087\083\120\051\048\106\112\084\049\120\089\119\090\089\067\088\056\104\054\083\113\079\057\098\075\078\052\070\\";\\"\048\089\078\118\097\070\111\108\057\102\072\116\068\050\107\121\\",\\"\109\047\098\107\072\075\054\067\053\122\061\061\\",\\"\102\098\085\048\066\114\078\050\\",\\"\098\116\055\109\066\105\043\048\076\103\089\066\100\070\080\115\051\071\081\114\101\097\061\061\\";\\"\049\110\055\121\084\066\055\106\048\105\053\090\078\070\106\061\\",\\"\121\047\075\098\098\084\111\054\116\052\119\119\100\050\097\075\122\097\061\061\\";\\"\105\111\098\076\105\101\108\107\072\075\118\061\\";\\"\098\082\117\100\071\105\080\105\\";\\"\118\101\108\107\072\110\097\061\\",\\"\082\073\107\121\070\077\106\104\\";\\"\048\090\080\116\115\104\117\049\078\056\082\056\054\079\080\070\\";\\"\080\109\106\069\103\065\117\071\111\069\085\080\118\078\052\085\\",\\"\084\110\067\119\078\097\061\061\\";\\"\078\112\072\043\052\106\088\057\074\081\106\115\087\102\051\054\076\047\117\101\073\086\101\098\085\068\102\052\073\097\114\116\053\083\101\057\071\112\122\065\098\075\078\088\089\049\102\066\073\051\043\073\056\112\102\102\111\043\087\115\088\074\112\071\111\101\089\070\109\065\087\108\080\073\113\067\049\050\077\061\\",\\"\057\097\066\119\108\077\067\089\113\077\051\105\085\047\122\086\121\107\068\114\106\074\122\068\098\068\110\112\102\108\088\054\081\115\110\097\055\085\090\056\078\097\061\061\\";\\"\100\097\106\070\051\080\052\065\\",\\"\103\071\047\105\119\069\083\106\075\053\087\116\057\083\074\055\067\090\052\087\065\087\109\112\089\114\066\104\070\114\049\089\077\074\106\061\\",\\"\116\075\088\048\111\089\068\100\055\115\118\077\074\056\099\081\098\118\074\078\121\065\048\081\067\085\065\100\\";\\"\102\078\101\065\106\072\066\057\\";\\"\085\052\084\056\048\104\080\111\054\103\089\082\053\090\098\051\\",\\"\089\101\105\086\051\080\088\082\118\103\067\086\084\075\108\076\078\067\090\061\\",\\"\089\083\076\119\049\065\070\118\107\078\067\104\101\118\082\122\089\071\103\069\104\118\114\074\118\051\112\122\110\081\087\075\071\078\120\105\099\053\077\065\079\068\107\079\074\056\057\099\081\053\070\047\055\067\105\080\056\084\119\111\086\056\052\108\050\100\121\099\066\070\105\115\067\084\101\107\084\056\115\086\073\118\112\061\\";\\"\075\106\114\068\078\049\088\078\043\087\061\061\\",\\"\115\101\080\075\054\119\080\075\089\067\078\049\105\076\104\104\048\097\061\061\\";\\"\090\098\104\078\101\110\108\072\\";\\"\054\074\112\083\065\072\119\052\108\079\100\043\048\051\111\067\079\122\102\048\080\076\083\105\050\087\074\052\071\087\061\061\\";\\"\105\079\082\087\084\079\089\081\\",\\"\073\085\085\117\115\122\061\061\\",\\"\071\066\120\111\067\077\097\089\\",\\"\053\115\047\052\\",\\"\072\079\104\119\084\056\065\061\\",\\"\107\047\112\084\099\112\073\097\069\088\117\098\118\106\089\089\055\053\075\108\081\100\100\078\073\105\087\075\066\065\053\119\083\082\052\072\121\097\061\061\\",\\"\117\076\083\069\117\068\090\069\\",\\"\077\122\061\061\\",\\"\118\099\054\066\048\079\082\110\\",\\"\111\076\049\069\077\118\048\071\\";\\"\048\104\068\104\048\047\122\087\090\119\080\115\085\067\054\068\089\087\061\061\\",\\"\088\056\055\101\111\078\043\057\074\097\061\061\\",\\"\078\112\067\050\115\110\089\070\085\079\084\076\105\119\077\050\072\103\084\061\\",\\"\048\119\090\099\087\089\112\054\\",\\"\067\067\122\068\112\122\061\061\\";\\"\109\047\098\049\078\079\077\061\\",\\"\072\079\104\119\048\122\061\061\\";\\"\057\084\111\071\065\119\120\057\\",\\"\105\101\067\087\078\097\061\061\\";\\"\078\056\080\119\078\075\080\116\105\065\061\061\\",\\"\072\052\106\061\\";\\"\088\049\076\049\057\086\106\076\122\043\055\085\073\099\110\047\104\104\069\111\051\119\097\061\\",\\"\090\119\050\114\084\047\105\104\115\067\107\097\072\047\054\082\048\065\061\061\\",\\"\089\050\082\088\069\053\072\079\099\073\090\061\\";\\"\109\084\081\065\105\073\080\102\081\072\069\074\115\100\106\120\055\057\069\098\066\043\074\049\083\102\090\050\085\083\106\068\048\097\106\071\099\056\086\116\116\121\113\109\082\121\083\078\087\076\056\082\107\047\083\054\051\080\110\087\110\051\112\061\\",\\"\080\067\098\077\085\089\066\043\074\106\067\079\052\079\115\117\098\067\056\110\108\120\105\053\053\050\049\053\111\119\121\043\113\065\061\061\\";\\"\118\075\104\116\078\111\098\086\\",\\"\072\052\070\061\\";\\"\101\121\085\117\115\114\086\087\108\075\084\061\\";\\"\051\114\065\067\078\083\088\107\051\065\061\061\\";\\"\122\067\098\080\100\051\115\114\050\081\056\101\082\072\076\051\051\070\078\089\090\109\088\051\066\105\057\089\057\075\075\121\075\078\048\078\051\120\049\053\116\069\072\082\084\049\108\078\084\043\117\108\074\082\056\121\099\090\118\084\053\099\048\069\081\121\082\073\050\087\061\061\\",\\"\072\067\098\098\083\087\098\043\\";\\"\070\075\049\052\075\057\056\120\\";\\"\110\097\061\061\\";\\"\072\110\088\087\105\106\082\048\053\085\117\103\085\103\067\067\\",\\"\074\098\067\076\077\107\104\110\\";\\"\111\081\089\070\047\087\061\061\\",\\"\080\068\105\072\118\115\112\085\114\117\101\068\078\068\087\090\115\118\070\065\051\090\099\085\066\116\088\112\089\116\072\055\076\087\061\061\\";\\"\078\056\047\068\105\111\089\088\\",\\"\083\073\120\101\066\121\047\082\085\090\066\056\119\087\061\061\\",\\"\047\079\050\069\105\086\079\101\\",\\"\078\110\107\097\072\047\117\047\080\075\097\087\100\075\050\120\115\065\061\061\\",\\"\065\086\072\103\043\106\118\066\\",\\"\119\097\112\104\072\047\082\112\\";\\"\118\075\078\067\100\112\102\056\100\119\047\085\078\075\067\107\100\122\061\061\\";\\"\084\090\072\100\089\077\085\101\\";\\"\065\057\104\052\084\054\057\084\079\048\050\099\066\076\097\069\057\077\102\087\083\115\109\097\052\113\079\120\073\083\054\112\108\081\071\116\085\089\117\068\047\107\089\065\053\090\121\097\074\072\052\049\065\080\067\104\043\106\057\083\118\083\071\106\107\056\048\047\105\113\086\050\072\098\103\090\067\113\110\111\070\108\076\075\122\070\102\051\072\114\052\104\043\071\107\085\085\056\043\065\084\086\103\052\108\114\098\047\110\051\109\090\071\085\056\104\110\102\106\050\115\103\073\107\067\085\043\103\085\105\110\081\067\077\116\081\054\066\080\057\050\104\072\073\078\057\065\052\113\080\103\043\090\076\107\111\113\085\084\066\103\065\061\061\\",\\"\117\086\105\077\109\114\068\117\054\074\112\075\105\055\121\052\114\074\086\121\053\072\121\097\106\067\082\100\068\065\061\061\\";\\"\106\102\115\121\109\121\121\055\121\066\049\115\090\089\085\077\084\120\122\117\105\111\119\090\078\097\081\068\\",\\"\076\104\090\113\102\078\103\106\\";\\"\080\081\066\114\117\069\076\055\085\121\077\087\077\110\117\047\115\081\071\083\111\043\043\122\082\108\099\099\122\069\087\051\052\115\099\043\048\078\079\097\102\066\119\119\072\054\087\070\084\110\072\110\104\099\087\070\084\051\080\047\054\088\100\109\\";\\"\110\097\097\117\117\105\075\069\\",\\"\119\055\075\097\047\083\082\067\085\076\088\102\076\065\047\074\078\083\065\061\\";\\"\049\109\087\078\081\050\105\070\098\098\117\067\100\074\076\121\075\116\049\084\057\065\075\113\067\051\088\061\\",\\"\049\065\061\061\\";\\"\053\106\086\079\115\076\089\050\078\056\068\088\100\106\086\108\085\087\061\061\\",\\"\073\107\103\100\052\117\057\047\051\055\084\109\082\122\057\106\051\079\078\052\082\053\105\052\114\097\043\121\055\084\051\122\090\082\106\115\067\047\106\106\107\071\043\085\067\069\078\084\089\090\080\089\082\113\077\087\117\080\056\120\\";\\"\105\070\112\083\057\111\113\065\081\065\061\061\\";\\"\097\112\097\061\\";\\"\112\090\053\116\074\117\119\082\075\052\115\072\069\085\070\078\\";\\"\054\082\053\104\082\120\049\116\\",\\"\118\075\080\068\072\104\098\101\\",\\"\084\087\043\054\057\121\073\082\\",\\"\072\111\080\116\\",\\"\118\098\118\080\098\070\117\115\\";\\"\118\090\076\050\090\075\079\113\107\090\106\111\103\103\111\071\075\082\089\089\077\116\079\066\053\050\109\108\065\101\090\067\081\080\090\101\121\119\052\122\097\054\073\118\086\116\047\070\108\107\106\061\\";\\"\104\103\114\070\088\083\089\097\077\071\078\053\065\048\122\089\106\065\061\061\\",\\"\066\100\069\073\075\111\117\116\074\086\108\117\103\108\052\070\106\082\055\103\090\052\088\106\118\054\110\076\120\112\051\066\051\054\082\121\097\107\069\118\098\074\053\088\083\066\084\080\112\122\061\061\\";\\"\084\056\047\080\115\106\108\111\078\067\100\082\084\099\104\081\053\122\061\061\\",\\"\054\104\088\087\115\103\104\052\084\103\068\075\097\109\105\057\\";\\"\053\097\061\061\\",\\"\101\099\103\051\103\107\106\085\116\119\049\107\077\074\065\108\\";\\"\053\070\048\065\080\081\080\072\086\057\090\061\\",\\"\072\122\112\070\118\047\099\075\069\122\061\061\\",\\"\109\047\098\110\084\087\061\061\\";\\"\118\056\080\119\072\079\080\119\084\109\054\068\084\075\050\067\\";\\"\078\109\108\066\072\099\070\061\\"}for E,n in ipairs({{-298108-(-298109),-99135-(-99335)},{-423121-(-423122),-143105+143168};{295189-295125,-62588-(-62788)}})do while n[-391586+391587]<n[-942229+942231]do v[n[-940843+940844]],v[n[-350784+350786]],n[542627-542626],n[-524209-(-524211)]=v[n[753005-753003]],v[n[-1014114+1014115]],n[902371+-902370]+(1035891-1035890),n[-891441+891443]-(-658404-(-658405))end end local function E(E)return v[E+(-226747+257804)]end do local E={T=641333-641309;h=690519-690514,D=920732-920699;s=-989412-(-989430);q=305229+-305167,V=-1039526-(-1039571),b=-983354+983415;A=679640+-679608;W=347262+-347214;[\\"\047\\"]=-727252-(-727305);[\\"\057\\"]=-404770+404781,z=1034219-1034219;H=415576+-415549;S=650317+-650315,L=195473+-195422,Y=934128+-934115;C=880372-880335,X=-929077-(-929117),k=660915-660874,P=-856147+856168;R=460390+-460333,[\\"\052\\"]=55102+-55099,U=173068-173049,[\\"\054\\"]=-562743-(-562760),[\\"\056\\"]=943737-943683;t=-263041+263087,Z=-444453-(-444473);p=-275183-(-275219),d=575226+-575214;Q=428576+-428533,[\\"\055\\"]=960623-960576,c=658584-658529,[\\"\043\\"]=508251-508193;O=-277708+277730,r=868009-867975;o=-745997-(-746003);u=-206370-(-206371);B=-594117+594167;[\\"\053\\"]=275615-275585,v=162596+-162568;g=892025+-891990,K=309866-309828,E=339535+-339504,J=-765261+765271,f=75205+-75145;y=-943145-(-943187);l=-890327+890336;n=865550-865511;[\\"\050\\"]=-93568-(-93617),[\\"\048\\"]=-760717-(-760743);a=-214970+214986;G=-1032970-(-1033033),[\\"\049\\"]=-565172-(-565216),N=750848+-750823,M=744651-744595;[\\"\051\\"]=-936325-(-936339);w=-660854+660906,m=18160+-18137,F=337701-337693,I=-265181-(-265240);e=899632+-899625,x=-658442-(-658457),i=-736030+736059,j=894163+-894159}local n=string.sub local W=v local Q=string.char local g=string.len local i=math.floor local m=table.concat local X=type local w=table.insert for v=31589+-31588,#W,542394-542393 do local G=W[v]if X(G)==\\"\115\116\114\105\110\103\\"then local X=g(G)local U={}local T=347984+-347983 local N=-923738-(-923738)local B=813319-813319 while T<=X do local v=n(G,T,T)local W=E[v]if W then N=N+W*(-730042-(-730106))^((892392-892389)-B)B=B+(524588+-524587)if B==-539954-(-539958)then B=-995136+995136 local v=i(N/(-744466+810002))local E=i((N%(739134-673598))/(-740952+741208))local n=N%(115502+-115246)w(U,Q(v,E,n))N=-724169+724169 end elseif v==\\"\061\\"then w(U,Q(i(N/(448098-382562))))if T>=X or n(G,T+(-623681-(-623682)),T+(-799650+799651))~=\\"\061\\"then w(U,Q(i((N%(-683295+748831))/(-698998+699254))))end break end T=T+(-82042-(-82043))end W[v]=m(U)end end end return(function(v,W,Q,g,i,m,X,G,u,c,T,Z,k,w,I,r,B,N,t,A,n,U)r,T,k,u,U,A,c,Z,w,B,n,I,G,t,N=function(v,E)local W=N(E)local Q=function(...)return n(v,{...},E,W)end return Q end,-1012402-(-1012402),function(v,E)local W=N(E)local Q=function(Q,g,i)return n(v,{Q,g;i},E,W)end return Q end,function(v,E)local W=N(E)local Q=function(Q,g,i,m,X,w,G)return n(v,{Q;g;i,m,X,w;G},E,W)end return Q end,function()T=T+(-794672-(-794673))G[T]=593313-593312 return T end,function(v,E)local W=N(E)local Q=function(Q,g,i,m,X)return n(v,{Q,g,i,m;X},E,W)end return Q end,function(v)G[v]=G[v]-(303916-303915)if-819951-(-819951)==G[v]then G[v],w[v]=nil,nil end end,function(v,E)local W=N(E)local Q=function(Q,g,i,m)return n(v,{Q,g;i;m},E,W)end return Q end,{},function(v)local E,n=634839+-634838,v[-669403+669404]while n do G[n],E=G[n]-(-1024390+1024391),(-941575+941576)+E if-406815+406815==G[n]then G[n],w[n]=nil,nil end n=v[E]end end,function(n,Q,g,i)local V,q,b,G,H,T,s,Y,y,f,F,a,e,N,d,j,X,J,x,h,o,D,K,M,R,r,z,C,O,L,B,S,l,p,P while n do if n<-394136+9564297 then if n<771134+4107242 then if n<2839791-674083 then if n<1191821-(-59962)then if n<53194-(-493041)then if n<1206504-934316 then if n<928246-789857 then if n<-771224-(-859402)then T=E(549295+-580275)N=-745199+13126284 G=T^N X=-209677+12067323 n=X-G G=n X=E(-670030-(-639063))n=X/G X={n}n=v[E(-742552+711551)]else p=30270074551698-(-539005)x=E(-898314+867452)L=E(-268898-(-238010))r=v[L]D=v[x]f=E(235403+-266430)K=w[T]F=w[B]n=2390231-(-549131)V=F(f,p)f=E(-443840+412795)p=-758204+27474734056373 x=K[V]O=D[x]K=w[T]F=w[B]V=F(f,p)x=K[V]K=w[s]s=c(s)D={O(x,K)}L=r(W(D))end else if n<796247+-608732 then K,V=D(x,K)n=K and 15492935-(-356219)or-333256+11120619 else N=N+r T=N<=B s=not J T=s and T s=N>=B s=J and s T=s or T s=10829440-199698 n=T and s T=-1022028+11913515 n=n or T end end else if n<-271587+634946 then if n<-619798-(-933964)then s=s+O r=s<=L x=not D r=x and r x=s>=L x=D and x r=x or r x=7422248-(-536834)n=r and x r=446629+10337566 n=n or r else n=w[s]a=666112-666111 f=-112702+112708 q=n(a,f)n=E(-119646+88603)f=E(-154924-(-123881))v[n]=q a=v[f]f=38954-38952 n=a>f n=n and 14181396-709517 or 7608243-275512 end else if n<-643246-(-1037983)then K=w[g[768365-768364]]P=E(640398+-671335)n=-513852+4360907 F=w[g[-134679-(-134681)]]q=10917061866072-(-287107)V=F(P,q)x=K[V]o=x else n=s n=r and 482341+8096949 or 985396+14993776 end end end else if n<1795604-725778 then if n<-339286+1163440 then if n<1598012-998403 then X={}n=v[E(890930+-921803)]else y=864317+13897021991178 V=n z=E(-858896-(-828007))H=w[T]d=w[B]R=d(z,y)p=H[R]f=F[p]n=f and 2355485-(-953782)or 352345+9713612 x=f end else if n<923983+-16564 then f=-511144-(-511144)V=#K F=V==f n=962793+9687284 else M=w[T]j=M n=M and-571723+8194112 or 9704301-(-971352)end end else if n<566263+604355 then if n<-233866+1341008 then n=X and 986133+8179177 or 869750+3844734 else X=j n=M n=7259405-370722 end else L=E(460955-491843)V=4245817083456-458375 F=E(429417-460365)s=v[L]D=w[T]x=w[B]K=x(F,V)O=D[K]L=s(O)K=E(-784601+753592)L=E(154568+-185559)s=v[L]x=v[K]K={s(x)}L=K[-270175-(-270176)]n=15492097-425321 D=K[937546-937543]O=K[-736384+736386]end end end else if n<2018136-364610 then if n<542889+880960 then if n<-876874+2270264 then if n<2147426-830729 then f=n p=E(-799707-(-768732))C=7029497375192-56591 p=s[p]p=p(s)R=w[T]e=E(-618518+587484)z=w[B]H=E(-142693+111827)H=p[H]y=z(e,C)d=R[y]H=H(p,d)V=H n=H and 371073+15031348 or 5894726-965614 else n=-208512+5703235 s=nil J=nil r=nil end else if n<127590+1289368 then X=E(-393102+362111)n=v[X]B={n(G)}T=B[337775+-337773]X=B[-336341+336342]N=B[-819776+819779]B=X n=132550+14931113 else n=K n=o and 165754+7114570 or-764672+5033027 end end else if n<1175826-(-287384)then if n<860165-(-594891)then B=r..J n=s T=N..B n=X..T X={n}n=v[E(4560+-35489)]else K=n f=E(205094+-236146)V=v[f]f=V(x)p=w[T]H=w[B]z=-35075+1115722828554 R=E(717048+-747989)d=H(R,z)V=p[d]F=f==V n=F and-667667+10011817 or-966414+2387713 o=F end else if n<2059601-473979 then M=n b=24353+-24352 C=y[b]b=false e=C==b n=e and 16010954-(-391896)or 1683054-543258 j=e else r=-464039+464039 B=#T N=B>r X=N n=-846414+16413642 end end end else if n<693632+1285643 then if n<2698371-800302 then if n<2484947-731640 then H=c(H)Y=c(Y)d=c(d)z=c(z)y=nil p=c(p)R=c(R)n=11555203-(-351964)else D,x=L(O,D)n=D and 12159696-758967 or 1015482+8158386 end else if n<206882+1711026 then n=X and 910980+12618073 or 8345392-(-845990)else f=E(-800114-(-769226))C=-447665+10829137143907 V=v[f]d=E(623793-654655)H=v[d]R=w[T]e=E(-525176-(-494227))z=w[B]y=z(e,C)d=R[y]p=H[d]n=-61909+16049982 C=12306047578359-580245 e=E(513710-544595)R=w[T]z=w[B]y=z(e,C)d=R[y]z=E(492799-523689)R=v[z]z={R(K)}H={p(d,s,L,W(z))}f=V(W(H))end end else if n<-807011+2860387 then if n<1637511-(-356944)then B,s=r(N,B)n=B and-406949+8012849 or 433274+12088269 else n=r n=X and 15414958-311373 or 413768+12130009 end else n=L and-798323+14593811 or 2956261-(-6204)end end end end else if n<-375560+4020982 then if n<3220499-277497 then if n<-580197+3038630 then if n<-185842+2552645 then if n<843038+1495207 then n=V n=x and 3159868-(-247098)or-25664+686913 else x=2268525040137-626153 X=E(-275466+244514)n=v[X]s=E(-609870-(-579008))D=E(-495603+464615)J=v[s]L=w[g[-1035082-(-1035083)]]O=w[g[666315+-666313]]o=O(D,x)s=L[o]x=447817+35145486281380 r=J[s]D=E(426668+-457561)L=w[g[-921708+921709]]O=w[g[839340+-839338]]o=O(D,x)O=E(-775147-(-744257))s=L[o]L=v[O]O={L(N)}J={r(s,G,W(O))}X=n(W(J))n=false X={n;N}n=v[E(113445+-144321)]end else if n<716577+1702187 then D=E(-1072689-(-1041705))O=v[D]K=E(440209-471218)x=v[K]F=w[T]H=3508966495175-(-570010)p=E(501921+-532821)V=w[B]n=621129-184132 f=V(p,H)K=F[f]D=O(x,K)f=-318088+1042542681197 x=w[T]K=w[B]V=E(564808-595773)F=K(V,f)O=x[F]L=D[O]r=L else o=968850-968849 s=-284194+284449 r=-989798+35184373078630 n={}w[g[-365803-(-365805)]]=n X=w[g[-728654-(-728657)]]B=X X=T%r w[g[645515+-645511]]=X J=T%s s=-404927-(-404929)L=E(-822429+791567)n=9352095-337018 r=J+s w[g[-611968+611973]]=r D=o s=v[L]o=366461+-366461 L=E(689438+-720445)J=s[L]s=J(G)J=E(-534191-(-503278))N[T]=J J=519237+-519163 L=-106048+106049 O=s x=D<o o=L-D end end else if n<934847+1876200 then if n<2543924-(-6957)then s=16531184454923-978682 J=E(-949548-(-918639))X=E(-585690-(-554696))n=v[X]N=w[g[432370-432369]]B=w[g[-527348-(-527350)]]r=B(J,s)T=N[r]X=n(T)n=3334747-(-885601)else j=w[T]X=j n=j and 1847798-315454 or 7683458-794775 end else if n<3853977-914061 then F=30231190608850-894165 s=E(-958448+927560)K=E(594240+-625123)r=v[s]O=w[T]n=-755214-(-1046883)D=w[B]x=D(K,F)K=-945844+33143875185405 L=O[x]s=r(L)L=w[T]O=w[B]x=E(-404255+373376)D=O(x,K)s=L[D]L=A(917895+9660546,{T,B;J})F=340945383670-(-446376)r=N(s,L)K=E(15438+-46458)s=E(406184+-437072)r=v[s]O=w[T]D=w[B]x=D(K,F)L=O[x]s=r(L)r=-495273+495274 s=-601433-(-601453)L=s s=473413+-473412 O=s s=-854435+854435 D=O<s s=r-O else r=U()G=Q n=true N=E(-398471-(-367609))T=U()w[T]=n X=v[N]N=E(499585-530617)s=E(-79339+48437)n=X[N]L=k(-423457+7974011,{r})N=U()B=U()w[N]=n n=t(-302056+12940558,{})w[B]=n n=false w[r]=n J=v[s]s=J(L)X=s n=s and 10228904-348244 or 15947541-(-402001)end end end else if n<4102847-738884 then if n<3587428-471226 then if n<-95342+3047009 then X=E(-104932-(-74044))s=E(73936-104798)n=v[X]x=22538222300391-934888 J=v[s]L=w[g[-7893-(-7894)]]O=w[g[14753+-14751]]D=E(-246417-(-215495))o=O(D,x)s=L[o]D=E(96436+-127454)r=J[s]x=-29498+8237490864693 L=w[g[-851519+851520]]O=w[g[253234+-253232]]o=O(D,x)O=E(-78447-(-47557))s=L[o]L=v[O]D=n o=N n=N and-529277+4376332 or 494607+-115475 else J=nil n=471219+1519726 s=nil end else if n<2264673-(-1018061)then X={}r=nil N=nil n=v[E(-205889+174860)]L=nil T=c(T)B=c(B)s=nil J=c(J)else d=w[T]R=w[B]y=E(-304887-(-273932))e=875176+11760560536252 z=R(y,e)H=d[z]y=E(992181-1023125)d=-916147+916148 p=F[H]e=10466663374901-(-799444)R=-197407+197408 H=E(1033217+-1064143)H=p[H]n=999714+9066243 H=H(p,d,R)d=w[T]R=w[B]z=R(y,e)p=d[z]f=H~=p x=f end end else if n<4096294-605972 then if n<3639679-240041 then x=-617476-(-617506)D=#J O=n o=D>x n=o and 16679732-(-29881)or 7197274-(-902010)L=o else r=nil n=642753+10141442 K=nil F=nil end else n=F and-20447+15107702 or 15828558-(-299045)end end end else if n<245251+4022272 then if n<-833995+4880186 then if n<4698044-861379 then if n<33799+3732583 then n=15488750-487607 else X={T}n=v[E(-138595+107609)]end else if n<53696+3812393 then O={L(o)}n=D J={r(s,G,W(O))}X=n(W(J))n=true X={n,N}n=v[E(296218+-327135)]else X={}n=v[E(142912+-173899)]T=nil G=nil end end else if n<4969091-763304 then if n<4030519-(-52433)then X=T n=N n=14690776-(-344296)else s=c(s)J=nil r=c(r)O=c(O)L=nil V=c(V)N=c(N)B=c(B)V=-968393+968649 L=E(480449-511365)s=E(760151-791205)O=E(-697221+666359)B=U()o=c(o)D=nil F=nil J=E(-875633+844579)D={}o=U()T=c(T)N=nil T=nil F=728849+-728848 w[B]=T T=U()w[T]=N K=nil x=nil r=v[J]J=E(546305-577224)N=r[J]r=U()w[r]=N J=v[s]s=E(17652+-48696)N=J[s]s=v[L]L=E(316296+-347247)J=s[L]n=4821984-(-361058)L=v[O]f=V O=E(-678182-(-647281))s=L[O]L=319728+-319728 O=U()V=-977782+977783 w[O]=L L=683225-683223 w[o]=L K={}x=U()L={}p=V w[x]=D V=489908-489908 D=-981238-(-981238)Y=p<V V=F-p end else X={}G=nil n=v[E(439005-469925)]end end else if n<4245776-(-471115)then if n<176135+4284586 then if n<4284350-(-42946)then r=nil n=-862878+15576787 D=nil x=nil else K=15500117930708-792227 O=w[g[-413475-(-413476)]]o=w[g[919321+-919319]]x=E(-671954-(-640985))D=o(x,K)L=O[D]n=1190238-(-264228)J=L end else if n<4963881-269447 then T=w[g[688164-688161]]n=715684+8186304 N=-812263+812442 G=T*N T=-933100-(-933357)X=G%T w[g[-18310-(-18313)]]=X else n=-574823+5663095 s=nil J=nil r=nil end end else if n<4244577-(-534796)then if n<4080084-(-650049)then o=E(940495-971547)F=E(1029044+-1059925)O=v[o]o=O(J)D=w[g[970-969]]V=28236112702745-244157 x=w[g[-544718-(-544720)]]K=x(F,V)O=D[K]L=o==O n=L and 12766476-(-841975)or 554186-(-547261)X=L else K=w[x]R=4910887061834-(-196516)F=true r[K]=F d=E(-611242-(-580231))f=w[T]p=w[B]H=p(d,R)p=E(-53263+22373)V=f[H]f=v[p]H=w[s]p=f(H)F=V..p n=16600272-569853 V=k(9930336-131064,{T;B;x,s;J})K=N(F,V)end else G=E(-345232-(-314299))X=v[G]J=-301975+28553005502343 r=E(-460547-(-429615))T=w[g[-286405+286406]]N=w[g[300506+-300504]]B=N(r,J)G=T[B]n=X[G]X=n()n=518430-518430 G=X T=n X=E(-1042903-(-1011912))n=v[X]r={n(G)}X=r[187418-187417]n=2460042-469097 N=r[-444285-(-444287)]B=r[-908946-(-908949)]r=X end end end end end else if n<6259472-(-571229)then if n<5072721-(-716482)then if n<5799243-348018 then if n<4431212-(-733986)then if n<4179657-(-897209)then if n<-361918+5281333 then V=E(-970096-(-939107))n=w[g[-354126+354129]]P=11472117062020-33958 x=E(590341+-621245)O=w[g[586692+-586691]]o=w[g[-370365-(-370367)]]K=26262618985849-452020 D=o(x,K)o=E(290975-321865)L=O[D]O=v[o]o=O(r)D=E(210752-241614)s=L..o L=J n[s]=L s=-823609+823610 n=G+s G=n L=E(-612777+581889)s=v[L]o=v[D]x=w[g[-297410-(-297411)]]K=w[g[-178458-(-178460)]]F=K(V,P)D=x[F]V=E(310952+-341851)P=926337+21375513363552 O=o[D]x=w[g[250107-250106]]K=w[g[895384-895382]]F=K(V,P)D=x[F]n=6278904-503925 P=E(877777+-908703)x=#J P=J[P]F=-958874+958875 V=-839457-(-839537)K={P(J,F,V)}o={O(D,r,x,W(K))}L=s(W(o))else d=E(651318-682293)d=s[d]H=n h=-1024711+17706554360572 d=d(s)b=E(17684-48551)y=w[T]R=E(-413397-(-382531))e=w[B]C=e(b,h)z=y[C]R=d[R]R=R(d,z)p=R n=R and 11577234-(-1017194)or 32830+13966584 end else if n<5977128-851381 then G=G+N r=not B X=G<=T X=r and X r=G>=T r=B and r X=r or X r=12861540-544546 n=X and r X=5178682-(-316041)n=n or X else y=1031259+18384645055766 V=-1005806-(-1005807)F=s+V s=F L=x p=E(-37157+6105)f=v[p]p=f(K)H=w[T]z=E(-909442-(-878403))d=w[B]R=d(z,y)f=H[R]V=p==f n=V and 14420+10895714 or 731461+1228902 end end else if n<6036830-668138 then if n<5355992-119308 then V=V+p F=V<=f H=not Y F=H and F H=V>=f H=Y and H F=H or F H=75074+9923782 n=F and H F=-809405+1664668 n=n or F else N=nil n=12828627-221091 end else if n<938741+4471963 then O=#J o=530810+-530780 n=5414734-(-580958)L=O>o s=L else L=E(579035-609923)s=v[L]D=w[T]x=w[B]F=E(788356-819326)V=23412606882861-895383 K=x(F,V)n=1916195-676111 O=D[K]K=E(812077-843126)L=s(O)O=w[T]D=w[B]F=25122193904750-370364 x=D(K,F)L=O[x]O=Z(4688918-(-177902),{T;B,J})s=N(L,O)end end end else if n<6125752-619899 then if n<4480215-(-993327)then if n<6310201-853742 then X={}n=v[E(401879+-432851)]else x=n K=E(-615110-(-584135))K=J[K]K=K(J)P=w[g[98812-98811]]p=21604745647004-93264 q=w[g[328640-328638]]F=E(879728+-910594)f=E(-791154-(-760280))a=q(f,p)V=P[a]F=K[F]F=F(K,V)n=F and 12536604-407049 or 589407+5421281 D=F end else if n<635261+4854430 then B=-23534-(-23535)r=-750756-(-750758)T=w[g[-61413-(-61414)]]N=T(B,r)T=-287398+287399 G=N==T X=G n=G and-13490+1913927 or 5986541-(-602771)else X={}n=v[E(-860036-(-829178))]end end else if n<5519315-(-215789)then if n<-625946+6315202 then X=-513523+16665148 N=-117149+9729221 T=E(445444+-476456)G=T^N n=X-G X=E(268925+-299882)G=n n=X/G X={n}n=v[E(761398-792434)]else D,x=L(O,D)n=D and 561911+14361113 or 774613+-655336 end else r=nil n=-258194+15484013 J=nil end end end else if n<894672+5558127 then if n<6937101-940644 then if n<-24462+5921646 then if n<6768478-965515 then n=-970766+4802801 else F={}V=U()w[V]=F f=k(14801567-681921,{V,O;o,r})F=U()w[F]=f Y=E(-891235+860240)f={}p=U()e=nil w[p]=f H={}f=v[Y]N=nil s=nil R=E(-1020724-(-989829))r=c(r)z=w[p]y=E(-511494+480521)D=nil L=nil d={[R]=z;[y]=e}J=nil Y=f(H,d)f=u(13930089-(-783302),{p;V,x;O;o,F})J=E(-142445-(-111436))x=c(x)O=c(O)K=nil F=c(F)p=c(p)V=c(V)w[T]=Y w[B]=f r=v[J]o=c(o)N=not r n=N and 13326764-(-840994)or 1001341+11606195 end else if n<-1030400+6983316 then r=nil n=431095+14632568 J=nil else n=s and 5340903-422014 or 5904694-129715 end end else if n<810547+5586312 then if n<115218+6011309 then F=E(302991+-333857)K=E(-1009646+978671)K=J[K]f=E(-500890-(-470003))K=K(J)F=K[F]P=w[g[-1035413+1035414]]p=-1018858+31193883657383 q=w[g[-997814+997816]]a=q(f,p)V=P[a]F=F(K,V)n=-967720+13097275 D=F else x=w[J]p=w[T]C=E(-113996-(-82958))z=319319+12547282646907 H=w[B]R=E(-198240+167328)d=H(R,z)y=16071007646917-38794 f=p[d]S=E(-14629+-16263)V=f..r z=E(-676039+645009)e=31247227676675-651053 H=w[T]d=w[B]R=d(z,y)p=H[R]f=F[p]x[V]=f V=E(-519618-(-488730))H=E(639538-670400)x=v[V]p=v[H]l=12620525310943-(-754453)y=E(-649416+618555)d=w[T]R=w[B]z=R(y,e)H=d[z]y=E(226949+-257831)f=p[H]d=w[T]R=w[B]e=684013+11317489951913 z=R(y,e)b=2919220045403-286988 H=d[z]z=w[T]y=w[B]e=y(C,b)R=z[e]d=F[R]z=n C=w[T]b=w[B]h=b(S,l)e=C[h]y=F[e]e=-947378+947378 R=y or e p={f(H,r,d,R)}n=16610082-283455 V=x(W(p))end else r=N V=3278280748371-(-153763)o=E(-645713+614661)O=v[o]F=E(-65087-(-34181))o=O(J)D=w[g[-575543+575544]]x=w[g[-295860-(-295862)]]K=x(F,V)O=D[K]L=o==O s=L n=L and-360405+5760684 or 5061579-(-934113)end end else if n<5675918-(-961869)then if n<-740062+7290458 then if n<5823443-(-703682)then J=w[g[880741+-880740]]o=47111+11557855042815 s=w[g[-735994-(-735996)]]O=E(426887-457815)L=s(O,o)r=J[L]n=4672282-617450 B=G[r]T=B else T=E(-587333-(-556324))G=v[T]s=-558006+13131562851224 N=w[g[664371+-664370]]J=E(1035574+-1066513)B=w[g[235242-235240]]K=936192+13556076089256 r=B(J,s)T=N[r]X=G[T]T=w[g[-773184+773185]]J=9865702023044-363922 D=E(82950+-113819)r=E(-967438-(-936382))N=w[g[404956+-404954]]B=N(r,J)G=T[B]n=X[G]G=w[g[436809+-436806]]X=n(G)x=865350+28857354764343 G=X X=E(-554443+523553)s=E(142653-173515)n=v[X]X=n(G)T=X B=1047389-1047387 N=-358468-(-358469)X=w[g[-832180+832184]]n=X+N w[g[378917-378913]]=n N=E(498928-529842)X=v[N]J=v[s]L=w[g[-224565-(-224566)]]F=806774+33834631392789 O=w[g[1024278-1024276]]o=O(D,x)s=L[o]r=J[s]L=w[g[832401+-832400]]D=E(-590163+559121)x=9455012167006-(-562132)O=w[g[-213084+213086]]o=O(D,x)x=E(-171996+141083)s=L[o]O=w[g[-329748-(-329749)]]o=w[g[-659469-(-659471)]]D=o(x,K)L=O[D]J={r(T,s,L)}N=X(B,W(J))B=E(357358+-388272)L=E(-72386+41524)r=-470506+470508 K=2587460966054-233970 X=v[B]s=v[L]O=w[g[785912-785911]]o=w[g[880405+-880403]]x=E(506711-537693)D=o(x,K)L=O[D]J=s[L]K=19664839065236-(-992561)x=E(-859113-(-828120))O=w[g[241870+-241869]]o=w[g[101432+-101430]]D=o(x,K)K=E(115607-146520)L=O[D]o=w[g[262304+-262303]]D=w[g[-184434-(-184436)]]x=D(K,F)O=o[x]s={J(T,L,O)}B=X(r,W(s))s=870034+-870034 r=n J=N>s n=J and 460520+8868086 or 1037933+956757 X=J end else if n<7027725-407586 then T=w[g[-705351-(-705353)]]N=w[g[-404970+404973]]G=T==N n=431872+1468565 X=G else n=2212650-(-749815)end end else if n<7525618-718441 then if n<5701586-(-976971)then B=nil s=nil n=4594004-761969 J=nil else J=E(331998+-362992)r=v[J]x=E(-776028-(-745163))K=-271521+17722138313949 L=w[T]O=w[B]D=O(x,K)s=L[D]n=-620916+5874250 J=r(s)end else n=-682900+10480763 end end end end else if n<7897218-(-543736)then if n<8369240-762014 then if n<7334215-(-18866)then if n<6868881-(-340622)then if n<7796796-861127 then w[T]=X n=1527620-(-144082)else G=nil w[g[-109615+109620]]=X n=745589+8445793 end else if n<950394+6346350 then n=7642018-195093 o=x K=E(553090-584099)v[K]=o r=nil D=nil x=nil else f=E(-641178-(-610135))n=v[f]f=E(153121-184171)v[f]=n n=12187582-553041 end end else if n<6822388-(-678308)then if n<-555061+7941124 then n=F n=K and 916694+11874694 or 397840+8819558 else s=E(973025-1004034)J=v[s]r=not J n=r and 6464252-(-241680)or 4652125-(-601209)end else if n<-484104+8046075 then n=true w[g[-261843+261844]]=n X={}n=v[E(-786154+755249)]else J=B D=E(-976854+945802)V=E(264452+-295360)P=28323493237013-(-8816)o=v[D]D=o(J)x=w[g[1018076+-1018075]]K=w[g[-545537-(-545539)]]F=K(V,P)o=x[F]O=D==o L=O n=O and 484640+8186106 or 2090024-(-33417)end end end else if n<-1048452+9025807 then if n<8070813-396865 then if n<-687496+8327646 then e=-707949+707950 n=10471927-(-203726)M=y[e]j=M else D=nil x=nil n=12596641-(-150008)end else if n<-132905+8098703 then r=s K=E(617557-648459)p=E(756928+-787861)x=v[K]f=v[p]y=-203141+9173100866100 H=w[T]z=E(279268-310265)d=w[B]R=d(z,y)p=H[R]V=f[p]z=78827+25986196126553 p=w[T]H=w[B]R=E(-156108+125071)d=H(R,z)f=p[d]p={x(V,r,f)}K=p[113890-113889]f=not K F=p[-328255+328257]x=f V=n n=f and 2319607-142222 or 226905+10847837 else p=w[g[-916170-(-916171)]]d=E(898962+-930015)R=24059036881370-763415 Y=w[g[-104205+104207]]H=Y(d,R)Y=-473937-(-473938)R=990320+6096855346855 f=p[H]d=E(292519-323497)a=K[f]p=-970708+970709 f=E(-991821-(-960895))f=a[f]n=16063328-136057 f=f(a,p,Y)p=w[g[-922565+922566]]Y=w[g[-267772-(-267774)]]H=Y(d,R)a=p[H]q=f~=a V=q end end else if n<434109+7680326 then if n<8498205-463338 then D=-446810+446823 T=w[g[843085+-843082]]N=-306744-(-306776)O=301572-301570 G=T%N B=w[g[-70440-(-70444)]]s=w[g[870409-870407]]F=w[g[631402+-631399]]K=F-G F=-861196+861228 x=K/F o=D-x n=-975002+9442103 L=O^o J=s/L L=-1017718-(-1017719)O=-277698-(-277954)D=-363507+363763 r=B(J)B=-257934+4295225230 N=r%B r=905350-905348 B=r^G T=N/B B=w[g[-659367+659371]]s=T%L L=-712691+4295679987 J=s*L r=B(J)B=w[g[910824+-910820]]J=B(T)N=r+J T=nil r=323683+-258147 B=N%r s=68345-2809 J=N-B r=J/s s=-132020+132276 N=nil J=B%s L=B-J s=L/O B=nil O=-133033-(-133289)G=nil L=r%O o=r-L O=o/D o={J,s;L;O}O=nil J=nil L=nil s=nil w[g[229179-229178]]=o r=nil else s=L n=O n=8891193-(-187095)end else V=30548082936330-479865 F=E(915515-946478)O=E(229331+-260264)L=v[O]D=w[T]x=w[B]K=x(F,V)O=D[K]s=L[O]n=s and-86175+5536701 or 452793-(-787291)end end end else if n<9762941-974536 then if n<805064+7767264 then if n<-689591+9229685 then if n<8295385-(-204631)then n=v[E(477560+-508586)]N=E(501504-532420)T=v[N]N=E(-236622+205671)G=T[N]N=w[g[778070-778069]]T={G(N)}X={W(T)}else n=-762354+13130498 o=E(-315568-(-284698))O=v[o]X=O end else if n<9322878-761307 then n=true n=n and-45658+6866240 or 294658+14485093 else N=678100+-677871 T=w[g[-712685-(-712687)]]G=T*N T=8914476638149-(-569458)X=G+T G=35184371983083-(-105749)n=X%G w[g[640836-640834]]=n T=-56397+56398 G=w[g[442253-442250]]n=-1011883+5586109 X=G~=T end end else if n<573721+8197804 then if n<566190+8081207 then F=8574234540367-862647 s=E(-1033599-(-1002711))r=v[s]n=-186329+5906064 O=w[T]D=w[B]K=E(-791853+760813)x=D(K,F)L=O[x]K=E(-390848-(-359839))s=r(L)s=U()r=-523669+523669 L=E(413260+-444251)w[s]=r r=v[L]x=v[K]K={r(x)}O=K[-354890-(-354892)]L=K[-760766+760767]D=K[-535402-(-535405)]else a=304490+10956322188931 D=E(-1038454-(-1007479))o=n D=J[D]D=D(J)q=E(-105558-(-74664))F=w[g[-613931-(-613932)]]V=w[g[-1045630+1045632]]P=V(q,a)x=E(-984990-(-954124))K=F[P]x=D[x]x=x(D,K)n=x and 13861873-297806 or 4909112-(-563664)O=x end else X={}G=nil n=v[E(-271069-(-240138))]end end else if n<9494731-426779 then if n<9667685-728944 then if n<9738280-904507 then f=-851049-(-851049)V=#K F=V==f n=F and 5879732-57044 or 396123+10253954 else T=w[g[-256122-(-256125)]]N=973180+-973179 G=T~=N n=G and 8870531-889849 or 751818+3822408 end else if n<9232879-218431 then V=6474320663635-(-374643)L=E(-349582+318694)s=v[L]D=w[T]x=w[B]F=E(153501-184504)K=x(F,V)O=D[K]L=s(O)s=754547+-754547 O=E(906963+-937954)L=v[O]K=w[J]F={L(K)}O=F[-1029911-(-1029912)]x=F[-967694+967697]n=-849887+12502943 D=F[704240+-704238]else o=o+D K=not x L=o<=O L=K and L K=o>=O K=x and K L=K or L K=340954+12095480 n=L and K L=7491630-840743 n=n or L end end else if n<8260724-(-896631)then if n<8844561-(-282437)then n=s and 8125571-(-1013813)or-756906+6685847 else K=587902+32113924751852 n=w[g[83115+-83112]]O=w[g[537601-537600]]x=E(96045-126972)o=w[g[-41458-(-41460)]]D=o(x,K)o=E(514754-545644)L=O[D]O=v[o]o=O(r)s=L..o L=J n[s]=L o=E(325767-356629)V=24762275568701-(-168141)s=E(-502215+471327)n=v[s]F=E(-539185-(-508177))O=v[o]D=w[g[455225+-455224]]x=w[g[50342-50340]]K=x(F,V)F=E(-412009-(-381099))V=25808564777136-(-327234)o=D[K]L=O[o]D=w[g[-144851+144852]]x=w[g[636054+-636052]]K=x(F,V)o=D[K]D=#J O={L(o,r,D)}s=n(W(O))n=6496579-567638 end else L=E(-96887+66025)K=582021+2870388810675 x=E(180342-211298)X=v[L]O=w[g[-887544-(-887545)]]o=w[g[647750-647748]]D=o(x,K)L=O[D]P=26561210094389-(-875803)K=4125464856243-573234 n=X[L]O=w[g[-801006+801007]]o=w[g[220952+-220950]]V=E(-457817+426853)x=E(-316822+285832)D=o(x,K)L=O[D]O=w[g[-270365+270369]]o=#J X=n(L,r,O,o)n=w[g[-637580+637585]]L=X X=J n[L]=X X=E(-725184-(-694296))n=v[X]D=E(850930+-881792)o=v[D]x=w[g[-357271-(-357272)]]K=w[g[-343934-(-343936)]]F=K(V,P)D=x[F]P=27092510939856-878985 V=E(947203-978177)O=o[D]x=w[g[667479+-667478]]K=w[g[-714432-(-714434)]]F=K(V,P)K=-508109+508110 V=E(-1014899+983973)V=J[V]D=x[F]F=649800+-649740 x={V(J,K,F)}o={O(D,L,W(x))}X=n(W(o))L=nil n=4735825-21341 end end end end end end else if n<-806114+13489165 then if n<639529+10025286 then if n<-53883+9875839 then if n<1030539+8432244 then if n<161087+9080170 then if n<882758+8317518 then if n<8812829-(-363650)then L=E(1010592-1041480)s=v[L]D=w[T]x=w[B]F=E(800370-831353)V=33888917105907-454479 K=x(F,V)F=-508954+11077452191808 V=13460737727991-1017211 O=D[K]L=s(O)O=w[T]K=E(860379-891276)D=w[B]x=D(K,F)L=O[x]F=E(121838+-152859)O=t(-528173+16338634,{T;B,J})s=N(L,O)O=E(128561+-159570)L=v[O]D=w[T]x=w[B]K=x(F,V)O=D[K]s=L[O]n=s and-322712+17071337 or-866440+9067982 else n=w[g[311430-311423]]n=n and-894934+16846050 or 10462654-211082 end else if n<-522778+9738035 then V=E(-558766+527876)F=v[V]Y=236679+10308447729209 p=E(782166+-813089)V=F(r)F=E(-815684+784709)F=V[F]F=F(V)q=w[g[639971+-639970]]a=w[g[498558-498556]]n=916213+14261993 V=E(208053+-238919)f=a(p,Y)V=F[V]P=q[f]V=V(F,P)x=V else x=c(x)s=nil n=733902+14332874 end end else if n<9018242-(-295122)then if n<8525067-(-764834)then J=E(771739-802743)n=w[g[272811-272808]]N=w[g[143781-143780]]s=16363155409702-109923 B=w[g[-382630+382632]]r=B(J,s)X=N[r]N=T n[X]=N N=E(-303084-(-272222))X=v[N]s=E(-511084-(-480206))B=w[g[-210965-(-210966)]]L=27628863171614-473565 r=w[g[-204416-(-204418)]]J=r(s,L)L=10792079747922-(-174159)N=B[J]n=X[N]s=E(717987+-748986)B=w[g[870123+-870122]]r=w[g[-538720-(-538722)]]J=r(s,L)N=B[J]B=#T X={n(N,B)}X={W(X)}n=v[E(406863+-437749)]else n=F n=K and 5469108-716331 or-455587+16486006 end else if n<-277580+9608327 then s=-255912+255912 J=B>s n=1156653-(-838037)X=J else f=w[T]n=735011-(-686288)R=119948278913-703562 d=E(-123146-(-92221))p=w[B]H=p(d,R)V=f[H]F=x[V]o=F end end end else if n<9918981-160316 then if n<-490196+10214730 then if n<223323+9343366 then D=E(249091+-280082)L={}n=707718+-564396 O=v[D]V=w[J]f={O(V)}K=f[58870-58867]x=f[145272-145270]D=f[-857543-(-857544)]else N=n r=E(-664946+633962)B=v[r]o=E(-1011206-(-980200))s=w[g[117144+-117143]]L=w[g[-1034640+1034642]]D=3815872999629-666077 O=L(o,D)J=s[O]r=B(G,J)T=r n=r and 3947092-(-107740)or 6395193-(-93746)end else if n<429736+9301636 then G=E(-664874+633865)X=v[G]L=E(-611999+581028)J=34981665870770-87057 T=w[g[849146-849145]]N=w[g[349367-349365]]r=E(896866-927784)B=N(r,J)O=4262559859333-(-967995)G=T[B]n=X[G]G=n N=E(654368+-685352)T=v[N]r=w[g[-685335+685336]]J=w[g[73395+-73393]]s=J(L,O)B=r[s]N=T(G,B)X=N n=N and 14281534-(-753538)or-892107+10509266 else X=E(105889-136883)L=215998+27680645736091 s=E(552892+-583790)n=v[X]B=w[g[858592-858591]]r=w[g[-503725+503727]]J=r(s,L)N=B[J]X=n(N)n=3731514-(-255715)end end else if n<930337+8868049 then if n<340670+9450988 then p=613677+1722984850933 r=J f=E(-222500+191558)x=E(-531169+500236)D=v[x]K=w[T]F=w[B]V=F(f,p)x=K[V]o=D[x]K={o(N,r)}x=K[-574577-(-574579)]D=K[-841827-(-841828)]o=not D n=o and 40394+11894503 or 976729+478552 else n=true n=n and-950823+1285658 or-46040+5501763 end else n=397586+4690686 X=787378+-787377 G=19401-19301 T=G G=425525+-425524 N=G G=999059+-999059 B=N<G G=X-N end end end else if n<-603293+10883160 then if n<10762978-704966 then if n<9840644-(-127674)then if n<-646768+10524646 then p=w[x]f=r[p]V=not f n=9563190-255308 K=V else J=w[r]X=J n=1021412+15328130 end else if n<-54137+10101496 then F=V n=4207024-(-976018)H=F K[F]=H F=nil else n=149344-149344 G=n X=E(173437-204428)n=v[X]r=E(-253306+222297)B=v[r]r={n(B)}T=r[644597-644595]N=r[-5181+5184]X=r[284983+-284982]B=X n=15723114-497295 end end else if n<649579+9528056 then if n<9288817-(-812894)then n=V n=x and 263923+6031414 or-975276+17301903 else x=E(528735-559651)D=v[x]p=E(-4793-26232)K=w[T]V=w[B]H=34745851570194-(-694049)f=V(p,H)H=962928+28857773179661 x=K[f]O=D[x]d=-161404+16227894285312 K=w[T]p=E(659362+-690297)V=w[B]n=2292414-(-935131)f=V(p,H)H=E(-69556+38595)x=K[f]D=O(L,x)x=E(-608567+577679)O=v[x]V=w[T]f=w[B]p=f(H,d)K=V[p]x=O(K)x=E(-682504+651616)O=v[x]x=O(D)D=nil end else n={}N=w[g[161299-161290]]T=-815287+815288 B=N G=n N=370838-370837 n=-137962-(-378714)r=N N=-244571-(-244571)J=r<N N=T-r end end else if n<-948226+11535797 then if n<10952072-599825 then if n<-296969+10631771 then B=E(-75725-(-44835))N=v[B]B=N(G)L=E(308907+-339929)r=w[g[310205-310204]]J=w[g[466069+-466067]]n=v[E(632094-663109)]O=2048949357455-165845 s=J(L,O)N=r[s]T=B..N X={T}else s=D p=E(401103-432155)K=U()w[K]=x x=K F=n f=v[p]y=12739599479141-268857 H=w[x]p=f(H)H=w[T]d=w[B]z=E(-406033+375054)R=d(z,y)f=H[R]V=p==f n=V and 354837+897187 or 6775557-(-588420)K=V end else if n<10501749-(-55523)then p=E(161684+-192637)K=n V=E(-472298+441408)F=v[V]V=F(r)F=E(499316-530291)Y=34287030783127-(-782791)F=V[F]F=F(V)q=w[g[-257769+257770]]a=w[g[215734-215732]]V=E(878557-909423)f=a(p,Y)P=q[f]V=F[V]V=V(F,P)x=V n=V and-358316+15536522 or 8353884-(-846848)else G=E(-976005-(-945072))X=v[G]T=w[g[239088+-239087]]J=18291335138777-(-201580)s=33509470435732-(-181088)r=E(-679582-(-648723))N=w[g[556755+-556753]]B=N(r,J)G=T[B]n=X[G]N=w[g[-614361+614362]]G=-307959+307960 B=w[g[385260-385258]]J=E(283176-314192)r=B(J,s)T=N[r]X=n(G,T)G=X n=G and 40695+15017960 or 11463998-(-954277)X=G end end else if n<11117214-486575 then if n<10233106-(-386247)then F=E(947262-978195)f=12981583588406-(-846695)K=v[F]a=E(-12755-18183)V=w[g[622973+-622972]]P=w[g[685943+-685941]]q=P(a,f)F=V[q]f=-130136+23102020740701 a=E(-151805-(-120942))n=K[F]V=w[g[-423098+423099]]P=w[g[-846549-(-846551)]]q=P(a,f)F=V[q]K=n(x,F)F=K n=K and 16188831-619640 or 669604+2852542 else T=N L=772669+-772669 O=811778+-811523 n=w[g[-117250+117251]]s=n(L,O)n=230386-(-10366)G[T]=s T=nil end else f=#K V=-522535+522536 F=N(V,f)n=-1033411+9854990 V=J(K,F)H=329598-329597 f=w[x]Y=V-H p=s(Y)F=nil f[V]=p V=nil end end end end else if n<11322334-(-731836)then if n<975066+10370103 then if n<1043332+9853741 then if n<9830403-(-956684)then if n<10039134-(-664690)then w[T]=j b=w[d]h=115743-115742 C=b+h e=y[C]M=D+e e=577375+-577119 n=M%e C=w[H]e=x+C C=184818-184562 M=e%C D=n n=-669768+2341470 x=M else s=E(167801-198689)r=v[s]O=w[T]K=E(785693+-816678)D=w[B]F=32625918991032-(-696480)x=D(K,F)n=-814443+2706509 L=O[x]K=E(-299014-(-268005))s=r(L)r={}L=E(976148+-1007139)s=v[L]x=v[K]K={s(x)}O=K[100329-100327]L=K[-437253-(-437254)]D=K[380668-380665]end else if n<-765516+11652437 then D=#L x=-105142+105142 O=D>x n=O and-46110+10203018 or 1039106+2188439 else n=w[g[-951340-(-951350)]]T=w[g[-189274-(-189285)]]G[n]=T n=w[g[-711164+711176]]T={n(G)}X={W(T)}n=v[E(806263-837265)]end end else if n<10822423-(-231255)then if n<487771+10426412 then f=E(-462760+431872)d=E(665156-696018)C=1513966072166-(-987482)V=v[f]e=E(-725717+694783)H=v[d]R=w[T]z=w[B]y=z(e,C)d=R[y]p=H[d]R=w[T]e=E(704251-735284)C=22837477203953-865895 z=w[B]y=z(e,C)d=R[y]n=15199198-(-788875)y=898430+-898429 R=#K e=867142+-867062 C=E(730423-761349)C=K[C]z={C(K,y,e)}H={p(d,s,L,R,W(z))}f=V(W(H))else O=E(-747559-(-716671))K=E(655395+-686257)L=v[O]x=v[K]V=w[T]n=9291840-(-264722)H=E(1005257-1036125)f=w[B]d=6192847590700-543209 p=f(H,d)K=V[p]D=x[K]H=E(-506896-(-475850))d=534281307043-426667 V=w[T]f=w[B]p=f(H,d)K=V[p]x={D(K,s)}O=L(W(x))end else if n<-434667+11625398 then n=1499408-(-677977)f=not F x=f else n=9156323-370590 end end end else if n<11623570-(-31195)then if n<12212644-732805 then if n<10912929-(-551795)then y=33189294052092-(-797026)s=D K=U()w[K]=s s=K p=E(-157817+126765)K=U()w[K]=x f=v[p]F=n z=E(242791+-273789)x=K H=w[x]p=f(H)H=w[T]d=w[B]R=d(z,y)f=H[R]V=p==f K=V n=V and 9630752-(-244151)or 9862170-554288 else X=O n=o n=O and 11961551-(-406593)or 79068+8457543 end else if n<-744518+12390152 then n=8893530-(-904333)else x,K=O(D,x)n=x and 5920614-790375 or 374555+12246020 end end else if n<-235360+12143868 then if n<489549+11208713 then n=465238+13677498 p=#L H=-369404-(-369405)f=p+H p=V L[f]=p else P=P+a X=P<=q p=not f X=p and X p=P>=q p=f and p X=p or X p=12639450-(-72081)n=X and p X=16056873-832840 n=n or X end else D=nil x=nil n=-224775+7671700 r=nil end end end else if n<12526692-99635 then if n<-341804+12720213 then if n<-715768+12947251 then if n<-11141+12167592 then O=D n=x n=-839470+14403537 else O=E(-727820+696868)L=v[O]f=E(226169-257193)n=-998843+10555405 x=w[T]K=w[B]p=369990+15333749814942 V=K(f,p)D=x[V]O=L(D)end else if n<217472+12143771 then J=E(273601+-304534)X=v[J]s=w[g[-31595-(-31596)]]r=G o=E(-443697-(-412666))L=w[g[-518621+518623]]D=436111+21018500611756 O=L(o,D)J=s[O]n=X[J]s=w[g[694260-694257]]L={n(s,r)}J=L[-17104-(-17106)]X=L[1026139-1026138]s=X n=not s n=n and-934854+2320287 or 4865937-141371 else O=U()D=564107+-564042 w[O]=X n=w[s]o=563387+-563384 X=n(o,D)o=U()w[o]=X K=E(-1074125-(-1043223))n=535072+-535072 D=n X=v[K]n=-964057+964057 F=k(-546705-(-632045),{})K={X(F)}a=E(-1055073-(-1024183))x=n n={W(K)}K=n X=505368+-505366 n=K[X]X=E(344812+-375755)F=n n=v[X]V=w[N]q=v[a]a=q(F)q=E(-636705-(-605664))P=V(a,q)V={P()}X=n(W(V))V=U()w[V]=X X=-853406-(-853407)P=w[o]q=P P=-505886+505887 n=181983+11725184 a=P P=-860290+860290 f=a<P P=X-a end end else if n<324724+12083941 then if n<12196302-(-201029)then n=-334419+7441778 N=w[g[73346+-73340]]T=N==G X=T else n=w[g[810056-810053]]T=w[g[-274737-(-274738)]]r=E(581845+-612826)J=26271069431007-(-445162)K=E(-662458+631499)N=w[g[139880+-139878]]B=N(r,J)s=E(46663-77574)o=3399621184743-1720 L=-465627+30009760059761 X=T[B]B=w[g[-738178-(-738179)]]r=w[g[-213791+213793]]J=r(s,L)N=B[J]T=G[N]n[X]=T r=E(-86395-(-55504))T=w[g[-396640+396641]]J=-142901+23209580025964 N=w[g[570639-570637]]B=N(r,J)F=25659616705527-429387 X=T[B]L=E(-1047000-(-1016046))O=-56571+27313612295849 r=w[g[476367-476366]]J=w[g[-881301-(-881303)]]s=J(L,O)O=E(-508203-(-477227))B=r[s]N=G[B]J=w[g[924264+-924263]]s=w[g[821053+-821051]]L=s(O,o)r=J[L]s=n o=w[g[795922+-795921]]D=w[g[303511+-303509]]x=D(K,F)O=o[x]L=G[O]J=L n=L and-214446+1668912 or 4894003-554378 end else n=X and 12529901-123482 or 2854220-393898 end end else if n<809625+11795083 then if n<873506+11657116 then if n<12724322-225356 then a=E(760794-791656)L=o n=8060637-(-954440)q=v[a]a=E(-166635+135751)P=q[a]q=P(G,L)P=w[g[-391010+391016]]a=P()V=q+a F=V+J a=-108340-(-108341)V=233735+-233479 K=F%V J=K L=nil V=N[T]q=J+a P=B[q]F=V..P N[T]=F else r=E(-239720+208830)o=178970+16405304140477 n=v[E(894469-925517)]B=v[r]r=B(T)J=w[g[-110492+110493]]s=w[g[192689-192687]]O=E(-204372+173501)L=s(O,o)B=J[L]N=r..B X={N}end else if n<-716893+13283364 then G=nil B=nil T=nil X={}n=v[E(616431-647397)]N=nil else V=p n=H n=14899518-(-502903)end end else if n<-622685+13251574 then if n<12735143-117633 then r=E(-103010-(-72122))x=30961479962090-(-420455)D=E(565674+-596697)N=v[r]s=w[T]L=w[B]K=E(-819911-(-788897))O=L(D,x)J=s[O]r=N(J)N=Z(14001080-925132,{T;B})s=E(-687690-(-656802))r={}J=U()w[J]=r F=5669141451743-510352 r=v[s]O=w[T]D=w[B]x=D(K,F)L=O[x]x=E(-802491-(-771588))s=r(L)L=w[T]p=-901772+246308127486 K=29898754699967-719965 O=w[B]D=O(x,K)s=L[D]x=E(984738+-1015747)L=Z(10241604-189979,{T,B,J})f=E(-532743+501819)r=N(s,L)s=n O=E(680217-711201)L=v[O]D=v[x]K=w[T]F=w[B]V=F(f,p)x=K[V]O=L(D,x)n=O and 382541+1989771 or 1065973-628976 r=O else O=-568743-(-568743)L=s==O n=L and 13039135-876977 or 9934627-(-985415)end else X=E(-10077-20917)G=E(-641513+610566)n=v[X]X=n(G)n=v[E(-741681-(-710723))]X={}end end end end end else if n<-881075+15816610 then if n<13698628-(-23471)then if n<733873+12789423 then if n<12627878-(-412853)then if n<13753164-1034299 then if n<12963253-252830 then n=true n=70133+14709618 else Y=E(-742836+711782)H=-698602+698702 p=U()w[p]=P X=v[Y]Y=E(196464+-227508)n=X[Y]Y=-535067-(-535068)X=n(Y,H)y=-161878+161880 Y=U()d=-22876-(-23131)S=394572+-384572 H=463205-463205 w[Y]=X e=E(-606172+575282)n=w[s]X=n(H,d)d=-691408+691409 z=472368-472367 H=U()w[H]=X n=w[s]R=w[Y]h=-248818+248818 X=n(d,R)d=U()w[d]=X X=w[s]R=X(z,y)X=883184-883183 n=R==X X=E(-21763+-9278)R=U()w[R]=n y=E(844018+-875010)M=v[e]n=E(-350151+319215)C=w[s]b={C(h,S)}e=M(W(b))M=E(-133530-(-102538))n=F[n]j=e..M z=y..j n=n(F,X,z)z=U()y=E(321394-352296)j=t(278707+5200516,{s,p;o,N,T,V;R;z,Y;d,H;O})w[z]=n X=v[y]y={X(j)}n={W(y)}y=n n=w[R]n=n and 454634+2297541 or 855937+84362 end else if n<305679+12476265 then o,x=L(O,o)n=o and-472405+14622802 or 6343154-(-292282)else d=E(813557+-844478)f=w[T]R=438633+6826790558465 p=w[B]H=p(d,R)p=E(646842-677732)V=f[H]f=v[p]p=f(s)F=V..p n=8771329-(-446069)V=k(16972711-856136,{x,T,B})K=N(F,V)end end else if n<897693+12520888 then if n<72095+13223802 then X=E(-1034058-(-1003156))T=Q[-799985-(-799987)]n=v[X]G=Q[-598625+598626]B={n(T)}X=B[233106-233105]N=B[-311349+311351]B=X n=B and 2001400-(-948219)or-253262+2618411 else f=w[T]d=E(-440234+409272)R=-35781+23370877040199 p=w[B]H=p(d,R)V=f[H]p=E(165088+-195978)f=v[p]H=w[r]n=271109+15500251 p=f(H)F=V..p V=Z(6674590-126506,{T,B,x;s,J;r})K=N(F,V)end else if n<14402432-900576 then a=E(-101234-(-70344))p=E(947164+-978214)n=v[a]f=v[p]a=n(f)n=E(567968-599011)v[n]=a n=11399702-(-234839)else s=w[g[-480422+480423]]o=E(637896+-668931)D=29763453003014-634595 L=w[g[-468503-(-468505)]]O=L(o,D)D=19700612165867-(-635626)J=s[O]L=480571+-480570 s=444085+-444084 o=E(653846-684846)r=G[J]J=E(-125755+94829)J=r[J]J=J(r,s,L)s=w[g[813848-813847]]L=w[g[807539+-807537]]O=L(o,D)r=s[O]n=334337+13926274 B=J~=r T=B end end end else if n<504945+13056265 then if n<-168196+13704094 then if n<13029881-(-501796)then X=E(-1068816-(-1037873))B=E(-592393+561503)O=k(-426164+6037640,{})n=v[X]G=w[g[-151550-(-151554)]]L=E(-794231+763329)N=v[B]s=v[L]L={s(O)}s=26646+-26644 J={W(L)}r=J[s]B=N(r)N=E(-1012970+981929)T=G(B,N)G={T()}X=n(W(G))G=X T=w[g[-318334+318339]]n=T and 88639+12303976 or 6123796-(-983563)X=T else n=-846497+15576246 q=D==x P=q end else if n<13979781-439042 then V=18179207637819-(-194006)r=N o=E(256359-287411)O=v[o]o=O(J)D=w[g[351278-351277]]F=E(-1036535-(-1005605))x=w[g[540993-540991]]K=x(F,V)O=D[K]L=o==O n=L and-559760+3934478 or 772617+8305671 s=L else n=D L=o n=8447861-348577 end end else if n<13017458-(-611357)then if n<13568649-(-12292)then n=o L=O n=2900403-776962 else o=250198-250168 O=#J L=O>o n=-480765+1582212 X=L end else G=E(936660-967710)X=E(-982188+951145)n=v[X]X=v[G]G=E(207111+-238161)v[G]=n G=E(696840-727883)v[G]=X G=w[g[444535+-444534]]T=G()n=-257251+15258394 end end end else if n<13821677-(-438949)then if n<239777+13908087 then if n<14153045-49778 then if n<-320022+14201416 then L=E(-876972+845981)n=v[L]D={n(s)}L=D[-276204+276205]o=D[-465564-(-465567)]O=D[-788738+788740]n=12793430-46781 else d=E(-263270+232295)d=s[d]n=-892658+13487086 R=E(28943-59809)h=-885508+2658449573849 b=E(-1035285+1004345)d=d(s)y=w[T]e=w[B]R=d[R]C=e(b,h)z=y[C]R=R(d,z)p=R end else if n<14453060-330711 then G=w[g[-343027-(-343028)]]X=#G G=-811924-(-811924)n=X==G n=n and-687380+9254532 or 8295262-(-171839)else O=nil V=nil n=796916-653594 end end else if n<-232778+14464486 then if n<14271600-116232 then D=o a=E(688224-719184)F=E(-918156+887104)K=v[F]f=-979377+15081787755808 F=K(x)V=w[g[-934666+934667]]P=w[g[-595924-(-595926)]]q=P(a,f)K=V[q]n=F==K n=n and 1003531+9588663 or 59918+7605398 else r=E(-515013-(-484125))D=-143276+20278555317390 o=E(-617128-(-586123))N=v[r]s=w[T]L=w[B]O=L(o,D)J=s[O]r=N(J)J=-824486-(-824686)r=E(-687837+656949)s=J N=v[r]J=-158889+158890 r=-428118+428119 L=J J=-12350+12350 n=-601929+15315838 O=L<J J=r-L end else n=N n=733466+11684809 X=T end end else if n<14085829-(-632934)then if n<-1019553+15536047 then if n<14132416-(-153060)then n=v[E(-642461+611601)]N=nil X={}G=nil T=nil B=nil else n=11947870-480849 K=E(-1034980+1004064)x=v[K]K=E(-104790+73920)D=x[K]O=D end else if n<-682611+15396373 then n=w[g[-563133-(-563134)]]N=n G=Q[-690488-(-690489)]T=Q[-632919-(-632921)]n=N[T]n=n and 4907019-(-888604)or 2343005-(-94572)else o=not O J=J+L r=J<=s r=o and r o=J>=s o=O and o r=o or r o=10369729-580929 n=r and o r=-548249+7995174 n=n or r end end else if n<51800+14837564 then if n<15669293-913614 then w[T]=P n=w[T]n=n and 15585117-614616 or 553556+12152755 else n=I(95905+3666322,{B})q={n()}n=v[E(-96622-(-65654))]X={W(q)}end else K=U()r=D w[K]=r R=-890172+2450037283248 r=K K=U()V=E(-998177+967125)d=E(-442699-(-411652))w[K]=x F=v[V]x=K f=w[x]V=F(f)f=w[T]p=w[B]H=p(d,R)F=f[H]K=V==F n=K and-541235+13912862 or 15636987-(-134373)end end end end else if n<-140999+15919336 then if n<15057787-(-85344)then if n<832587+14229985 then if n<422856+14601570 then if n<14749952-(-221106)then n=4010609-(-139400)else n=true n=n and 322383+13324001 or-325723+914985 end else if n<-694834+15745432 then O=E(628509+-659537)T=X r=E(-304603+273551)B=v[r]r=B(T)J=w[g[-342940+342941]]o=14729224218751-(-782923)s=w[g[876000-875998]]L=s(O,o)B=J[L]N=r==B n=N and 735761-(-896812)or 15637128-69900 X=N else o=-323921+24222120992096 J=w[g[-2950-(-2951)]]O=E(-551466-(-520609))N=n s=w[g[73621-73619]]L=s(O,o)r=J[L]B=G[r]n=B and-251499+13769303 or 250247+14010364 T=B end end else if n<15480399-395293 then if n<15243294-177122 then N,J=B(T,N)n=N and 157575+13380936 or 10760886-(-454003)else D,x=L(O,D)n=D and 15317+10330388 or 286315+8673364 end else if n<-725070+15819629 then n=w[g[154291+-154288]]f=E(-1032076+1001063)p=7316263952768-562226 P=w[g[176343-176342]]q=w[g[-581265+581267]]a=q(f,p)p=E(-832827+801808)V=P[a]F=V..D q=w[g[217549+-217548]]a=w[g[-314673+314675]]Y=312+23161695578345 f=a(p,Y)P=q[f]V=K[P]n[F]=V F=-198529-(-198530)n=T+F T=n n=829629+15297974 else X=w[g[-203621+203626]]D=305230+4310445891465 o=E(239739+-270689)s=w[g[183703+-183702]]L=w[g[-726738-(-726740)]]O=L(o,D)J=s[O]s=w[g[-822378+822384]]r=J..s L=E(-530504-(-499642))s=v[L]K=-18076+20780562869352 O=w[g[292886-292885]]o=w[g[-18893+18895]]x=E(207223+-238200)D=o(x,K)L=O[D]J=s[L]O=w[g[1015829+-1015828]]x=E(-302775+271900)o=w[g[715404+-715402]]K=-827687+33954580602602 D=o(x,K)L=O[D]n=-85460+12629237 q=E(-532282-(-501386))O=#T s=J(L,O,N,B)X[r]=s r=E(702350+-733238)X=v[r]K=22032584509936-270813 L=E(275039-305901)s=v[L]O=w[g[300964-300963]]o=w[g[-962698+962700]]x=E(-249988-(-219043))D=o(x,K)L=O[D]K=37546+16557671091060 x=E(-20327+-10619)J=s[L]O=w[g[-102572+102573]]o=w[g[-56699-(-56701)]]a=21308429253387-201801 D=o(x,K)L=O[D]O=w[g[-73320+73326]]D=w[g[-235615+235620]]F=w[g[302238+-302237]]V=w[g[216279+-216277]]P=V(q,a)K=F[P]F=w[g[448908+-448902]]x=K..F o=D[x]s={J(L,O,o)}r=X(W(s))end end end else if n<15947666-485354 then if n<15770885-545870 then if n<15867325-684538 then n=K n=532685+13008162 o=x else q=w[T]P=q n=q and-184908+13717320 or 15345965-616216 end else if n<15843146-574882 then N,J=B(T,N)n=N and-95982+6524789 or 10072345-(-262117)else n=f K=V n=7360234-(-3743)end end else if n<-707756+16301464 then if n<-1044776+16613734 then n=X and 8693728-(-560005)or 9203612-(-528246)else H=E(911868+-942732)d=-60603+13786331399630 f=w[g[46831+-46830]]P=n p=w[g[-774059-(-774061)]]Y=p(H,d)a=f[Y]q=K[a]V=q n=q and 831237+7144665 or 15807661-(-119610)end else n=969844+4749891 r=c(r)x=c(x)end end end else if n<16109815-62699 then if n<-842194+16811774 then if n<16040766-171207 then if n<259153+15558877 then X=E(-1737-29314)G=564267+-564267 n=v[X]X=n(G)G=X n=G and 839099+576518 or 8420609-(-365124)else H=E(248567-279619)e=5271572177254-546768 p=v[H]O=K H=p(V)y=E(-110431+79559)d=w[T]R=w[B]z=R(y,e)p=d[z]f=H==p n=f and 12140991-474626 or 15126948-984212 end else if n<411356+15523722 then F=V n=P n=-774334+4296480 else G=E(-417732+386738)N=534367+-534367 n=v[G]T=w[g[961523-961515]]G=n(T,N)n=10792326-540754 end end else if n<-240791+16234156 then if n<203472+15781191 then s=E(-194879+163927)K=E(-920962-(-890047))r=v[s]n=180137+2759225 O=w[T]F=519072+23576952946498 D=w[B]x=D(K,F)L=O[x]s=r(L)else K=nil L=nil n=-659203+12312259 end else x=c(x)n=1636699-(-255367)s=c(s)end end else if n<16285504-(-87730)then if n<149309+16140237 then if n<16400427-273891 then J=21969114354065-190875 n=w[g[670733-670732]]r=E(-256355-(-225475))T=w[g[-867996+867998]]N=w[g[-272762-(-272765)]]B=N(r,J)G=T[B]X=n(G)G=X X=E(157837+-188727)n=v[X]X={n(G)}X={W(X)}n=v[E(294924+-325801)]else n=6953580-(-711736)K=nil end else if n<596802+15747030 then r=nil K=nil n=-494361+786030 F=nil else s=E(-682412+651358)J=X X=v[s]L=E(7751-38667)s=E(1034471+-1065515)n=X[s]s=U()w[s]=n X=v[L]L=E(965874-996781)x=E(4505-35421)n=X[L]L=n D=v[x]O=D o=n n=D and 816965+13693369 or 271655+11195366 end end else if n<16622431-(-120109)then if n<204178+16497375 then b=-665363-(-665365)C=y[b]b=w[z]e=C==b j=e n=204196+935600 else K=E(1035527+-1066417)D=n a=E(-40224-(-9214))f=1035490+28714303121241 x=v[K]K=x(r)x=E(-409431-(-378456))x=K[x]x=x(K)K=E(-161215+130349)V=w[g[-958954-(-958955)]]P=w[g[-637817+637819]]K=x[K]q=P(a,f)F=V[q]K=K(x,F)o=K n=K and-386021+13926868 or 10947107-483385 end else O=w[T]K=E(7017-38034)n=8961853-760311 F=-919260+25103222502533 D=w[B]x=D(K,F)L=O[x]O=Z(8706533-(-1021111),{T;B;J})s=N(L,O)end end end end end end end end n=#i return W(X)end,function(v,E)local W=N(E)local Q=function(Q)return n(v,{Q},E,W)end return Q end,{},function(v,E)local W=N(E)local Q=function()return n(v,{},E,W)end return Q end,function(v)for E=-773399-(-773400),#v,815703+-815702 do G[v[E]]=(-761658-(-761659))+G[v[E]]end if Q then local n=Q(true)local W=i(n)W[E(-1033302-(-1002407))],W[E(505643-536639)],W[E(-109502+78447)]=v,B,function()return-1064086-155038 end return n else return g({},{[E(127608-158604)]=B,[E(-503228-(-472333))]=v;[E(215314+-246369)]=function()return 100067+-1319191 end})end end return(r(2332862-(-608057),{}))(W(X))end)(getfenv and getfenv()or _ENV,unpack or table[E(-341504+310634)],newproxy,setmetatable,getmetatable,select,{...})end)(...) (linedefined 1)")
print("  Stack 5: local unpack = unpack or table.unpack
local warn = warn or function() end

local _origPcall = pcall
local _origXpcall = xpcall
local _origError = error

local debugLibrary = debug
_G._VERSION = \\"Luau\\"
local setHook = debug.sethook
local getInfo = debug.getinfo
local getTraceback = debug.traceback
local loadFunction = load
local loadStringFunction = loadstring or load
local pcallFunction = pcall
local xpcallFunction = xpcall
local errorFunction = error
local typeFunction = type
local getMetatableFunction = getmetatable
local rawEqualFunction = rawequal
local toStringFunction = tostring
local toNumberFunction = tonumber
local ioLibrary = io
local osLibrary = os
local pairsFunction = pairs
local ipairsFunction = ipairs
local tableUnpackFunction = table.unpack or unpack
local proxyTable = {}
proxyTable.__index = proxyTable
local configuration = {
    MAX_DEPTH = 15,
    MAX_TABLE_ITEMS = 150,
    OUTPUT_FILE = \\"dumped_output.lua\\",
    VERBOSE = false,
    TRACE_CALLBACKS = true,
    TIMEOUT_SECONDS = 6.67,
    MAX_REPEATED_LINES = 8,
    MIN_DEOBF_LENGTH = 150,
    MAX_OUTPUT_SIZE = 2 * 1024 * 1024,
    CONSTANT_COLLECTION = true,
    INSTRUMENT_LOGIC = true
}
local inputKey = (arg and arg[3]) or \\"NoKey\\"
if arg and arg[3] then
    print(\\"[Dumper] Auto-Input Key Detected: \\" .. toStringFunction(inputKey))
end
local dumperState = {
    output = {},
    indent = 0,
    registry = {},
    reverse_registry = {},
    names_used = {},
    parent_map = {},
    property_store = {},
    call_graph = {},
    variable_types = {},
    string_refs = {},
    proxy_id = 0,
    callback_depth = 0,
    pending_iterator = false,
    last_http_url = nil,
    last_emitted_line = nil,
    repetition_count = 0,
    current_size = 0,
    ls_counter = 0
}
local _at = {
    mem          = {},
    tags         = {},
    sigs         = {},
    acts         = {},
    json         = {},
    enum         = {},
    svcCache     = {},
    typeOverride = {},
    connState    = {},
    debugIds     = {},
    debugIdCtr   = 0,
    instTags     = {},
    attrs        = {},
    children     = {},
    threadLike   = {},
    vectors      = {},
    buffers      = {},
    userdata     = {},
    localPlayer  = nil,
    weldRegistry = {},
    services     = {},
    folders      = {},
    files        = {},
    refBase      = {},
    metaHooks    = {},
    currentNamecallMethod = nil,
    inMetaHook   = false,
    pendingHeartbeat = {},
    locEntries = {},
    signalCallbacks = {},  -- AT5: live signal firing
    animateScript = nil,   -- AT3: getrunningscripts
}
setmetatable(_at.debugIds, {__mode = \\"k\\"})
setmetatable(_at.instTags, {__mode = \\"k\\"})
setmetatable(_at.attrs, {__mode = \\"k\\"})
setmetatable(_at.children, {__mode = \\"k\\"})
setmetatable(_at.threadLike, {__mode = \\"k\\"})
setmetatable(_at.vectors, {__mode = \\"k\\"})
setmetatable(_at.buffers, {__mode = \\"k\\"})
setmetatable(_at.userdata, {__mode = \\"k\\"})
setmetatable(_at.refBase, {__mode = \\"k\\"})
local function _getDebugId(p)
    if not _at.debugIds[p] then
        _at.debugIdCtr = _at.debugIdCtr + 1
        local n = _at.debugIdCtr
        _at.debugIds[p] = toStringFunction(n * 17 + 3) .. \\"-\\" .. toStringFunction(n * 97 + 11)
    end
    return _at.debugIds[p]
end
local function _removeChild(parent, child)
    local list = parent and _at.children[parent]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == child then table.remove(list, i) end
    end
end
local function _setParent(child, parent)
    local oldParent = dumperState.parent_map[child]
    if oldParent == parent then return end
    _removeChild(oldParent, child)
    dumperState.parent_map[child] = parent
    if parent then
        _at.children[parent] = _at.children[parent] or {}
        table.insert(_at.children[parent], child)
        -- skip signal firing for internal proxy types
        local childType = _at.typeOverride[child]
        local parentType = _at.typeOverride[parent]
        if childType == \\"RBXScriptSignal\\" or childType == \\"RBXScriptConnection\\"
        or parentType == \\"RBXScriptSignal\\" or parentType == \\"RBXScriptConnection\\" then
            return
        end
        -- fire ChildAdded on direct parent only
        if _at.signalCallbacks[parent] then
            for _, cb in ipairsFunction(_at.signalCallbacks[parent].ChildAdded or {}) do
                pcallFunction(cb, child)
            end
        end
        -- fire DescendantAdded on direct parent and its ancestors
        local ancestor = parent
        while ancestor do
            if _at.signalCallbacks[ancestor] then
                for _, cb in ipairsFunction(_at.signalCallbacks[ancestor].DescendantAdded or {}) do
                    pcallFunction(cb, child)
                end
            end
            ancestor = dumperState.parent_map[ancestor]
        end
    end
end
local function _isDescendantOf(child, parent)
    local cur = dumperState.parent_map[child]
    while cur do
        if cur == parent then return true end
        cur = dumperState.parent_map[cur]
    end
    return false
end
local function _getAllDescendants(root, out)
    out = out or {}
    for _, child in ipairsFunction(_at.children[root] or {}) do
        table.insert(out, child)
        _getAllDescendants(child, out)
    end
    return out
end
local numericArg = (arg and toNumberFunction(arg[4])) or (arg and toNumberFunction(arg[3])) or 123456789
local proxyMarker = {}
local function isProxyTable(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyMarker) == true end )
    return success and result
end
local function getProxyValue(target)
    if isProxyTable(target) then
        return rawget(target, \\"__value\\") or 0
    end
    return 0
end
local loadStringFunction = loadstring or load
local printFunction = print
local warnFunction = warn or function() end
local pairsFunction = pairs
local ipairsFunction = ipairs
local typeFunction = type
local toStringFunction = tostring
local proxyList = {}
local function isProxy(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyList) == true end )
    return success and result
end
local function getProxyId(target)
    if not isProxy(target) then
        return nil
    end
    return rawget(target, \\"__proxy_id\\")
end
local function processString(inputString)
    if typeFunction(inputString) ~= \\"string\\" then
        return '\\"'
    end
    local outputParts = {}
    local currentIndex, totalLength = 1, #inputString
    local function cleanEscapes(content)
        return content:gsub( \\"\\\\\\\\(.)\\", function(escapedChar)
            if escapedChar:match('[abfnrtv\\\\\\\\%\'%\\\\\\"%[%]0-9xu]') then
                return \\"\\" .. escapedChar
            end
            return escapedChar
        end )
    end
    local function stripLuauSyntax(rawCode)
        if not rawCode or rawCode == \\"\\" then
            return rawCode
        end
        rawCode = rawCode:gsub(\\"\239\187\191\\", \\"\\")
        rawCode = rawCode:gsub(\\"\\r\n\\", \\"\n\\"):gsub(\\"\\r\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"\226\128\168\\", \\"\n\\"):gsub(\\"\226\128\169\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"%-%-!%a+[^\n]*\\", \\"\\")
        rawCode = rawCode:gsub(\\"([^\n]*)\\", function(line)
            if line:match(\\"^%s*export%s+type%s+\\") or line:match(\\"^%s*type%s+[%a_][%w_]*%s*=\\") then
                return \\"-- \\" .. line
            end
            return line
        end)
        rawCode = rawCode:gsub(\\"local%s+([%a_][%w_]*)%s*<[%a_][%w_]*>%s*=\\", \\"local %1 =\\")
        rawCode = rawCode:gsub(\\"(function%s+[%a_][%w_%.:]*)%s*<[^>\n%(]+>%s*%(\\", \\"%1(\\")
        rawCode = rawCode:gsub(\\"([%(%s,])%.%.%.%s*:%s*[%a_][%w_%.]*%??\\", \\"%1...\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"%1%2\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\"%1%2%3\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\")\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\")%1\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%??\\", \\"\\")
        return rawCode
    end
    local function parseExpression(rawCode)
        if not rawCode or rawCode == '\\"' then
            return \\"\\"
        end
        rawCode = stripLuauSyntax(rawCode)
        rawCode = rawCode:gsub( \\"0[bB]([01_]+)\\", function(binaryString)
            local cleanBinary = binaryString:gsub(\\"_\\", \\"\\")
            local decimalValue = toNumberFunction(cleanBinary, 2)
            return decimalValue and toStringFunction(decimalValue) or \\"0\\"
        end )
        rawCode = rawCode:gsub( \\"0[xX]([%x_]+)\\", function(hexString)
            local cleanHex = hexString:gsub(\\"_\\", \\"\\")
            return \\"0x\\" .. cleanHex
        end )
        while rawCode:match(\\"%d_+%d\\") do
            rawCode = rawCode:gsub(\\"(%d)_+(%d)\\", \\"%1%2\\")
        end
        local operators = {{\\"+=\\", \\"+\\"}, {\\"-=\\", \\"-\\"}, {\\"*=\\", \\"*\\"}, {\\"/=\\", \\"/\\"}, {\\"%%=\\", \\"%%\\"}, {\\"%^=\\", \\"^\\"}, {\\"%.%.=\\", \\"..\\"}}
        for _, opPair in ipairsFunction(operators) do
            local operatorAssignment, operator = opPair[1], opPair[2]
            -- simple var: x+=1 -> x = x + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- dot chain: x.y.z+=1 -> x.y.z = x.y.z + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*%.[%a_][%w_%.]+)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- bracket chain: R[m]+=q, T[1][2]+=q, obj[\\"k\\"][i]+=q
            -- manually find identifier + full bracket chain before the operator
            local escOp = operatorAssignment:gsub(\\"([%.%+%-%*%/%^%%])\\", \\"%%%1\\")
            rawCode = rawCode:gsub(\\"([%a_][%w_]*)(%b[])\\", function(name, firstBracket)
                -- check if after firstBracket there are more brackets then the operator
                return name .. firstBracket
            end)
            -- proper scan: replace lval+= where lval is ident + bracket chain
            do
                local result = {}
                local i = 1
                local len = #rawCode
                while i <= len do
                    -- look for identifier start
                    local idStart, idEnd = rawCode:find(\\"[%a_][%w_]*\\", i)
                    if not idStart then
                        result[#result+1] = rawCode:sub(i)
                        break
                    end
                    result[#result+1] = rawCode:sub(i, idStart-1)
                    local varName = rawCode:match(\\"[%a_][%w_]*\\", idStart)
                    local pos = idStart + #varName
                    -- consume bracket chains
                    while pos <= len and rawCode:sub(pos,pos) == \\"[\\" do
                        local _, bEnd = rawCode:find(\\"%b[]\\", pos)
                        if not bEnd then break end
                        varName = varName .. rawCode:sub(pos, bEnd)
                        pos = bEnd + 1
                    end
                    -- check for operator after optional whitespace
                    local wsEnd = pos
                    while wsEnd <= len and rawCode:sub(wsEnd,wsEnd):match(\\"%s\\") do wsEnd=wsEnd+1 end
                    local opMatch = rawCode:sub(wsEnd, wsEnd + #operatorAssignment - 1)
                    if opMatch == operatorAssignment and varName:find(\\"%[\\") then
                        -- rewrite: varName op= ... -> varName = varName op ...
                        result[#result+1] = varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
                        i = wsEnd + #operatorAssignment
                    else
                        result[#result+1] = varName
                        i = pos
                    end
                end
                rawCode = table.concat(result)
            end
        end
        rawCode = rawCode:gsub(\\"([^%w_])continue([^%w_])\\", \\"%1__LC__()%2\\")
        rawCode = rawCode:gsub(\\"^continue([^%w_])\\", \\"__LC__()%1\\")
        rawCode = rawCode:gsub(\\"([^%w_])continue$\\", \\"%1__LC__()\\")
        return rawCode
    end
    local function getBracketCount(index)
        local count = 0
        while index <= totalLength and inputString:byte(index) == 61 do
            count = count + 1
            index = index + 1
        end
        return count, index
    end
    local function findClosingBracket(startIndex, bracketCount)
        local closingPattern = \\"]\\" .. string.rep(\\"=\\", bracketCount) .. \\"]\\"
        local start, finish = inputString:find(closingPattern, startIndex, true)
        return finish or totalLength
    end
    local segmentStart = 1
    while currentIndex <= totalLength do
        local byteValue = inputString:byte(currentIndex)
        if byteValue == 91 then
            local bracketCount, nextIndex = getBracketCount(currentIndex + 1)
            if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
                local startSegment = currentIndex
                local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                table.insert(outputParts, inputString:sub(startSegment, endSegment))
                currentIndex = endSegment
                segmentStart = currentIndex + 1
            end
        elseif byteValue == 45 and currentIndex + 1 <= totalLength and inputString:byte(currentIndex + 1) == 45 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local startSegment = currentIndex
            if currentIndex + 2 <= totalLength and inputString:byte(currentIndex + 2) == 91 then
                local bracketCount, nextIndex = getBracketCount(currentIndex + 3)
                if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                    local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                    table.insert(outputParts, inputString:sub(startSegment, endSegment))
                    currentIndex = endSegment
                    segmentStart = currentIndex + 1
                    currentIndex = currentIndex + 1
                end
            end
            local lineBreak = inputString:find(\\"\n\\", currentIndex + 2, true)
            if lineBreak then
                currentIndex = lineBreak
            else
                currentIndex = totalLength
            end
            table.insert(outputParts, inputString:sub(startSegment, currentIndex))
            segmentStart = currentIndex + 1
        elseif byteValue == 34 or byteValue == 39 or byteValue == 96 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local quoteType = byteValue
            local startSegment = currentIndex
            currentIndex = currentIndex + 1
            while currentIndex <= totalLength do
                local charByte = inputString:byte(currentIndex)
                if charByte == 92 then
                    currentIndex = currentIndex + 1
                elseif charByte == quoteType then
                    break
                end
                currentIndex = currentIndex + 1
            end
            local extractedContent = inputString:sub(startSegment + 1, currentIndex - 1)
            extractedContent = cleanEscapes(extractedContent)
            if quoteType == 96 then
                table.insert(outputParts, '\\"' .. extractedContent:gsub('\\"', '\\\\\\\\\\"') .. '\\"')
            else
                local quoteChar = string.char(quoteType)
                table.insert(outputParts, quoteChar .. extractedContent .. quoteChar)
            end
            segmentStart = currentIndex + 1
        end
        currentIndex = currentIndex + 1
    end
    table.insert(outputParts, parseExpression(inputString:sub(segmentStart)))
    return table.concat(outputParts)
end
local function safeLoad(code, chunkName)
    local loadedFunc, errorMessage = loadStringFunction(code, chunkName)
    if loadedFunc then
        return loadedFunc
    end
    printFunction(\\"\n[CRITICAL ERROR] Failed to load script!\\")
    printFunction(\\"[LUA_LOAD_FAIL] \\" .. toStringFunction(errorMessage))
    local errorLine = toNumberFunction(errorMessage:match(\\":(%d+):\\"))
    local errorNear = errorMessage:match(\\"near '([^']+)'\\")
    if errorNear then
        local foundIndex = code:find(errorNear, 1, true)
        if foundIndex then
            local startCtx = math.max(1, foundIndex - 50)
            local endCtx = math.min(#code, foundIndex + 50)
            printFunction(\\"Context around error:\\")
            printFunction(\\"...\\" .. code:sub(startCtx, endCtx) .. \\"...\\")
        end
    end
    local debugFile = ioLibrary.open(\\"DEBUG_FAILED_TRANSPILE.lua\\", \\"w\\")
    if debugFile then
        debugFile:write(code)
        debugFile:close()
        printFunction(\\"[*] Saved to 'DEBUG_FAILED_TRANSPILE.lua' for inspection\\")
    end
    return nil, errorMessage
end
local function emitOutput(data, isInline)
    if dumperState.limit_reached then
        return
    end
    if data == nil then
        return
    end
    local indentPrefix = isInline and \\"\\" or string.rep(\\"    \\", dumperState.indent)
    local lineString = indentPrefix .. toStringFunction(data)
    local lineSize = #lineString + 1
    if dumperState.current_size + lineSize > configuration.MAX_OUTPUT_SIZE then
        dumperState.limit_reached = true
        local warningMessage = \\"-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.\\"
        table.insert(dumperState.output, warningMessage)
        dumperState.current_size = dumperState.current_size + #warningMessage
        errorFunction(\\"DUMP_LIMIT_EXCEEDED\\")
    end
    if lineString == dumperState.last_emitted_line then
        dumperState.repetition_count = dumperState.repetition_count + 1
        if dumperState.repetition_count <= configuration.MAX_REPEATED_LINES then
            table.insert(dumperState.output, lineString)
            dumperState.current_size = dumperState.current_size + lineSize
        elseif dumperState.repetition_count == configuration.MAX_REPEATED_LINES + 1 then
            local suppressMessage = indentPrefix .. \\"-- [Repeated lines suppressed...]\\"
            table.insert(dumperState.output, suppressMessage)
            dumperState.current_size = dumperState.current_size + #suppressMessage
        end
    else
        dumperState.last_emitted_line = lineString
        dumperState.repetition_count = 0
        table.insert(dumperState.output, lineString)
        dumperState.current_size = dumperState.current_size + lineSize
    end
    if configuration.VERBOSE and dumperState.repetition_count <= 1 then
        printFunction(lineString)
    end
end
local function emitComment(data)
    emitOutput(\\"-- \\" .. toStringFunction(data or \\"\\"))
end
local function addEmptyLine()
    dumperState.last_emitted_line = nil
    table.insert(dumperState.output, \\"\\")
end
local function getFullOutput()
    return table.concat(dumperState.output, \\"\n\\")
end
local function saveToFile(filePath)
    local fileHandle = ioLibrary.open(filePath or configuration.OUTPUT_FILE, \\"w\\")
    if fileHandle then
        fileHandle:write(getFullOutput())
        fileHandle:close()
        return true
    end
    return false
end
local function formatValue(value)
    if value == nil then
        return \\"nil\\"
    end
    if typeFunction(value) == \\"string\\" then
        return value
    end
    if typeFunction(value) == \\"number\\" or typeFunction(value) == \\"boolean\\" then
        return toStringFunction(value)
    end
    if typeFunction(value) == \\"table\\" then
        if dumperState.registry[value] then
            return dumperState.registry[value]
        end
        if isProxy(value) then
            local proxyId = getProxyId(value)
            return proxyId and \\"proxy_\\" .. proxyId or \\"proxy\\"
        end
    end
    local success, result = pcallFunction(toStringFunction, value)
    return success and result or \\"unknown\\"
end
local function formatStringLiteral(value)
    local rawValue = formatValue(value)
    local escapedValue = rawValue:gsub(\\"\\\\\\\\\\", \\"\\\\\\\\\\\\\\\\\\"):gsub('\\"', '\\\\\\\\\\"'):gsub(\\"\n\\", \\"\n\\"):gsub(\\"\\\\\r\\", \\"\\\\\\\\\r\\"):gsub(\\"\\\\\t\\", \\"\\\\\\\\\t\\")
    return '\\"' .. escapedValue .. '\\"'
end
local serviceNames = {
    Players = \\"Players\\",
    Workspace = \\"Workspace\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    ServerStorage = \\"ServerStorage\\",
    ServerScriptService = \\"ServerScriptService\\",
    StarterGui = \\"StarterGui\\",
    StarterPack = \\"StarterPack\\",
    StarterPlayer = \\"StarterPlayer\\",
    Lighting = \\"Lighting\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    RunService = \\"RunService\\",
    UserInputService = \\"UserInputService\\",
    TweenService = \\"TweenService\\",
    GroupService = \\"GroupService\\",
    AnimationClipProvider = \\"AnimationClipProvider\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    TeleportService = \\"TeleportService\\",
    PathfindingService = \\"PathfindingService\\",
    CollectionService = \\"CollectionService\\",
    PhysicsService = \\"PhysicsService\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    GuiService = \\"GuiService\\",
    HapticService = \\"HapticService\\",
    VRService = \\"VRService\\",
    CoreGui = \\"CoreGui\\",
    Teams = \\"Teams\\",
    InsertService = \\"InsertService\\",
    DataStoreService = \\"DataStoreService\\",
    MessagingService = \\"MessagingService\\",
    TextService = \\"TextService\\",
    TextChatService = \\"TextChatService\\",
    NetworkClient = \\"NetworkClient\\",
    ContentProvider = \\"ContentProvider\\",
    Debris = \\"Debris\\",
    MemStorageService = \\"MemStorageService\\",
    ChangeHistoryService = \\"ChangeHistoryService\\",
    PlayerEmulatorService = \\"PlayerEmulatorService\\",
    StylingService = \\"StylingService\\",
    ScriptContext = \\"ScriptContext\\",
    LocalizationService = \\"LocalizationService\\",
    PolicyService = \\"PolicyService\\",
    CaptureService = \\"CaptureService\\",
    AnalyticsService = \\"AnalyticsService\\",
    EncodingService = \\"EncodingService\\",
    CorePackages = \\"CorePackages\\",
    RobloxReplicatedStorage = \\"RobloxReplicatedStorage\\",
    RobloxGui = \\"RobloxGui\\",
    AvatarEditorService = \\"AvatarEditorService\\",
    SocialService = \\"SocialService\\",
    VoiceChatService = \\"VoiceChatService\\",
    AdService = \\"AdService\\",
    GeometryService = \\"GeometryService\\",
    AssetService = \\"AssetService\\",
    LocalizationService = \\"LocalizationService\\",
    NotificationService = \\"NotificationService\\",
    ProcessInstancePhysicsService = \\"ProcessInstancePhysicsService\\",
    FriendService = \\"FriendService\\",
    SessionService = \\"SessionService\\",
    TimerService = \\"TimerService\\",
    TouchInputService = \\"TouchInputService\\",
    GamepadService = \\"GamepadService\\",
    KeyboardService = \\"KeyboardService\\",
    MouseService = \\"MouseService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceService = \\"PerformanceService\\",
    PlatformFriendService = \\"PlatformFriendService\\",
    ReplicatedFirst = \\"ReplicatedFirst\\",
    SpawnLocation = \\"SpawnLocation\\",
    LogService = \\"LogService\\",
    Stats = \\"Stats\\",
    TweenService = \\"TweenService\\",
    Debris = \\"Debris\\",
    CoreGui = \\"CoreGui\\",
    MarketplaceService = \\"MarketplaceService\\",
    NotificationService = \\"NotificationService\\",
    GuidRegistryService = \\"GuidRegistryService\\",
    NetworkServer = \\"NetworkServer\\",
    Geometry = \\"Geometry\\",
    VirtualInputManager = \\"VirtualInputManager\\",
    MLModelDeliveryService = \\"MLModelDeliveryService\\",
    PartyEmulatorService = \\"PartyEmulatorService\\",
    PlatformFriendsService = \\"PlatformFriendsService\\",
    FriendService = \\"FriendService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceControlService = \\"PerformanceControlService\\",
    RbxAnalyticsService = \\"RbxAnalyticsService\\",
    AbuseReportService = \\"AbuseReportService\\",
    AdService = \\"AdService\\",
    AdPortalService = \\"AdPortalService\\",
    AppUpdateService = \\"AppUpdateService\\",
    BrowserService = \\"BrowserService\\",
    CookiesService = \\"CookiesService\\",
    CoreGui = \\"CoreGui\\",
    GamesService = \\"GamesService\\",
    KeyboardService = \\"KeyboardService\\",
    MarketplaceService = \\"MarketplaceService\\",
    MouseService = \\"MouseService\\",
    NotificationService = \\"NotificationService\\",
    PurchaseDataService = \\"PurchaseDataService\\",
    TimerService = \\"TimerService\\",
    UGCValidationService = \\"UGCValidationService\\",
}
local serviceShortcuts = {
    Players = \\"Players\\",
    UserInputService = \\"UIS\\",
    RunService = \\"RunService\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    TweenService = \\"TweenService\\",
    Workspace = \\"Workspace\\",
    Lighting = \\"Lighting\\",
    StarterGui = \\"StarterGui\\",
    CoreGui = \\"CoreGui\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    DataStoreService = \\"DataStoreService\\",
    TeleportService = \\"TeleportService\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    Teams = \\"Teams\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    CollectionService = \\"CollectionService\\",
    PathfindingService = \\"PathfindingService\\",
    Debris = \\"Debris\\"
}
local classParents = {
    DataModel = {\\"DataModel\\", \\"ServiceProvider\\", \\"Instance\\"},
    Workspace = {\\"Workspace\\", \\"WorldRoot\\", \\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Camera = {\\"Camera\\", \\"Instance\\"},
    Players = {\\"Players\\", \\"Instance\\"},
    Player = {\\"Player\\", \\"Instance\\"},
    PlayerGui = {\\"PlayerGui\\", \\"BasePlayerGui\\", \\"Instance\\"},
    Backpack = {\\"Backpack\\", \\"Instance\\"},
    PlayerScripts = {\\"PlayerScripts\\", \\"Instance\\"},
    Folder = {\\"Folder\\", \\"Instance\\"},
    Model = {\\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Part = {\\"Part\\", \\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    BasePart = {\\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    ModuleScript = {\\"ModuleScript\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    LocalScript = {\\"LocalScript\\", \\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Script = {\\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Humanoid = {\\"Humanoid\\", \\"Instance\\"},
    SoundService = {\\"SoundService\\", \\"Instance\\"},
    Lighting = {\\"Lighting\\", \\"Instance\\"},
    HttpService = {\\"HttpService\\", \\"Instance\\"},
    TweenService = {\\"TweenService\\", \\"Instance\\"},
    RunService = {\\"RunService\\", \\"Instance\\"},
    TextService = {\\"TextService\\", \\"Instance\\"},
    GuiService = {\\"GuiService\\", \\"Instance\\"},
    ContentProvider = {\\"ContentProvider\\", \\"Instance\\"},
    CollectionService = {\\"CollectionService\\", \\"Instance\\"},
    MemStorageService = {\\"MemStorageService\\", \\"Instance\\"},
    NetworkClient = {\\"NetworkClient\\", \\"Instance\\"},
    ClientReplicator = {\\"ClientReplicator\\", \\"Instance\\"},
}
local function classIsA(className, targetClass)
    if className == targetClass then return true end
    local parents = classParents[className] or {className, \\"Instance\\"}
    for _, parentName in ipairsFunction(parents) do
        if parentName == targetClass then return true end
    end
    return false
end
local uiNamingConvention = {
    {pattern = \\"window\\", prefix = \\"Window\\", counter = \\"window\\"},
    {pattern = \\"tab\\", prefix = \\"Tab\\", counter = \\"tab\\"},
    {pattern = \\"section\\", prefix = \\"Section\\", counter = \\"section\\"},
    {pattern = \\"button\\", prefix = \\"Button\\", counter = \\"button\\"},
    {pattern = \\"toggle\\", prefix = \\"Toggle\\", counter = \\"toggle\\"},
    {pattern = \\"slider\\", prefix = \\"Slider\\", counter = \\"slider\\"},
    {pattern = \\"dropdown\\", prefix = \\"Dropdown\\", counter = \\"dropdown\\"},
    {pattern = \\"textbox\\", prefix = \\"Textbox\\", counter = \\"textbox\\"},
    {pattern = \\"input\\", prefix = \\"Input\\", counter = \\"input\\"},
    {pattern = \\"label\\", prefix = \\"Label\\", counter = \\"label\\"},
    {pattern = \\"keybind\\", prefix = \\"Keybind\\", counter = \\"keybind\\"},
    {pattern = \\"colorpicker\\", prefix = \\"ColorPicker\\", counter = \\"colorpicker\\"},
    {pattern = \\"paragraph\\", prefix = \\"Paragraph\\", counter = \\"paragraph\\"},
    {pattern = \\"notification\\", prefix = \\"Notification\\", counter = \\"notification\\"},
    {pattern = \\"divider\\", prefix = \\"Divider\\", counter = \\"divider\\"},
    {pattern = \\"bind\\", prefix = \\"Bind\\", counter = \\"bind\\"},
    {pattern = \\"picker\\", prefix = \\"Picker\\", counter = \\"picker\\"}
}
local uiCounters = {}
local function getUiCounter(name)
    uiCounters[name] = (uiCounters[name] or 0) + 1
    return uiCounters[name]
end
local function resolveVariableName(obj, originalName, hintString)
    if not obj then
        obj = \\"var\\"
    end
    local formattedName = formatValue(obj)
    if serviceShortcuts[formattedName] then
        return serviceShortcuts[formattedName]
    end
    if hintString then
        local lowerHint = hintString:lower()
        for _, patternEntry in ipairsFunction(uiNamingConvention) do
            if lowerHint:find(patternEntry.pattern) then
                local counter = getUiCounter(patternEntry.counter)
                return counter == 1 and patternEntry.prefix or patternEntry.prefix .. counter
            end
        end
    end
    if formattedName == \\"LocalPlayer\\" then
        return \\"LocalPlayer\\"
    end
    if formattedName == \\"Character\\" then
        return \\"Character\\"
    end
    if formattedName == \\"Humanoid\\" then
        return \\"Humanoid\\"
    end
    if formattedName == \\"HumanoidRootPart\\" then
        return \\"HumanoidRootPart\\"
    end
    if formattedName == \\"Camera\\" then
        return \\"Camera\\"
    end
    if formattedName:match(\\"^Enum%.\\") then
        return formattedName
    end
    local sanitizedName = formattedName:gsub(\\"[^%w_]\\", '\\"'):gsub(\\"^%d+\\", '\\"')
    if sanitizedName == '\\"' or sanitizedName == \\"Object\\" or sanitizedName == \\"Value\\" or sanitizedName == \\"result\\" then
        sanitizedName = \\"var\\"
    end
    return sanitizedName
end
local function registerVariable(obj, objName, varType, hintString)
    local existing = dumperState.registry[obj]
    if existing and existing:match(\\"^v%d+$\\") then
        return existing
    end
    dumperState.ls_counter = (dumperState.ls_counter or 0) + 1
    local newName = \\"v\\" .. dumperState.ls_counter
    dumperState.names_used[newName] = true
    dumperState.registry[obj] = newName
    dumperState.reverse_registry[newName] = obj
    dumperState.variable_types[newName] = varType or typeFunction(obj)
    return newName
end
local function serializeValue(obj, depth, visited, allowInline)
    depth = depth or 0
    visited = visited or {}
    if depth > configuration.MAX_DEPTH then
        return \\"{ --[[max depth]] }\\"
    end
    local valueType = typeFunction(obj)
    if isProxyTable(obj) then
        local proxyValue = rawget(obj, \\"__value\\")
        return toStringFunction(proxyValue or 0)
    end
    if valueType == \\"table\\" and dumperState.registry[obj] then
        return dumperState.registry[obj]
    end
    if valueType == \\"nil\\" then
        return \\"nil\\"
    elseif valueType == \\"string\\" then
        if #obj > 100 and obj:match(\\"^[A-Za-z0-9+/=]+$\\") then
            table.insert(dumperState.string_refs, {value = obj:sub(1, 50) .. \\"...\\", hint = \\"base64\\", full_length = #obj})
        elseif obj:match(\\"https?://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"URL\\"})
        elseif obj:match(\\"rbxasset://\\") or obj:match(\\"rbxassetid://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"Asset\\"})
        end
        return formatStringLiteral(obj)
    elseif valueType == \\"number\\" then
        if obj ~= obj then
            return \\"0/0\\"
        end
        if obj == math.huge then
            return \\"math.huge\\"
        end
        if obj == -math.huge then
            return \\"-math.huge\\"
        end
        if obj == math.floor(obj) then
            return toStringFunction(math.floor(obj))
        end
        return string.format(\\"%.6g\\", obj)
    elseif valueType == \\"boolean\\" then
        return toStringFunction(obj)
    elseif valueType == \\"function\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        return \\"function() end\\"
    elseif valueType == \\"table\\" then
        if isProxy(obj) then
            return dumperState.registry[obj] or \\"proxy\\"
        end
        if visited[obj] then
            return \\"{ --[[circular]] }\\"
        end
        visited[obj] = true
        local count = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                count = count + 1
            end
        end
        if count == 0 then
            return \\"{}\\"
        end
        local isSequence = true
        local maxIdx = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                if typeFunction(k) ~= \\"number\\" or k < 1 or k ~= math.floor(k) then
                    isSequence = false
                    break
                else
                    maxIdx = math.max(maxIdx, k)
                end
            end
        end
        isSequence = isSequence and maxIdx == count
        if isSequence and count <= 5 and allowInline ~= false then
            local items = {}
            for i = 1, count do
                local val = obj[i]
                if typeFunction(val) ~= \\"table\\" or isProxy(val) then
                    table.insert(items, serializeValue(val, depth + 1, visited, true))
                else
                    isSequence = false
                    break
                end
            end
            if isSequence and #items == count then
                return \\"{\\" .. table.concat(items, \\", \\") .. \\"}\\"
            end
        end
        local output = {}
        local itemCount = 0
        local indent = string.rep(\\"    \\", dumperState.indent + depth + 1)
        local baseIndent = string.rep(\\"    \\", dumperState.indent + depth)
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                itemCount = itemCount + 1
                if itemCount > configuration.MAX_TABLE_ITEMS then
                    table.insert(output, indent .. \\"-- ...\\" .. count - itemCount + 1 .. \\" more\\")
                    break
                end
                local keyStr
                if isSequence then
                    keyStr = nil
                elseif typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                    keyStr = k
                else
                    keyStr = \\"[\\" .. serializeValue(k, depth + 1, visited) .. \\"]\\"
                end
                local valStr = serializeValue(v, depth + 1, visited)
                if keyStr then
                    table.insert(output, indent .. keyStr .. \\" = \\" .. valStr)
                else
                    table.insert(output, indent .. valStr)
                end
            end
        end
        if #output == 0 then
            return \\"{}\\"
        end
        return \\"{\n\\" .. table.concat(output, \\",\n\\") .. \\"\n\\" .. baseIndent .. \\"}\\"
    elseif valueType == \\"userdata\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"userdata\\"
    elseif valueType == \\"thread\\" then
        return \\"coroutine.create(function() end)\\"
    else
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"nil\\"
    end
end
local proxyStore = {}
setmetatable(proxyStore, {__mode = \\"k\\"})
local function createProxy()
    local proxy = {}
    proxyStore[proxy] = true
    local meta = {}
    setmetatable(proxy, meta)
    return proxy, meta
end
local function isProxy(obj)
    return proxyStore[obj] == true
end
local createProxyObject
local createProxyMethod
-- ContentId type for AT6 (SurfaceAppearance.ColorMap etc)
local function _makeContentId(val)
    val = val or \\"\\"
    return setmetatable({_value = val}, {
        __typeof = \\"ContentId\\",
        __tostring = function() return val end,
        __eq = function(a, b)
            local av = typeFunction(a) == \\"table\\" and rawget(a, \\"_value\\") or a
            local bv = typeFunction(b) == \\"table\\" and rawget(b, \\"_value\\") or b
            return av == bv
        end,
        __index = function(t, k) if k == \\"_value\\" then return val end end,
    })
end
local _makeVector3
local _makeCFrame
local function createProxyInstance(bm)
    local proxy, meta = createProxy()
    rawset(proxy, proxyMarker, true)
    rawset(proxy, \\"__value\\", bm)
    dumperState.registry[proxy] = toStringFunction(bm)
    meta.__tostring = function() return toStringFunction(bm) end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" or key == proxyMarker or key == \\"__value\\" then
            return rawget(tbl, key)
        end
        return createProxyInstance(0)
    end
    meta.__newindex = function() end
    meta.__call = function() return bm end
    local function op(symbol)
        return function(a, b)
            local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a or 0
            local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b or 0
            local res
            if symbol == \\"+\\" then res = valA + valB
            elseif symbol == \\"-\\" then res = valA - valB
            elseif symbol == \\"*\\" then res = valA * valB
            elseif symbol == \\"/\\" then res = valB ~= 0 and valA / valB or 0
            elseif symbol == \\"%\\" then res = valB ~= 0 and valA % valB or 0
            elseif symbol == \\"^\\" then res = valA ^ valB
            else res = 0 end
            return createProxyInstance(res)
        end
    end
    meta.__add = op(\\"+\\")
    meta.__sub = op(\\"-\\")
    meta.__mul = op(\\"*\\")
    meta.__div = op(\\"/\\")
    meta.__mod = op(\\"%\\")
    meta.__pow = op(\\"^\\")
    meta.__unm = function(a) return createProxyInstance(-(rawget(a, \\"__value\\") or 0)) end
    meta.__eq = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA == valB
    end
    meta.__lt = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA < valB
    end
    meta.__le = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA <= valB
    end
    meta.__len = function() return 0 end
    return proxy
end
local function executeFunction(func, args)
    if typeFunction(func) ~= \\"function\\" then
        return {}
    end
    local outputCount = #dumperState.output
    local previousIteratorState = dumperState.pending_iterator
    dumperState.pending_iterator = false
    xpcallFunction( function() func(table.unpack(args or {})) end, function() end )
    while dumperState.pending_iterator do
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end\\")
        dumperState.pending_iterator = false
    end
    dumperState.pending_iterator = previousIteratorState
    local capturedLines = {}
    for i = outputCount + 1, #dumperState.output do
        table.insert(capturedLines, dumperState.output[i])
    end
    for i = #dumperState.output, outputCount + 1, -1 do
        table.remove(dumperState.output, i)
    end
    return capturedLines
end
createProxyMethod = function(methodName, parentProxy)
    local proxy, meta = createProxy()
    rawset(proxy, \\"__is_method\\", true)
    local parentName = dumperState.registry[parentProxy] or \\"object\\"
    local methodSignature = formatValue(methodName)
    dumperState.registry[proxy] = parentName .. \\".\\" .. methodSignature
    meta.__call = function(self, firstArg, ...)
        local args
        if firstArg == proxy or firstArg == parentProxy or isProxy(firstArg) then
            args = {...}
        else
            args = {firstArg, ...}
        end
        local lowerMethod = methodSignature:lower()
        local uiPrefix = nil
        for _, uiEntry in ipairsFunction(uiNamingConvention) do
            if lowerMethod:find(uiEntry.pattern) then
                uiPrefix = uiEntry.prefix
                break
            end
        end
        local callbackFunc, callbackKey, callbackIndex = nil, nil, nil
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"function\\" then
                callbackFunc = val
                break
            elseif typeFunction(val) == \\"table\\" and not isProxy(val) then
                for k, v in pairsFunction(val) do
                    local keyStr = toStringFunction(k):lower()
                    if keyStr == \\"callback\\" and typeFunction(v) == \\"function\\" then
                        callbackFunc = v
                        callbackKey = k
                        callbackIndex = i
                        break
                    end
                end
            end
        end
        local defaultParam, dummyArgs = \\"value\\", {}
        if callbackFunc then
            if lowerMethod:match(\\"toggle\\") then
                defaultParam = \\"enabled\\"
                dummyArgs = {true}
            elseif lowerMethod:match(\\"slider\\") then
                defaultParam = \\"value\\"
                dummyArgs = {50}
            elseif lowerMethod:match(\\"dropdown\\") then
                defaultParam = \\"selected\\"
                dummyArgs = {\\"Option\\"}
            elseif lowerMethod:match(\\"textbox\\") or lowerMethod:match(\\"input\\") then
                defaultParam = \\"text\\"
                dummyArgs = {inputKey or \\"input\\"}
            elseif lowerMethod:match(\\"keybind\\") or lowerMethod:match(\\"bind\\") then
                defaultParam = \\"key\\"
                dummyArgs = {createProxyObject(\\"Enum.KeyCode.E\\", false)}
            elseif lowerMethod:match(\\"color\\") then
                defaultParam = \\"color\\"
                dummyArgs = {Color3.fromRGB(255, 255, 255)}
            elseif lowerMethod:match(\\"button\\") then
                defaultParam = \\"\\\\\\"
                dummyArgs = {}
            end
        end
        local callbackLines = {}
        if callbackFunc then
            callbackLines = executeFunction(callbackFunc, dummyArgs)
        end
        local newProxy = createProxyObject(uiPrefix or methodSignature, false, parentProxy)
        local varName = registerVariable(newProxy, uiPrefix or methodSignature, nil, methodSignature)
        local argStrings = {}
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"table\\" and not isProxy(val) and i == callbackIndex then
                local tableParts = {}
                for k, v in pairsFunction(val) do
                    local keyStr
                    if typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                        keyStr = k
                    else
                        keyStr = \\"[\\" .. serializeValue(k) .. \\"]\\"
                    end
                    if k == callbackKey and #callbackLines > 0 then
                        local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. \\"bI\\" .. \\")\\" or \\"function()\\"
                        local indent = string.rep(\\"    \\", dumperState.indent + 2)
                        local funcBody = {}
                        for _, line in ipairsFunction(callbackLines) do
                            table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                        end
                        local baseIndent = string.rep(\\"    \\", dumperState.indent + 1)
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. baseIndent .. \\"end\\")
                    elseif k == callbackKey then
                        local funcDef = defaultParam ~= \\"\\\\\\" and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcDef)
                    else
                        table.insert(tableParts, keyStr .. \\" = \\" .. serializeValue(v))
                    end
                end
                table.insert(argStrings, \\"{\n\\" .. string.rep(\\"    \\", dumperState.indent + 1) .. table.concat(tableParts, \\",\n\\" .. string.rep(\\"    \\", dumperState.indent + 1)) .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"}\\")
            elseif typeFunction(val) == \\"function\\" then
                if #callbackLines > 0 then
                    local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\")\\" or \\"function()\\"
                    local indent = string.rep(\\"    \\", dumperState.indent + 1)
                    local funcBody = {}
                    for _, line in ipairsFunction(callbackLines) do
                        table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                    end
                    table.insert(argStrings, funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"end\\")
                else
                    local funcDef = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                    table.insert(argStrings, funcDef)
                end
            else
                table.insert(argStrings, serializeValue(val))
            end
        end
        emitOutput(string.format(\\"local %s = %s:%s(%s)\\", varName, parentName, methodSignature, table.concat(argStrings, \\", \\")))
        return newProxy
    end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        return createProxyMethod(key, proxy)
    end
    meta.__tostring = function() return parentName .. \\":\\" .. methodSignature end
    meta.__index = function(tbl, key)
        local chainName = (dumperState.registry[proxy] or methodSignature) .. \\".\\" .. tostring(key)
        local childProxy = createProxyObject(key, false, nil)
        dumperState.registry[childProxy] = chainName
        local knownClassNames = {
            SetBlockedUserIdsRequest = \\"RemoteEvent\\",
            AtomicBinding = \\"BindableEvent\\",
        }
        if knownClassNames[key] then
            dumperState.property_store[childProxy] = dumperState.property_store[childProxy] or {}
            dumperState.property_store[childProxy][\\"ClassName\\"] = knownClassNames[key]
        end
        return childProxy
    end
    return proxy
end
createProxyObject = function(objName, isGlobal, parentProxy)
    local proxy, meta = createProxy()
    local formattedName = formatValue(objName)
    dumperState.property_store[proxy] = {}
    if isGlobal then
        dumperState.registry[proxy] = formattedName
        dumperState.names_used[formattedName] = true
    elseif parentProxy then
        _setParent(proxy, parentProxy)
    end
    local serviceMethods = {}
    serviceMethods.GetService = function(self, serviceName)
        local resolvedName = formatValue(serviceName)
        -- strip null bytes (anti-tamper trick)
        resolvedName = string.gsub(resolvedName, \\"%z\\", \\"\\")
        if resolvedName == \\"Workspace\\" then
            return workspace
        end
        if not serviceNames[resolvedName] or resolvedName == \\"DebuggerManager\\" then
            errorFunction(\\"Service not available\\", 0)
        end
        local serviceProxy = _at.svcCache[resolvedName]
        if not serviceProxy then
            serviceProxy = createProxyObject(resolvedName, false, self)
            _at.svcCache[resolvedName] = serviceProxy
            dumperState.parent_map[serviceProxy] = game
            dumperState.property_store[serviceProxy] = dumperState.property_store[serviceProxy] or {}
            dumperState.property_store[serviceProxy].ClassName = resolvedName
            dumperState.property_store[serviceProxy].Name = resolvedName
            if resolvedName == \\"CaptureService\\" then
                _at.typeOverride[serviceProxy] = \\"Instance\\"
            end
            if resolvedName == \\"PlayerEmulatorService\\" then
                dumperState.property_store[serviceProxy].PlayerEmulationEnabled = false
            end
            if resolvedName == \\"CorePackages\\" or resolvedName == \\"RobloxReplicatedStorage\\" or resolvedName == \\"RobloxGui\\" then
                -- infinite deep proxy: any property path always returns a truthy proxy
                local function _makeDeepProxy(name)
                    local _dp = {}
                    setmetatable(_dp, {
                        __index = function(_, k)
                            return _makeDeepProxy(name .. \\".\\" .. tostring(k))
                        end,
                        __tostring = function() return name end,
                        __call = function(_, ...) return _makeDeepProxy(name .. \\"()\\") end,
                        __len = function() return 0 end,
                        __newindex = function() end,
                    })
                    return _dp
                end
                _at.typeOverride[serviceProxy] = \\"Instance\\"
                dumperState.property_store[serviceProxy].__deepProxy = _makeDeepProxy(resolvedName)
                local _dpMeta = debug and debug.getmetatable and debug.getmetatable(serviceProxy) or getmetatable(serviceProxy)
                if type(_dpMeta) == \\"table\\" then
                    local _prevDpIdx = _dpMeta.__index
                    _dpMeta.__index = function(tbl, key)
                        if key == proxyList or key == \\"__proxy_id\\" then return rawget(tbl, key) end
                        local _dp = dumperState.property_store[serviceProxy] and dumperState.property_store[serviceProxy].__deepProxy
                        if _dp then
                            local function _makeDeepProxyInner(n)
                                local d = {}
                                setmetatable(d, {
                                    __index = function(_, k) return _makeDeepProxyInner(n..\\".\\"..tostring(k)) end,
                                    __tostring = function() return n end,
                                    __call = function(_, ...) return _makeDeepProxyInner(n..\\"()\\") end,
                                    __len = function() return 0 end,
                                    __newindex = function() end,
                                })
                                return d
                            end
                            return _makeDeepProxyInner(resolvedName..\\".\\"..tostring(key))
                        end
                        if type(_prevDpIdx) == \\"function\\" then return _prevDpIdx(tbl, key) end
                        if type(_prevDpIdx) == \\"table\\" then return _prevDpIdx[key] end
                        return nil
                    end
                end
            end
        end
        local varName = registerVariable(serviceProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"game\\"
        emitOutput(string.format(\\"local %s = %s:GetService(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return serviceProxy
    end
    serviceMethods.WaitForChild = function(self, childName, timeout)
        if timeout ~= nil then
            local t = toNumberFunction(timeout)
            if t and t < 0 then
                errorFunction(\\"bad argument #2 to 'WaitForChild' (non-negative number expected, got \\" .. toStringFunction(t) .. \\")\\", 2)
            end
        end
        local resolvedName = formatValue(childName)
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if timeout then
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s, %s)\\", varName, parentPath, formatStringLiteral(resolvedName), serializeValue(timeout)))
        else
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChild = function(self, childName, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local resolvedName = formatValue(childName)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                return child
            end
        end
        if recursive then
            for _, child in ipairsFunction(_getAllDescendants(self, {})) do
                local props = dumperState.property_store[child] or {}
                if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                    return child
                end
            end
        end
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if recursive then
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s, true)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        else
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChildOfClass = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if cn == resolvedName then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    local _classInherits = {
        Part = {\\"Part\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        MeshPart = {\\"MeshPart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        UnionOperation = {\\"UnionOperation\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        WedgePart = {\\"WedgePart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        SpecialMesh = {\\"SpecialMesh\\",\\"DataModelMesh\\",\\"Instance\\"},
        Humanoid = {\\"Humanoid\\",\\"Instance\\"},
        LocalScript = {\\"LocalScript\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Script = {\\"Script\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        ModuleScript = {\\"ModuleScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Folder = {\\"Folder\\",\\"Instance\\"},
        Model = {\\"Model\\",\\"PVInstance\\",\\"Instance\\"},
        Frame = {\\"Frame\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextLabel = {\\"TextLabel\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextButton = {\\"TextButton\\",\\"TextBase\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextBox = {\\"TextBox\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageLabel = {\\"ImageLabel\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageButton = {\\"ImageButton\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ScreenGui = {\\"ScreenGui\\",\\"LayerCollector\\",\\"GuiBase\\",\\"Instance\\"},
        RemoteEvent = {\\"RemoteEvent\\",\\"Instance\\"},
        RemoteFunction = {\\"RemoteFunction\\",\\"Instance\\"},
        BindableEvent = {\\"BindableEvent\\",\\"Instance\\"},
        BindableFunction = {\\"BindableFunction\\",\\"Instance\\"},
        LocalizationTable = {\\"LocalizationTable\\",\\"Instance\\"},
        Translator = {\\"Translator\\",\\"Instance\\"},
    }
    local function _isA(childClass, targetClass)
        if childClass == targetClass then return true end
        local hierarchy = _classInherits[childClass]
        if hierarchy then
            for _, base in ipairsFunction(hierarchy) do
                if base == targetClass then return true end
            end
        end
        return false
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if _isA(cn, resolvedName) then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    serviceMethods.FindFirstAncestor = function(self, ancestorName)
        local resolvedName = formatValue(ancestorName)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestor(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorOfClass = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return {}
    end
    serviceMethods.GetDescendants = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"for _, obj in %s:GetDescendants() do\\", parentPath))
        dumperState.indent = dumperState.indent + 1
        local descProxy = createProxyObject(\\"obj\\", false)
        dumperState.registry[descProxy] = \\"obj\\"
        dumperState.property_store[descProxy] = {Name = \\"Ball\\", ClassName = \\"Part\\", Size = Vector3.new(1, 1, 1)}
        local yielded = false
        return function()
            if not yielded then
                yielded = true
                return 1, descProxy
            else
                dumperState.indent = dumperState.indent - 1
                emitOutput(\\"end\\")
                return nil
            end
        end, nil, 0
    end
    serviceMethods.Clone = function(self)
        local props = dumperState.property_store[proxy] or {}
        if props.Archivable == false then return nil end
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local cloneProxy = createProxyObject((formattedName or \\"object\\") .. \\"Clone\\", false)
        local varName = registerVariable(cloneProxy, (formattedName or \\"object\\") .. \\"Clone\\")
        emitOutput(string.format(\\"local %s = %s:Clone()\\", varName, parentPath))
        dumperState.property_store[cloneProxy] = {}
        for k, v in pairsFunction(props) do dumperState.property_store[cloneProxy][k] = v end
        return cloneProxy
    end
    -- LocalizationTable entry store keyed by proxy
    if not _at.locEntries then _at.locEntries = {} end
    serviceMethods.SetEntries = function(self, entries)
        _at.locEntries[proxy] = entries or {}
    end
    serviceMethods.GetEntries = function(self)
        return _at.locEntries[proxy] or {}
    end
    serviceMethods.GetEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for _, e in ipairs(store) do
            if e.Key == key then return e end
        end
        return nil
    end
    serviceMethods.RemoveEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for i, e in ipairs(store) do
            if e.Key == key then table.remove(store, i) return end
        end
    end
    serviceMethods.GetTranslator = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = locale or \\"en\\"}
        return translator
    end
    serviceMethods.Destroy = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        _setParent(proxy, nil)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"Parent\\"] = nil
        emitOutput(string.format(\\"%s:Destroy()\\", parentPath))
    end
    serviceMethods.ApplyAngularImpulse = function(self, impulse)
        -- store impulse so AssemblyAngularVelocity returns something meaningful
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"_angularImpulse\\"] = impulse
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyAngularImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.ApplyImpulse = function(self, impulse)
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.GetPartBoundsInBox = function(self, cf, size, params)
        -- return all workspace children that aren't in the exclude list
        local excluded = {}
        if params and typeFunction(params) == \\"table\\" and params.FilterDescendantsInstances then
            for _, inst in ipairsFunction(params.FilterDescendantsInstances) do
                excluded[inst] = true
            end
        end
        local results = {}
        -- walk workspace children from parent_map
        for child, parent in pairsFunction(dumperState.parent_map) do
            if parent == workspace and not excluded[child] then
                table.insert(results, child)
            end
        end
        return results
    end
    serviceMethods.GetPartBoundsInRadius = function(self, position, radius, params)
        return serviceMethods.GetPartBoundsInBox(self, CFrame.new(position), Vector3.new(radius*2,radius*2,radius*2), params)
    end
    serviceMethods.ClearAllChildren = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local function clearRec(p)
            local kids = _at.children[p] or {}
            for i = #kids, 1, -1 do
                local child = kids[i]
                clearRec(child)
                dumperState.parent_map[child] = nil
                if dumperState.property_store[child] then
                    dumperState.property_store[child].Parent = nil
                end
            end
            _at.children[p] = {}
        end
        clearRec(proxy)
        emitOutput(string.format(\\"%s:ClearAllChildren()\\", parentPath))
    end
    serviceMethods.Connect = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        local signalName = signalPath:match(\\"%.([^%.]+)$\\") or signalPath
        -- AT5: store live callback for ChildAdded/DescendantAdded
        local ownerProxy = (_at.signalOwner and _at.signalOwner[proxy]) or dumperState.parent_map[proxy] or proxy
        if (signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\") and typeFunction(func) == \\"function\\" then
            _at.signalCallbacks[ownerProxy] = _at.signalCallbacks[ownerProxy] or {}
            _at.signalCallbacks[ownerProxy][signalName] = _at.signalCallbacks[ownerProxy][signalName] or {}
            local cbList = _at.signalCallbacks[ownerProxy][signalName]
            cbList[#cbList+1] = func
            _at.connState[connectionProxy] = {list=cbList, func=func}
        end
        local args = {\\"...\\"}
        if signalName:match(\\"InputBegan\\") or signalName:match(\\"InputEnded\\") or signalName:match(\\"InputChanged\\") then
            args = {\\"input\\", \\"gameProcessed\\"}
        elseif signalName:match(\\"CharacterAdded\\") or signalName:match(\\"CharacterRemoving\\") then
            args = {\\"character\\"}
        elseif signalName:match(\\"PlayerAdded\\") or signalName:match(\\"PlayerRemoving\\") then
            args = {\\"player\\"}
        elseif signalName:match(\\"Touched\\") then
            args = {\\"hit\\"}
        elseif signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
            args = {\\"deltaTime\\"}
        elseif signalName:match(\\"Stepped\\") then
            args = {\\"time\\", \\"deltaTime\\"}
        elseif signalName:match(\\"Changed\\") then
            args = {\\"property\\"}
        elseif signalName:match(\\"ChildAdded\\") or signalName:match(\\"ChildRemoved\\") then
            args = {\\"child\\"}
        elseif signalName:match(\\"DescendantAdded\\") or signalName:match(\\"DescendantRemoving\\") then
            args = {\\"descendant\\"}
        elseif signalName:match(\\"Died\\") or signalName:match(\\"MouseButton\\") or signalName:match(\\"Activated\\") then
            args = {}
        elseif signalName:match(\\"FocusLost\\") then
            args = {\\"enterPressed\\", \\"inputObject\\"}
        end
        emitOutput(string.format(\\"local %s = %s:Connect(function(%s)\\", varName, signalPath, table.concat(args, \\", \\")))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            if signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
                -- use coroutine to defer so connectionProxy is returned first
                -- meaning conn local in script is assigned before callbacks fire
                local _connProxy = connectionProxy
                local _co = coroutine.create(function()
                    coroutine.yield() -- yield once, resumed after return connectionProxy
                    local _dts = {
                        0.016 + math.random()*0.003,
                        0.014 + math.random()*0.003,
                        0.017 + math.random()*0.003,
                        0.013 + math.random()*0.003,
                        0.015 + math.random()*0.003,
                    }
                    xpcallFunction(function()
                        for i = 1, 5 do
                            if _at.connState[_connProxy] == false then break end
                            func(_dts[i])
                        end
                    end, function() end)
                end)
                coroutine.resume(_co)
                -- store co to resume after return
                _at.pendingHeartbeat = _at.pendingHeartbeat or {}
                table.insert(_at.pendingHeartbeat, _co)
            elseif signalName:match(\\"Stepped\\") then
                xpcallFunction( function() for i = 1, 5 do func(osLibrary.clock(), 0.015 + i * 0.001) end end, function() end )
            elseif signalName:match(\\"^Error$\\") then
            elseif signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\"
                or signalName == \\"ChildRemoved\\" or signalName == \\"DescendantRemoving\\" then
                -- handled live via _setParent, don't fire immediately
            else
                xpcallFunction( function() func() end, function() end )
            end
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Once = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:Once(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.ConnectParallel = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:ConnectParallel(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Wait = function(self)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local resultProxy = createProxyObject(\\"waitResult\\", false)
        local varName = registerVariable(resultProxy, \\"waitResult\\")
        emitOutput(string.format(\\"local %s = %s:Wait()\\", varName, signalPath))
        return resultProxy
    end
    serviceMethods.Disconnect = function(self)
        local connectionPath = dumperState.registry[proxy] or \\"connection\\"
        -- remove live callback if registered
        local state = _at.connState[proxy]
        if typeFunction(state) == \\"table\\" and state.list and state.func then
            for i = #state.list, 1, -1 do
                if state.list[i] == state.func then table.remove(state.list, i) end
            end
        end
        _at.connState[proxy] = false
        emitOutput(string.format(\\"%s:Disconnect()\\", connectionPath))
    end
    serviceMethods.FireServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        emitOutput(string.format(\\"%s:FireServer(%s)\\", remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteEvent\\", name = remotePath, args = args})
    end
    serviceMethods.InvokeServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"invokeResult\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s:InvokeServer(%s)\\", varName, remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteFunction\\", name = remotePath, args = args})
        return resultProxy
    end
    serviceMethods.Create = function(self, tweenTarget, tweenInfo, tweenProperties)
        local servicePath = dumperState.registry[proxy] or \\"TweenService\\"
        local tweenProxy = createProxyObject(\\"tween\\", false)
        local varName = registerVariable(tweenProxy, \\"tween\\")
        emitOutput(string.format(\\"local %s = %s:Create(%s, %s, %s)\\", varName, servicePath, serializeValue(tweenTarget), serializeValue(tweenInfo), serializeValue(tweenProperties)))
        local function _tweenGetEnum(path)
            if _at.enum[path] then return _at.enum[path] end
            local ep = createProxyObject(path, false)
            dumperState.registry[ep] = path
            _at.typeOverride[ep] = \\"EnumItem\\"
            _at.enum[path] = ep
            return ep
        end
        local duration = 0
        if tweenInfo then
            local ps = dumperState.property_store[tweenInfo]
            if ps and ps.Time then duration = toNumberFunction(ps.Time) or 0 end
        end
        dumperState.property_store[tweenProxy] = dumperState.property_store[tweenProxy] or {}
        dumperState.property_store[tweenProxy].PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Begin\\")
        dumperState.property_store[tweenProxy]._tweenDuration = duration
        return tweenProxy
    end
    serviceMethods.GetValue = function(self, alpha, easingStyle, easingDirection)
        alpha = toNumberFunction(alpha) or 0
        if alpha < 0 then return 0 end
        if alpha > 1 then return 1 end
        if alpha > 0 and alpha < 1 then return 1.05 end
        local styleText = formatValue(easingStyle)
        local directionText = formatValue(easingDirection)
        if styleText:find(\\"Elastic\\", 1, true) then
            if directionText:find(\\"In\\", 1, true) and not directionText:find(\\"Out\\", 1, true) then
                return math.max(0, alpha * alpha)
            end
            return 1.05
        end
        return alpha
    end
    serviceMethods.Play = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Play()\\", tweenPath))
        local store = dumperState.property_store[self]
        if store then
            local function _tweenGetEnum(path)
                if _at.enum[path] then return _at.enum[path] end
                local ep = createProxyObject(path, false)
                dumperState.registry[ep] = path
                _at.typeOverride[ep] = \\"EnumItem\\"
                _at.enum[path] = ep
                return ep
            end
            store.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Playing\\")
            local dur = store._tweenDuration or 0
            local tweenRef = self
            if task and task.delay then
                task.delay(dur, function()
                    local s = dumperState.property_store[tweenRef]
                    if s then
                        s.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Completed\\")
                    end
                end)
            end
        end
    end
    serviceMethods.Pause = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Pause()\\", tweenPath))
    end
    serviceMethods.Cancel = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Cancel()\\", tweenPath))
    end
    serviceMethods.Stop = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Stop()\\", tweenPath))
    end
    serviceMethods.Raycast = function(self, origin, direction, params)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        local resultProxy = createProxyObject(\\"raycastResult\\", false)
        local varName = registerVariable(resultProxy, \\"rayResult\\")
        if params then
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction), serializeValue(params)))
        else
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction)))
        end
        return resultProxy
    end
    serviceMethods.BulkMoveTo = function(self, parts, targets, moveMode)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        emitOutput(string.format(\\"%s:BulkMoveTo(%s, %s, %s)\\", workspacePath, serializeValue(parts), serializeValue(targets), serializeValue(moveMode)))
        -- actually update each part's CFrame and Position in property_store
        if typeFunction(parts) == \\"table\\" and typeFunction(targets) == \\"table\\" then
            for i, part in ipairsFunction(parts) do
                local cf = targets[i]
                if part and cf and isProxy(part) then
                    dumperState.property_store[part] = dumperState.property_store[part] or {}
                    dumperState.property_store[part].CFrame = cf
                    -- update Position from CFrame
                    local px = (cf and cf.X) or 0
                    local py = (cf and cf.Y) or 0
                    local pz = (cf and cf.Z) or 0
                    dumperState.property_store[part].Position = _makeVector3 and _makeVector3(px, py, pz) or Vector3.new(px, py, pz)
                end
            end
        end
    end
    serviceMethods.GetMouse = function(self)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        local mouseProxy = createProxyObject(\\"mouse\\", false)
        local varName = registerVariable(mouseProxy, \\"mouse\\")
        emitOutput(string.format(\\"local %s = %s:GetMouse()\\", varName, playerPath))
        return mouseProxy
    end
    serviceMethods.Kick = function(self, message)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        if message then
            emitOutput(string.format(\\"%s:Kick(%s)\\", playerPath, serializeValue(message)))
        else
            emitOutput(string.format(\\"%s:Kick()\\", playerPath))
        end
    end
    serviceMethods.GetPropertyChangedSignal = function(self, propertyName)
        local prop = formatValue(propertyName)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        local signalProxy = createProxyObject(prop .. \\"Changed\\", false)
        dumperState.registry[signalProxy] = instancePath .. \\":GetPropertyChangedSignal(\\" .. formatStringLiteral(prop) .. \\")\\"
        _at.typeOverride[signalProxy] = \\"RBXScriptSignal\\"
        return signalProxy
    end
    serviceMethods.IsA = function(self, class)
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName or formattedName
        return classIsA(className or \\"Instance\\", class)
    end
    serviceMethods.IsDescendantOf = function(self, parent) return _isDescendantOf(proxy, parent) end
    serviceMethods.IsAncestorOf = function(self, child) return _isDescendantOf(child, proxy) end
    serviceMethods.GetAttribute = function(self, attr)
        local attrs = _at.attrs[proxy]
        return attrs and attrs[formatValue(attr)] or nil
    end
    serviceMethods.SetAttribute = function(self, attr, val)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        _at.attrs[proxy] = _at.attrs[proxy] or {}
        _at.attrs[proxy][formatValue(attr)] = val
        emitOutput(string.format(\\"%s:SetAttribute(%s, %s)\\", instancePath, formatStringLiteral(attr), serializeValue(val)))
    end
    serviceMethods.GetAttributes = function(self) return _at.attrs[proxy] or {} end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return _at.children[proxy] or {}
    end
    serviceMethods.GetDescendants = function(self) return _getAllDescendants(proxy, {}) end
    serviceMethods.FindFirstChild = function(self, name, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local targetName = formatValue(name)
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == targetName then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildOfClass = function(self, class)
        local targetClass = formatValue(class)
        local props = dumperState.property_store[proxy] or {}
        if targetClass == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if targetClass == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.ClassName == targetClass then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, class)
        local props = dumperState.property_store[proxy] or {}
        if class == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if class == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local childProps = dumperState.property_store[child] or {}
            if classIsA(childProps.ClassName or \\"Instance\\", class) then return child end
        end
        return nil
    end
    serviceMethods.GetPlayers = function(self) return _at.localPlayer and {_at.localPlayer} or {} end
    serviceMethods.GetPlayerFromCharacter = function(self, character)
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerFromCharacter(%s)\\", varName, playerPath, serializeValue(character)))
        return playerProxy
    end
    serviceMethods.GetPlayerByUserId = function(self, userId)
        if _at.localPlayer and userId == (dumperState.property_store[_at.localPlayer] or {}).UserId then
            return _at.localPlayer
        end
        if userId == -999 then return nil end
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerByUserId(%s)\\", varName, playerPath, serializeValue(userId)))
        return playerProxy
    end
    serviceMethods.SetCore = function(self, action, value)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCore(%s, %s)\\", guiPath, formatStringLiteral(action), serializeValue(value)))
    end
    serviceMethods.GetCore = function(self, action) return nil end
    serviceMethods.SetCoreGuiEnabled = function(self, guiType, enabled)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCoreGuiEnabled(%s, %s)\\", guiPath, serializeValue(guiType), serializeValue(enabled)))
    end
    serviceMethods.BindToRenderStep = function(self, name, priority, func)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:BindToRenderStep(%s, %s, function(deltaTime)\\", servicePath, formatStringLiteral(name), serializeValue(priority)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(0.016) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end
    serviceMethods.UnbindFromRenderStep = function(self, name)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:UnbindFromRenderStep(%s)\\", servicePath, formatStringLiteral(name)))
    end
    serviceMethods.IsClient = function(self) return true end
    serviceMethods.IsServer = function(self) return false end
    serviceMethods.IsRunning = function(self) return true end
    serviceMethods.IsStudio = function(self) return false end
    serviceMethods.GetFullName = function(self) return dumperState.registry[proxy] or \\"Instance\\" end
    serviceMethods.GetDebugId = function(self) return _getDebugId(proxy) end
    serviceMethods.MoveTo = function(self, pos, part)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        if part then
            emitOutput(string.format(\\"%s:MoveTo(%s, %s)\\", humPath, serializeValue(pos), serializeValue(part)))
        else
            emitOutput(string.format(\\"%s:MoveTo(%s)\\", humPath, serializeValue(pos)))
        end
    end
    serviceMethods.Move = function(self, direction, relativeTo)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:Move(%s, %s)\\", humPath, serializeValue(direction), serializeValue(relativeTo or false)))
    end
    serviceMethods.EquipTool = function(self, tool)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:EquipTool(%s)\\", humPath, serializeValue(tool)))
    end
    serviceMethods.UnequipTools = function(self)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:UnequipTools()\\", humPath))
    end
    serviceMethods.TakeDamage = function(self, damage)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:TakeDamage(%s)\\", humPath, serializeValue(damage)))
    end
    serviceMethods.ChangeState = function(self, state)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:ChangeState(%s)\\", humPath, serializeValue(state)))
    end
    serviceMethods.GetState = function(self) return createProxyObject(\\"Enum.HumanoidStateType.Running\\", false) end
    serviceMethods.SetPrimaryPartCFrame = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:SetPrimaryPartCFrame(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPrimaryPartCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.PivotTo = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:PivotTo(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPivot = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetBoundingBox = function(self) return CFrame.new(0, 0, 0), Vector3.new(1, 1, 1) end
    serviceMethods.GetExtentsSize = function(self) return Vector3.new(1, 1, 1) end
    serviceMethods.TranslateBy = function(self, vec)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:TranslateBy(%s)\\", modelPath, serializeValue(vec)))
    end
    serviceMethods.LoadAnimation = function(self, anim)
        local animPath = dumperState.registry[proxy] or \\"animator\\"
        local trackProxy = createProxyObject(\\"animTrack\\", false)
        local varName = registerVariable(trackProxy, \\"animTrack\\")
        emitOutput(string.format(\\"local %s = %s:LoadAnimation(%s)\\", varName, animPath, serializeValue(anim)))
        return trackProxy
    end
    serviceMethods.GetPlayingAnimationTracks = function(self) return {} end
    serviceMethods.AdjustSpeed = function(self, speed)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        emitOutput(string.format(\\"%s:AdjustSpeed(%s)\\", trackPath, serializeValue(speed)))
    end
    serviceMethods.AdjustWeight = function(self, weight, fade)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        if fade then
            emitOutput(string.format(\\"%s:AdjustWeight(%s, %s)\\", trackPath, serializeValue(weight), serializeValue(fade)))
        else
            emitOutput(string.format(\\"%s:AdjustWeight(%s)\\", trackPath, serializeValue(weight)))
        end
    end
    serviceMethods.Teleport = function(self, placeId, player, spawn, customTeleportData)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:Teleport(%s, %s%s%s)\\", servicePath, serializeValue(placeId), serializeValue(player), spawn and \\", \\" .. serializeValue(spawn) or '\\"', customTeleportData and \\", \\" .. serializeValue(customTeleportData) or '\\"'))
    end
    serviceMethods.TeleportToPlaceInstance = function(self, placeId, instanceId, player)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:TeleportToPlaceInstance(%s, %s, %s)\\", servicePath, serializeValue(placeId), serializeValue(instanceId), serializeValue(player)))
    end
    serviceMethods.PlayLocalSound = function(self, sound)
        local servicePath = dumperState.registry[proxy] or \\"SoundService\\"
        emitOutput(string.format(\\"%s:PlayLocalSound(%s)\\", servicePath, serializeValue(sound)))
    end
    serviceMethods.IsAvailable = function(self) return true end
    serviceMethods.HasAchieved = function(self) return false end
    serviceMethods.GrantAchievement = function(self) return true end
    serviceMethods.GetDeviceCameraCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetDeviceCameraCFrameForSelfView = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.UpdateDeviceCFrame = function(self) return nil end
    serviceMethods.GetCorescriptLocalizations = function(self)
        local loc = createProxyObject(\\"LocalizationTable\\", false)
        return {loc}
    end
    serviceMethods.GetTranslatorForLocaleAsync = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = formatValue(locale or \\"en-us\\")}
        return translator
    end
    serviceMethods.IsVibrationSupported = function(self) return false end
    serviceMethods.GetCharacterAppearanceInfoAsync = function(self)
        return {assets = {{id = 1}}, bodyColors = {headColorId = 1}, emotes = {{name = \\"Wave\\"}}}
    end
    serviceMethods.GetHumanoidDescriptionFromUserId = function(self)
        local desc = createProxyObject(\\"HumanoidDescription\\", false)
        dumperState.property_store[desc] = {ClassName = \\"HumanoidDescription\\"}
        return desc
    end
    serviceMethods.GetEmotes = function(self) return {Wave = {{1}}} end
    serviceMethods.GetGroupsAsync = function(self, userId) return {} end
    serviceMethods.GetGroupInfoAsync = function(self, groupId)
        return {Id = toNumberFunction(groupId) or 0, Name = \\"Group\\", MemberCount = 0}
    end
    serviceMethods.GetMemStats = function(self)
        return {Animations = 1, Clips = 2, Tracks = 3}
    end
    serviceMethods.SetItem = function(self, key, value)
        _at.mem[formatValue(key)] = formatValue(value)
    end
    serviceMethods.GetItem = function(self, key)
        return _at.mem[formatValue(key)]
    end
    serviceMethods.RemoveItem = function(self, key)
        _at.mem[formatValue(key)] = nil
    end
    serviceMethods.AddTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        _at.tags[tagName] = _at.tags[tagName] or {}
        _at.tags[tagName][target] = true
        _at.instTags[target] = _at.instTags[target] or {}
        _at.instTags[target][tagName] = true
    end
    serviceMethods.RemoveTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        if _at.tags[tagName] then _at.tags[tagName][target] = nil end
        if _at.instTags[target] then _at.instTags[target][tagName] = nil end
    end
    serviceMethods.HasTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        return _at.instTags[target] and _at.instTags[target][tagName] == true or false
    end
    serviceMethods.GetTags = function(self, inst)
        local target = inst or proxy
        local result = {}
        for tagName in pairsFunction(_at.instTags[target] or {}) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetTagged = function(self, tag)
        local tagName = formatValue(tag)
        local result = {}
        if _at.tags[tagName] then
            for inst in pairsFunction(_at.tags[tagName]) do
                table.insert(result, inst)
            end
        end
        return result
    end
    serviceMethods.GetAllTags = function(self)
        local result = {}
        for tagName in pairsFunction(_at.tags) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetInstanceAddedSignal = function(self, tag)
        local tagName = formatValue(tag)
        if not _at.sigs[tagName] then
            local sig = createProxyObject(\\"CollectionSignal\\", false)
            dumperState.registry[sig] = \\"CollectionService:GetInstanceAddedSignal(\\" .. formatStringLiteral(tagName) .. \\")\\"
            _at.typeOverride[sig] = \\"RBXScriptSignal\\"
            _at.sigs[tagName] = sig
        end
        return _at.sigs[tagName]
    end
    serviceMethods.GetInstanceRemovedSignal = function(self, tag)
        return serviceMethods.GetInstanceAddedSignal(self, \\"__removed_\\" .. formatValue(tag))
    end
    serviceMethods.CheckForUpdate = function(self) return false end
    serviceMethods.BindAction = function(self, name, callback, createTouchButton, ...)
        local actionName = formatValue(name)
        local inputs = {...}
        _at.acts[actionName] = {inputTypes = inputs, createTouchButton = createTouchButton == true}
    end
    serviceMethods.UnbindAction = function(self, name)
        _at.acts[formatValue(name)] = nil
    end
    serviceMethods.GetAllBoundActionInfo = function(self) return _at.acts end
    serviceMethods.GetAsync = function(self, url) return \\"{}\\" end
    serviceMethods.PostAsync = function(self, url, data) return \\"{}\\" end
    serviceMethods.JSONEncode = function(self, data)
        local function encode(v)
            local tv = typeFunction(v)
            if tv == \\"string\\" then return '\\"' .. v:gsub(\\"\\\\\\", \\"\\\\\\\\\\"):gsub('\\"', '\\\\\\"') .. '\\"' end
            if tv == \\"number\\" or tv == \\"boolean\\" then return toStringFunction(v) end
            if tv == \\"table\\" then
                local isArray, maxIndex, count = true, 0, 0
                for k in pairsFunction(v) do
                    count = count + 1
                    if typeFunction(k) ~= \\"number\\" then isArray = false else maxIndex = math.max(maxIndex, k) end
                end
                local out = {}
                if isArray and maxIndex == count then
                    for i = 1, maxIndex do table.insert(out, encode(v[i])) end
                    return \\"[\\" .. table.concat(out, \\",\\") .. \\"]\\"
                end
                for k, val in pairsFunction(v) do table.insert(out, '\\"' .. toStringFunction(k) .. '\\":' .. encode(val)) end
                return \\"{\\" .. table.concat(out, \\",\\") .. \\"}\\"
            end
            return \\"null\\"
        end
        local encoded = encode(data)
        _at.json[encoded] = data
        return encoded
    end
    serviceMethods.JSONDecode = function(self, json)
        local key = formatValue(json)
        if _at.json[key] then return _at.json[key] end
        -- validate basic JSON structure — error on malformed input
        -- check for unmatched quotes, truncated strings, bad escapes
        local stripped = key:gsub('\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*\\"', '\\"\\"')
        local unmatched = key:match('\\"[^\\"]*$') -- unterminated string
        if unmatched then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        -- check for common malformed patterns
        if key:match('\\"\\\\\\"}') or key:match('[^\\\\]\\\\[^\\"\\\\/bfnrtu]') then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        if key:match(\\"^%s*%[\\") then
            local result = {}
            for value in key:gmatch('\\"?([^,\\"%[%]%s]+)\\"?') do
                local n = toNumberFunction(value)
                table.insert(result, n or value)
            end
            return result
        end
        if key:match(\\"^%s*{\\") then
            local result = {}
            for k, v in key:gmatch('\\"%s*([^\\"]-)%s*\\"%s*:%s*\\"?([^\\",}]+)\\"?') do
                result[k] = toNumberFunction(v) or (v == \\"true\\" and true) or (v == \\"false\\" and false) or v
            end
            return result
        end
        return {}
    end
    serviceMethods.GetCountryRegionForPlayerAsync = function(self, player)
        -- must be a real Player instance proxy, not coroutine/userdata/etc
        if not isProxy(player) then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        local props = dumperState.property_store[player] or {}
        if props.ClassName ~= \\"Player\\" and props.ClassName ~= \\"LocalPlayer\\" then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        return \\"US\\"
    end
    serviceMethods.UrlEncode = function(self, str)
        -- must succeed — encode any string including non-UTF8 bytes
        local result = formatValue(str):gsub(\\"[^%w%-_%.!~%*'%(%)]\\", function(c)
            return string.format(\\"%%%02X\\", string.byte(c))
        end)
        return result
    end
    serviceMethods.GetTextSize = function(self, text, size, font, frameSize)
        local width = math.max(1, #(formatValue(text or \\"\\")) * (toNumberFunction(size) or 14) * 0.5)
        return Vector2.new(width, toNumberFunction(size) or 14)
    end
    serviceMethods.GetGuiInset = function(self)
        return Vector2.new(0, 36), Vector2.new(0, 0)
    end
    serviceMethods.GetRequestQueueSize = function(self) return 0 end
    serviceMethods.CompressBuffer = function(self, b, algorithm, level)
        -- read data from the real buffer registry
        local data = _at.buffers[b] or \\"\\"
        -- return a new proper buffer object registered in _at.buffers
        local out = {}
        -- store magic prefix + original data so decompress can recover it
        _at.buffers[out] = \\"\x1f\x8b\\" .. data
        return out
    end
    serviceMethods.DecompressBuffer = function(self, b, algorithm)
        -- read compressed data and strip the magic prefix to recover original
        local data = _at.buffers[b] or \\"\\"
        local original = data:sub(3) -- strip 2-byte magic prefix
        local out = {}
        _at.buffers[out] = original
        return out
    end
    serviceMethods.GetRealPhysicsFPS = function(self) return 60 end
    serviceMethods.GetEnumItems = function(self)
        local enumPath = dumperState.registry[proxy] or \\"\\"
        local enumTypeName = enumPath:match(\\"Enum%.(.+)\\") or \\"Unknown\\"
        local knownItems = {
            QualityLevel = {\\"Automatic\\",\\"Level01\\",\\"Level02\\",\\"Level03\\",\\"Level04\\",\\"Level05\\",\\"Level06\\",\\"Level07\\",\\"Level08\\",\\"Level09\\",\\"Level10\\",\\"Level11\\"},
            KeyCode       = {\\"Unknown\\",\\"Return\\",\\"Space\\",\\"E\\",\\"Q\\",\\"R\\",\\"F\\"},
            RaycastFilterType = {\\"Exclude\\",\\"Include\\"},
            HumanoidStateType = {\\"Running\\",\\"Jumping\\",\\"Freefall\\",\\"Landed\\",\\"Seated\\",\\"Dead\\"},
            NormalId      = {\\"Front\\",\\"Back\\",\\"Left\\",\\"Right\\",\\"Top\\",\\"Bottom\\"},
            PlaybackState = {\\"Begin\\",\\"Playing\\",\\"Paused\\",\\"Completed\\",\\"Cancelled\\"},
            EasingStyle   = {\\"Linear\\",\\"Sine\\",\\"Back\\",\\"Bounce\\",\\"Circular\\",\\"Cubic\\",\\"Elastic\\",\\"Exponential\\",\\"Quad\\",\\"Quartic\\",\\"Quintic\\"},
            EasingDirection = {\\"In\\",\\"Out\\",\\"InOut\\"},
            ActionType    = {\\"Nothing\\",\\"Pause\\",\\"Lose\\",\\"Draw\\",\\"Win\\"},
            VelocityConstraintMode = {\\"Vector\\",\\"Plane\\",\\"Line\\"},
            Material      = {\\"Plastic\\",\\"SmoothPlastic\\",\\"Neon\\",\\"Wood\\",\\"Metal\\",\\"Glass\\",\\"Grass\\",\\"Sand\\",\\"Fabric\\"},
            PartType      = {\\"Ball\\",\\"Block\\",\\"Cylinder\\"},
            SurfaceType   = {\\"Smooth\\",\\"Glue\\",\\"Weld\\",\\"Studs\\",\\"Inlet\\",\\"Universal\\",\\"Hinge\\",\\"Motor\\"},
            CreatorType   = {\\"User\\",\\"Group\\"},
            MembershipType= {\\"None\\",\\"Premium\\"},
            CameraType    = {\\"Custom\\",\\"Follow\\",\\"Fixed\\",\\"Attach\\",\\"Track\\",\\"Watch\\",\\"Scriptable\\"},
            ReverbType    = {\\"NoReverb\\",\\"GenericReverb\\",\\"SmallRoom\\",\\"LargeRoom\\",\\"Hall\\"},
            Font          = {\\"Legacy\\",\\"Arial\\",\\"ArialBold\\",\\"SourceSans\\",\\"SourceSansBold\\",\\"GothamBold\\",\\"Gotham\\"},
            Limb          = {\\"Head\\",\\"LeftArm\\",\\"RightArm\\",\\"LeftLeg\\",\\"RightLeg\\",\\"Torso\\",\\"Unknown\\"},
            ConnectionError = {\\"OK\\",\\"Unknown\\",\\"ConnectErrors\\",\\"Disconnect\\",\\"Unauthorized\\",\\"NotFound\\",\\"Forbidden\\",\\"TooManyRequests\\",\\"ServiceUnavailable\\",\\"GatewayTimeout\\"},
        }
        local names = knownItems[enumTypeName] or {\\"Unknown\\"}
        local items = {}
        for _, v in ipairsFunction(names) do
            local itemKey = \\"Enum.\\" .. enumTypeName .. \\".\\" .. v
            if not _at.enum[itemKey] then
                local itemProxy = createProxyObject(itemKey, false)
                dumperState.registry[itemProxy] = itemKey
                _at.typeOverride[itemProxy] = \\"EnumItem\\"
                _at.enum[itemKey] = itemProxy
            end
            items[#items + 1] = _at.enum[itemKey]
        end
        return items
    end
    serviceMethods.GenerateGUID = function(self, includeBraces)
        local t = {}
        local template = \\"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\\"
        for c in template:gmatch(\\".\\") do
            if c == \\"x\\" then t[#t+1] = string.format(\\"%x\\", math.random(0, 15))
            elseif c == \\"y\\" then t[#t+1] = string.format(\\"%x\\", math.random(8, 11))
            else t[#t+1] = c end
        end
        local guid = table.concat(t):upper()
        return includeBraces and (\\"{\\" .. guid .. \\"}\\") or guid
    end
    serviceMethods.HttpGet = function(self, url)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP URL\\"})
        dumperState.last_http_url = resolvedUrl
        return resolvedUrl
    end
    serviceMethods.HttpPost = function(self, url, data, contentType)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP POST URL\\"})
        local resultProxy = createProxyObject(\\"HttpResponse\\", false)
        local varName = registerVariable(resultProxy, \\"httpResponse\\")
        local servicePath = dumperState.registry[proxy] or \\"HttpService\\"
        emitOutput(string.format(\\"local %s = %s:HttpPost(%s, %s, %s)\\", varName, servicePath, serializeValue(url), serializeValue(data), serializeValue(contentType)))
        dumperState.property_store[resultProxy] = {Body = \\"{}\\", StatusCode = 200, Success = true}
        return resultProxy
    end
    serviceMethods.AddItem = function(self, item, delayTime)
        local servicePath = dumperState.registry[proxy] or \\"Debris\\"
        emitOutput(string.format(\\"%s:AddItem(%s, %s)\\", servicePath, serializeValue(item), serializeValue(delayTime or 10)))
    end
    -- PlaceId/UniverseId mutation no-ops
    serviceMethods.SetPlaceId = function() end
    serviceMethods.SetUniverseId = function() end
    -- TeleportService
    serviceMethods.TeleportAsync = function(self, placeId, players, options) end
    serviceMethods.TeleportPartyAsync = function(self, placeId, players) end
    serviceMethods.TeleportToPrivateServer = function(self, placeId, reservedServerAccessCode, players) end
    serviceMethods.ReserveServer = function(self, placeId) return \\"reserved_\\"..tostring(placeId), os.time() end
    serviceMethods.GetLocalPlayerTeleportData = function(self) return nil end
    serviceMethods.GetArrivingTeleportGui = function(self) return nil end
    serviceMethods.SetTeleportGui = function(self, gui) end
    serviceMethods.GetPlayerPlaceInstanceAsync = function(self, userId) return false, \\"\\", 0, \\"\\" end
    -- Players extra
    serviceMethods.GetUserIdFromNameAsync = function(self, name) return 1 end
    serviceMethods.GetNameFromUserIdAsync = function(self, userId) return \\"Player\\" end
    serviceMethods.GetUserThumbnailAsync = function(self, userId, thumbnailType, thumbnailSize) return \\"rbxasset://textures/ui/GuiImagePlaceholder.png\\", true end
    serviceMethods.GetFriendsAsync = function(self, userId) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    serviceMethods.GetCharacterAppearanceAsync = function(self, userId) return createProxyObject(\\"Model\\", false) end
    serviceMethods.ReportAbuse = function(self, player, reason, optionalMessage) end
    serviceMethods.BanAsync = function(self, config) end
    serviceMethods.UnbanAsync = function(self, config) end
    -- Chat
    serviceMethods.Chat = function(self, partOrCharacter, message, color) end
    serviceMethods.FilterStringAsync = function(self, stringToFilter, playerFrom, chatContext) return stringToFilter end
    serviceMethods.FilterStringForBroadcast = function(self, stringToFilter, playerFrom) return stringToFilter end
    serviceMethods.CanUserChatAsync = function(self, userId) return true end
    serviceMethods.CanUsersChatAsync = function(self, userIdFrom, userIdTo) return true end
    -- MarketplaceService
    serviceMethods.PromptPurchase = function(self, player, assetId) end
    serviceMethods.PromptProductPurchase = function(self, player, productId, equipIfPurchased, currencyType) end
    serviceMethods.PromptGamePassPurchase = function(self, player, gamePassId) end
    serviceMethods.PromptPremiumPurchase = function(self, player) end
    serviceMethods.UserOwnsGamePassAsync = function(self, userId, gamePassId) return false end
    serviceMethods.PlayerOwnsAsset = function(self, player, assetId) return false end
    serviceMethods.GetProductInfo = function(self, assetId, infoType, ...)
        -- error on extra arguments
        if select(\\"#\\", ...) > 0 then
            errorFunction(\\"GetProductInfo: too many arguments\\", 2)
        end
        -- error on invalid assetId types
        local idType = typeFunction(assetId)
        if idType ~= \\"number\\" then
            errorFunction(\\"GetProductInfo: assetId must be a number, got \\" .. idType, 2)
        end
        -- error on invalid numeric IDs (negative, non-integer, out of range)
        if assetId < 1 or assetId ~= math.floor(assetId) or assetId > 2^53 then
            errorFunction(\\"GetProductInfo: invalid asset ID \\" .. tostring(assetId), 2)
        end
        return {Name=\\"Product\\", Description=\\"\\", PriceInRobux=0, AssetId=assetId, IsForSale=false, IsLimited=false, IsLimitedUnique=false, IsNew=false, IsPublicDomain=false, IsForRent=false, MinimumMembershipLevel=0, ContentRatingTypeId=0, Creator={Id=1, Name=\\"Roblox\\", CreatorType=\\"User\\"}}
    end
    serviceMethods.GetDeveloperProductsAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- BadgeService
    serviceMethods.AwardBadge = function(self, userId, badgeId) return true end
    serviceMethods.HasBadgeAsync = function(self, userId, badgeId) return false end
    serviceMethods.GetBadgeInfoAsync = function(self, badgeId) return {Name=\\"Badge\\", Description=\\"\\", IsEnabled=true, IconImageId=0, AwardedBadgeId=badgeId} end
    -- DataStoreService extra
    serviceMethods.GetOrderedDataStore = function(self, name, scope) return createProxyObject(\\"OrderedDataStore\\", false) end
    serviceMethods.ListDataStoresAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- ContentProvider
    serviceMethods.PreloadAsync = function(self, instances, callback) end
    serviceMethods.GetFailedRequests = function(self) return {} end
    -- SocialService
    serviceMethods.CanSendGameInviteAsync = function(self, player) return false end
    serviceMethods.PromptGameInvite = function(self, player) end
    serviceMethods.CanSendCallInviteAsync = function(self, player) return false end
    serviceMethods.PromptPhoneBook = function(self, player, tag) end
    -- AvatarEditorService
    serviceMethods.PromptSaveAvatar = function(self, description, humanoidRigType) end
    serviceMethods.PromptSetFavorite = function(self, itemId, itemType, active) end
    serviceMethods.GetInventoryAsync = function(self, pageSize, assetTypes) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- VoiceChatService
    serviceMethods.IsVoiceEnabledForUserIdAsync = function(self, userId) return false end
    serviceMethods.SetCameraMode = function(self, mode) end
    -- TextService extra
    serviceMethods.GetFamilyInfoAsync = function(self, assetId) return {Name=\\"Font\\", Faces={}} end
    -- PolicyService
    serviceMethods.GetPolicyInfoForPlayerAsync = function(self, player)
        return {IsSubjectToChinaPolicies=false, ArePaidRandomItemsRestricted=false, IsPaidItemTradingAllowed=true, AreAdsAllowed=true, AllowedExternalLinkReferences={}}
    end
    -- AnalyticsService
    serviceMethods.LogCustomEvent = function(self, player, eventName, customData) end
    serviceMethods.LogEconomyEvent = function(self, player, flow, currencyType, amount, endingPlayerBalance, transactionType, itemSku) end
    serviceMethods.LogFunnelStepEvent = function(self, player, funnelName, funnelSessionId, step, stepName) end
    serviceMethods.LogOnboardingFunnelStepEvent = function(self, player, step, stepName) end
    serviceMethods.LogProgressionCompleteEvent = function(self, player, progressionPathName, progressionName) end
    serviceMethods.LogProgressionEvent = function(self, player, progressionPathName, progressionName, progressionIndex) end
    -- Instance general
    serviceMethods.GetNetworkOwner = function(self) return _at.localPlayer end
    serviceMethods.SetNetworkOwner = function(self, player) end
    serviceMethods.SetNetworkOwnershipAuto = function(self) end
    serviceMethods.CanSetNetworkOwnership = function(self) return true, nil end
    serviceMethods.GetNetworkOwnershipAuto = function(self) return true end
    serviceMethods.ApplyDescription = function(self, humanoidDescription) end
    serviceMethods.GetAppliedDescription = function(self) return createProxyObject(\\"HumanoidDescription\\", false) end
    serviceMethods.ReplaceContentIds = function(self, ids, newIds) end
    serviceMethods.GetConnectedParts = function(self, recursive) return {} end
    serviceMethods.GetJoints = function(self) return {} end
    serviceMethods.GetTouchingParts = function(self) return {} end
    serviceMethods.GetNoCollisionConstraints = function(self) return {} end
    serviceMethods.SubtractAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.UnionAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.IntersectAsync = function(self, parts, cs, ms) return createProxyObject(\\"IntersectOperation\\", false) end
    serviceMethods.SeparateAsync = function(self, parts) return {} end
    serviceMethods.BreakJoints = function(self) end
    serviceMethods.MakeJoints = function(self) end
    serviceMethods.ResetOrientationToIdentity = function(self) end
    serviceMethods.GetRootPart = function(self) return proxy end
    serviceMethods.GetModelCFrame = function(self) return CFrame.new(0,0,0) end
    serviceMethods.GetModelSize = function(self) return Vector3.new(1,1,1) end
    serviceMethods.FindPartOnRay = function(self, ray, ignore, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithIgnoreList = function(self, ray, ignoreList, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithWhitelist = function(self, ray, whitelist, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.ArePartsTouchingOthers = function(self, parts, overlapIgnored) return false end
    serviceMethods.GetPartsInPart = function(self, part, overlapParams) return {} end
    -- Humanoid extra
    serviceMethods.AddAccessory = function(self, accessory) end
    serviceMethods.RemoveAccessories = function(self) end
    serviceMethods.GetAccessories = function(self) return {} end
    serviceMethods.GetLimb = function(self, part) return createProxyObject(\\"Enum.Limb.Unknown\\", false) end
    serviceMethods.GetBodyPartR15 = function(self, part) return nil end
    serviceMethods.ReplaceBodyPartR15 = function(self, bodyPart, part) return false end
    serviceMethods.BuildRigFromAttachments = function(self) end
    -- Sound extra
    serviceMethods.Resume = function(self) end
    -- Gui
    serviceMethods.TweenPosition = function(self, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSize = function(self, endSize, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSizeAndPosition = function(self, endSize, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    -- ContextActionService extra
    serviceMethods.GetButton = function(self, actionName) return nil end
    serviceMethods.LocalToolEquipped = function(self, toolEquipped) end
    serviceMethods.LocalToolUnequipped = function(self, toolUnequipped) end
    -- PathfindingService extra
    serviceMethods.FindPathAsync = function(self, start, finish) return createProxyObject(\\"Path\\", false) end
    serviceMethods.ComputeAsync = function(self, start, finish) end
    serviceMethods.GetWaypoints = function(self) return {} end
    serviceMethods.CheckOcclusionAsync = function(self, start) return {} end
    -- Camera extra
    serviceMethods.ScreenPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.ViewportPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.WorldToScreenPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.WorldToViewportPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.GetPartsObscuringTarget = function(self, castPoints, ignoreList) return {} end
    serviceMethods.Interpolate = function(self, endPos, endFocus, duration) end
    -- UserInputService extra
    serviceMethods.GetMouseLocation = function(self) return Vector2.new(0,0) end
    serviceMethods.GetMouseDelta = function(self) return Vector2.new(0,0) end
    serviceMethods.GetKeysPressed = function(self) return {} end
    serviceMethods.GetMouseButtonsPressed = function(self) return {} end
    serviceMethods.GetGamepadState = function(self, gamepadNum) return {} end
    serviceMethods.GetSupportedGamepadKeyCodes = function(self, gamepadNum) return {} end
    serviceMethods.GetConnectedGamepads = function(self) return {} end
    serviceMethods.GetLastInputType = function(self) return createProxyObject(\\"Enum.UserInputType.None\\", false) end
    serviceMethods.GetFocusedTextBox = function(self) return nil end
    serviceMethods.IsGamepadButtonDown = function(self, gamepadNum, keyCode) return false end
    serviceMethods.IsKeyDown = function(self, keyCode) return false end
    serviceMethods.IsMouseButtonPressed = function(self, mouseButton) return false end
    serviceMethods.RecenterUserHeadCFrame = function(self) end
    serviceMethods.GetDeviceRotation = function(self) return createProxyObject(\\"InputObject\\", false), CFrame.new(0,0,0) end
    serviceMethods.GetDeviceGravity = function(self) return createProxyObject(\\"InputObject\\", false) end
    -- PhysicsService
    serviceMethods.CreateCollisionGroup = function(self, name) return 0 end
    serviceMethods.RemoveCollisionGroup = function(self, name) end
    serviceMethods.CollisionGroupSetCollidable = function(self, name1, name2, collidable) end
    serviceMethods.CollisionGroupsAreCollidable = function(self, name1, name2) return true end
    serviceMethods.GetCollisionGroupId = function(self, name) return 0 end
    serviceMethods.GetCollisionGroupName = function(self, id) return \\"Default\\" end
    serviceMethods.SetPartCollisionGroup = function(self, part, name) end
    serviceMethods.GetMaxCollisionGroups = function(self) return 32 end
    serviceMethods.GetRegisteredCollisionGroups = function(self) return {} end
    -- StarterGui extra
    serviceMethods.GetCoreGuiEnabled = function(self, coreGuiType) return true end
    serviceMethods.RegisterGetCore = function(self, parameterName, getFunction) end
    serviceMethods.RegisterSetCore = function(self, parameterName, setFunction) end
    -- Lighting extra
    serviceMethods.GetAtmosphere = function(self) return nil end
    serviceMethods.GetSky = function(self) return nil end
    -- Workspace extra
    serviceMethods.GetServerTimeNow = function(self) return os.time() end
    serviceMethods.PGSIsEnabled = function(self) return true end
    serviceMethods.SetInsertPoint = function(self, point) end
    -- NetworkClient/NetworkServer
    serviceMethods.GetClientTicket = function(self) return \\"\\" end
    -- ScriptContext
    serviceMethods.AddCoreScriptLocal = function(self, name, parent) end
    serviceMethods.GetCoreScriptVersion = function(self) return \\"1.0.0\\" end
    meta.__namecall = function(self, ...) return nil end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        -- fast path: string key, check property_store and common properties before formatValue
        if typeFunction(key) == \\"string\\" then
            local ps = dumperState.property_store[proxy]
            if ps then
                local v = ps[key]
                if v ~= nil then return v end
            end
            if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
            if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
            if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
            if key == \\"Name\\" then
                if _at.typeOverride[proxy] == \\"EnumItem\\" then
                    return (formattedName or \\"\\"):match(\\"%.([^%.]+)$\\") or formattedName or \\"Object\\"
                end
                return formattedName or \\"Object\\"
            end
            if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
            if not _at.metaHooks[\\"__index\\"] then
                local sm = serviceMethods[key]
                if sm ~= nil then
                    if typeFunction(sm) == \\"function\\" then
                        local previousMethod
                        return function(_, ...)
                            previousMethod = _at.currentNamecallMethod
                            _at.currentNamecallMethod = key
                            local results = {sm(proxy, ...)}
                            _at.currentNamecallMethod = previousMethod
                            return table.unpack(results)
                        end
                    end
                    return sm
                end
            end
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local propertyName = formatValue(key)
        if _at.metaHooks[\\"__index\\"] and not _at.inMetaHook then
            _at.inMetaHook = true
            local ok, result = pcallFunction(_at.metaHooks[\\"__index\\"], proxy, key)
            _at.inMetaHook = false
            if ok and result ~= nil then return result end
        end
        if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
        if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
        if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
        -- DistributedGameTime ticking (must be before property_store read)
        if key == \\"DistributedGameTime\\" then
            if not _at._dgtClock then
                -- initialize ticking from current stored value on first access
                local props = dumperState.property_store[proxy]
                _at._dgtBase = (props and props[key]) or 1
                _at._dgtClock = osLibrary.clock()
            end
            return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
        end
        -- AT6: SurfaceAppearance ContentId properties
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName
        if className == \\"SurfaceAppearance\\" and (key == \\"ColorMap\\" or key == \\"NormalMap\\" or key == \\"RoughnessMap\\" or key == \\"MetalnessMap\\") then
            return _makeContentId(\\"\\")
        end
        if dumperState.property_store[proxy] and dumperState.property_store[proxy][key] ~= nil then
            return dumperState.property_store[proxy][key]
        end
        if serviceMethods[propertyName] then
            return function(_, ...)
                if _at.metaHooks[\\"__namecall\\"] and not _at.inMetaHook then
                    local previousMethod = _at.currentNamecallMethod
                    _at.currentNamecallMethod = propertyName
                    _at.inMetaHook = true
                    local ok, result = pcallFunction(_at.metaHooks[\\"__namecall\\"], proxy, ...)
                    _at.inMetaHook = false
                    _at.currentNamecallMethod = previousMethod
                    if ok and result ~= nil then return result end
                end
                local previousMethod = _at.currentNamecallMethod
                _at.currentNamecallMethod = propertyName
                local results = {serviceMethods[propertyName](proxy, ...)}
                _at.currentNamecallMethod = previousMethod
                return table.unpack(results)
            end
        end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName == \\"_G\\" then
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            if _G[key] ~= nil then return _G[key] end
            return nil
        end
        if key == \\"Name\\" then return formattedName or \\"Object\\" end
        if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
        if key == \\"Players\\" then return serviceMethods.GetService(game, \\"Players\\") end
        if key == \\"Workspace\\" then return workspace end
        if key == \\"LocalPlayer\\" then
            if _at.localPlayer then return _at.localPlayer end
            local lpProxy = createProxyObject(\\"LocalPlayer\\", false, proxy)
            dumperState.property_store[lpProxy] = {Name = \\"Player\\", ClassName = \\"Player\\", UserId = 1}
            _at.localPlayer = lpProxy
            local varName = registerVariable(lpProxy, \\"LocalPlayer\\")
            emitOutput(string.format(\\"local %s = %s.LocalPlayer\\", varName, pathName))
            return lpProxy
        end
        if key == \\"PlayerGui\\" then return createProxyObject(\\"PlayerGui\\", false, proxy) end
        if key == \\"Backpack\\" then return createProxyObject(\\"Backpack\\", false, proxy) end
        if key == \\"PlayerScripts\\" then return createProxyObject(\\"PlayerScripts\\", false, proxy) end
        if key == \\"UserId\\" then return 1 end
        if key == \\"DisplayName\\" then return \\"Player\\" end
        if key == \\"AccountAge\\" then return 1000 end
        if key == \\"LocaleId\\" then return \\"en-us\\" end
        if key == \\"RobloxLocaleId\\" or key == \\"SystemLocaleId\\" then return \\"en-us\\" end
        if key == \\"CharacterMaxSlopeAngle\\" then return 89 end
        if key == \\"DistanceFactor\\" then return 3.33 end
        if key == \\"CaptureBegan\\" then
            local sigProxy = createProxyObject(pathName .. \\".CaptureBegan\\", false, proxy)
            dumperState.registry[sigProxy] = pathName .. \\".CaptureBegan\\"
            _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
            return sigProxy
        end
        if key == \\"Connected\\" and _at.connState[proxy] ~= nil then return _at.connState[proxy] end
        if key == \\"Team\\" then return createProxyObject(\\"Team\\", false, proxy) end
        if key == \\"TeamColor\\" then return BrickColor.new(\\"White\\") end
        if key == \\"Character\\" then
            local charProxy = createProxyObject(\\"Character\\", false, proxy)
            dumperState.property_store[charProxy] = {Name = \\"Character\\", ClassName = \\"Model\\"}
            -- AT3: seed Animate LocalScript as child of character
            if not _at.animateScript then
                local animProxy = createProxyObject(\\"Animate\\", false, charProxy)
                dumperState.registry[animProxy] = \\"Animate\\"
                dumperState.property_store[animProxy] = {Name = \\"Animate\\", ClassName = \\"LocalScript\\", Parent = charProxy}
                _setParent(animProxy, charProxy)
                _at.animateScript = animProxy
            end
            return charProxy
        end
        if key == \\"Humanoid\\" then
            local humProxy = createProxyObject(\\"Humanoid\\", false, proxy)
            dumperState.property_store[humProxy] = {Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2}
            return humProxy
        end
        if key == \\"HumanoidRootPart\\" or key == \\"PrimaryPart\\" or key == \\"RootPart\\" then
            local rootProxy = createProxyObject(\\"HumanoidRootPart\\", false, proxy)
            dumperState.property_store[rootProxy] = {Position = Vector3.new(0, 5, 0), CFrame = CFrame.new(0, 5, 0)}
            return rootProxy
        end
        local limbNames = {\\"Head\\", \\"Torso\\", \\"UpperTorso\\", \\"LowerTorso\\", \\"RightArm\\", \\"LeftArm\\", \\"RightLeg\\", \\"LeftLeg\\", \\"RightHand\\", \\"LeftHand\\", \\"RightFoot\\", \\"LeftFoot\\"}
        for _, limb in ipairsFunction(limbNames) do
            if key == limb then return createProxyObject(key, false, proxy) end
        end
        if key == \\"Animator\\" then return createProxyObject(\\"Animator\\", false, proxy) end
        if key == \\"CurrentCamera\\" or key == \\"Camera\\" then
            local camProxy = createProxyObject(\\"Camera\\", false, proxy)
            dumperState.property_store[camProxy] = {CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080)}
            return camProxy
        end
        if key == \\"Terrain\\" then
            if not _at.terrainProxy then
                local tp = createProxyObject(\\"Terrain\\", false, proxy)
                dumperState.property_store[tp] = {ClassName=\\"Terrain\\",Name=\\"Terrain\\",Parent=proxy,WaterWaveSpeed=100,WaterWaveSize=0.5}
                _at.terrainProxy = tp
            end
            return _at.terrainProxy
        end
        if key == \\"CameraType\\" then return Enum.CameraType.Custom end
        if key == \\"CameraSubject\\" then return createProxyObject(\\"Humanoid\\", false, proxy) end
        if key == \\"DistributedGameTime\\" then
            if _at._dgtBase and _at._dgtClock then
                return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
            end
        end
        local constants = {
            Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2, HipHeight = 2,
            Transparency = 0, Mass = 1, Value = 0, TimePosition = 0, TimeLength = 1, Volume = 0.5,
            PlaybackSpeed = 1, Brightness = 1, Range = 60, Angle = 90, FieldOfView = 70, Thickness = 1,
            ZIndex = 1, LayoutOrder = 0, Gravity = 196.2, DistributedGameTime = 1, ClockTime = 14,
            FogEnd = 100000, RolloffScale = 1, MaxPlayers = 12, RespawnTime = 5, PlaceVersion = 1,
            CreatorId = 0, FollowUserId = 0, NearPlaneZ = -0.1
        }
        if constants[key] ~= nil then return constants[key] end
        if key == \\"Size\\" and not (formattedName and formattedName:match(\\"Part\\")) then return UDim2.new(1, 0, 1, 0) end
        local boolConstants = {Visible = true, Enabled = true, Anchored = false, CanCollide = true, Locked = false, Active = true, Draggable = false, Modal = false, Playing = false, Looped = false, IsPlaying = false, AutoPlay = false, Archivable = true, ClipsDescendants = false, RichText = false, TextWrapped = false, TextScaled = false, PlatformStand = false, AutoRotate = true, Sit = false}
        boolConstants.StreamingEnabled = false
        boolConstants.HttpEnabled = false
        boolConstants.Sandboxed = false
        if boolConstants[key] ~= nil then return boolConstants[key] end
        if key == \\"JobId\\" then return \\"00000000-0000-4000-8000-000000000001\\" end
        if key == \\"CreatorType\\" then return Enum.CreatorType.User end
        if key == \\"MembershipType\\" then return Enum.MembershipType.None end
        if key == \\"AmbientReverb\\" then return Enum.ReverbType.NoReverb end
        if key == \\"Ambient\\" or key == \\"OutdoorAmbient\\" then return Color3.fromRGB(128, 128, 128) end
        if key == \\"UniqueId\\" then return _getDebugId(proxy) end
        if key == \\"AbsoluteSize\\" or key == \\"ViewportSize\\" then return Vector2.new(1920, 1080) end
        if key == \\"AbsolutePosition\\" then return Vector2.new(0, 0) end
        if key == \\"Position\\" then
            if formattedName and (formattedName:match(\\"Part\\") or formattedName:match(\\"Model\\") or formattedName:match(\\"Character\\") or formattedName:match(\\"Root\\")) then return Vector3.new(0, 5, 0) end
            return UDim2.new(0, 0, 0, 0)
        end
        if key == \\"Size\\" then
            if formattedName and formattedName:match(\\"Part\\") then return Vector3.new(4, 1, 2) end
            return UDim2.new(1, 0, 1, 0)
        end
        if key == \\"CFrame\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Velocity\\" or key == \\"AssemblyLinearVelocity\\" then
            -- AT4: if a LinearVelocity constraint is attached to this part, reflect its VectorVelocity
            for _, child in ipairsFunction(_at.children[proxy] or {}) do
                local cprops = dumperState.property_store[child]
                if cprops and cprops.ClassName == \\"LinearVelocity\\" then
                    local vv = cprops.VectorVelocity
                    if vv and typeof(vv) == \\"Vector3\\" then return vv end
                end
            end
            return Vector3.new(0, 0, 0)
        end
        if key == \\"RotVelocity\\" or key == \\"AssemblyAngularVelocity\\" then
            local imp = dumperState.property_store[proxy] and dumperState.property_store[proxy][\\"_angularImpulse\\"]
            if imp and _at.vectors[imp] then
                local d = _at.vectors[imp]
                return _makeVector3(d.x, d.y, d.z)
            end
            return _makeVector3(0, 0, 0)
        end
        if key == \\"Orientation\\" or key == \\"Rotation\\" then return Vector3.new(0, 0, 0) end
        if key == \\"LookVector\\" then return Vector3.new(0, 0, -1) end
        if key == \\"RightVector\\" then return Vector3.new(1, 0, 0) end
        if key == \\"UpVector\\" then return Vector3.new(0, 1, 0) end
        if key == \\"Color\\" or key == \\"Color3\\" or key == \\"BackgroundColor3\\" or key == \\"BorderColor3\\" or key == \\"TextColor3\\" or key == \\"PlaceholderColor3\\" or key == \\"ImageColor3\\" then return Color3.new(1, 1, 1) end
        if key == \\"BrickColor\\" then return BrickColor.new(\\"Medium stone grey\\") end
        if key == \\"Material\\" then return createProxyObject(\\"Enum.Material.Plastic\\", false) end
        if key == \\"Hit\\" then return CFrame.new(0, 0, -10) end
        if key == \\"Origin\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Target\\" then return createProxyObject(\\"Target\\", false, proxy) end
        if key == \\"X\\" or key == \\"Y\\" then return 0 end
        if key == \\"UnitRay\\" then return Ray.new(Vector3.new(0, 5, 0), Vector3.new(0, 0, -1)) end
        if key == \\"ViewSizeX\\" then return 1920 end
        if key == \\"ViewSizeY\\" then return 1080 end
        if key == \\"Text\\" or key == \\"PlaceholderText\\" or key == \\"ContentText\\" or key == \\"Value\\" then
            if inputKey then return inputKey end
            if key == \\"Value\\" then return \\"input\\" end
            return '\\"'
        end
        if key == \\"TextBounds\\" then return Vector2.new(0, 0) end
        if key == \\"Font\\" then return createProxyObject(\\"Enum.Font.SourceSans\\", false) end
        if key == \\"TextSize\\" then return 14 end
        if key == \\"Image\\" or key == \\"ImageContent\\" then return '\\"' end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        local signalNames = {\\"Changed\\", \\"ChildAdded\\", \\"ChildRemoved\\", \\"DescendantAdded\\", \\"DescendantRemoving\\", \\"Touched\\", \\"TouchEnded\\", \\"InputBegan\\", \\"InputEnded\\", \\"InputChanged\\", \\"MouseButton1Click\\", \\"MouseButton1Down\\", \\"MouseButton1Up\\", \\"MouseButton2Click\\", \\"MouseButton2Down\\", \\"MouseButton2Up\\", \\"MouseEnter\\", \\"MouseLeave\\", \\"MouseMoved\\", \\"MouseWheelForward\\", \\"MouseWheelBackward\\", \\"Activated\\", \\"Deactivated\\", \\"FocusLost\\", \\"FocusGained\\", \\"Focused\\", \\"Heartbeat\\", \\"RenderStepped\\", \\"Stepped\\", \\"CharacterAdded\\", \\"CharacterRemoving\\", \\"CharacterAppearanceLoaded\\", \\"PlayerAdded\\", \\"PlayerRemoving\\", \\"AncestryChanged\\", \\"AttributeChanged\\", \\"Died\\", \\"FreeFalling\\", \\"GettingUp\\", \\"Jumping\\", \\"Running\\", \\"Seated\\", \\"Swimming\\", \\"StateChanged\\", \\"HealthChanged\\", \\"MoveToFinished\\", \\"OnClientEvent\\", \\"OnServerEvent\\", \\"OnClientInvoke\\", \\"OnServerInvoke\\", \\"Completed\\", \\"DidLoop\\", \\"Stopped\\", \\"CaptureBegan\\", \\"Button1Down\\", \\"Button1Up\\", \\"Button2Down\\", \\"Button2Up\\", \\"Idle\\", \\"Move\\", \\"TextChanged\\", \\"ReturnPressedFromOnScreenKeyboard\\", \\"Triggered\\", \\"TriggerEnded\\", \\"Error\\", \\"Event\\", \\"AxisChanged\\", \\"JumpRequest\\", \\"DevTouchMovementModeChanged\\", \\"DevComputerMovementModeChanged\\", \\"GraphicsQualityChangeRequest\\", \\"MenuOpened\\", \\"MenuClosed\\", \\"PointerAction\\", \\"TouchStarted\\", \\"TouchMoved\\", \\"TouchEnded\\", \\"TouchTap\\", \\"TouchLongPress\\", \\"TouchPinch\\", \\"TouchRotate\\", \\"TouchSwipe\\", \\"GamepadConnected\\", \\"GamepadDisconnected\\", \\"WindowFocused\\", \\"WindowFocusReleased\\"}
        for _, sig in ipairsFunction(signalNames) do
            if key == sig then
                local sigProxy = createProxyObject(pathName .. \\".\\" .. key, false, nil)
                dumperState.registry[sigProxy] = pathName .. \\".\\" .. key
                _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
                _at.signalOwner = _at.signalOwner or {}
                _at.signalOwner[sigProxy] = proxy  -- track owner without triggering _setParent
                return sigProxy
            end
        end
        return createProxyMethod(propertyName, proxy)
    end
    meta.__newindex = function(tbl, key, val)
        if key == proxyList or key == \\"__proxy_id\\" then
            rawset(tbl, key, val)
            return
        end
        -- locked: never allow mutation regardless of method
        local _lockedProps = {PlaceId=true, placeId=true, GameId=true, gameId=true, UniverseId=true}
        if _lockedProps[key] then return end
        -- read-only properties: error like real Roblox does
        local _readOnlyProps = {
            PlaybackLoudness = true,
            AbsolutePosition = true,
            AbsoluteSize = true,
            AbsoluteRotation = true,
            TextBounds = true,
            ContentText = true,
            SimulationRadius = true,
            MaxSimulationRadius = true,
            RootPriority = true,
            NativeIndex = true,
            ReceiveAge = true,
            AssemblyAngularVelocity = true,
            AssemblyLinearVelocity = true,
            AssemblyMass = true,
            AssemblyRootPart = true,
            CurrentCamera = true,
            PrivateServerOwnerId = true,
            PrivateServerId = true,
            JobId = true,
            PlaceId = true,
            GameId = true,
            PlaceVersion = true,
            UserId = true,
            FloorMaterial = true,
            MoveDirection = true,
            SeatPart = true,
        }
        if _readOnlyProps[key] then
            errorFunction(toStringFunction(key) .. \\" is not a valid member of \\" .. (dumperState.registry[proxy] or formattedName or \\"Instance\\"), 2)
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local prop = formatValue(key)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][key] = val
        local _cls2 = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if key == \\"CameraMinZoomDistance\\" then
            local n = tonumber(val) or 0; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif key == \\"CameraMaxZoomDistance\\" then
            local n = tonumber(val) or 400; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif _cls2 == \\"Terrain\\" and key == \\"WaterWaveSpeed\\" then
            local n = tonumber(val) or 100; if n > 100 then n = 100 end; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        end
        if key == \\"Parent\\" then
            _setParent(proxy, isProxy(val) and val or nil)
        end
        local className = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if className == \\"WeldConstraint\\" or className == \\"Weld\\" or className == \\"Motor6D\\" then
            if key == \\"Part0\\" or key == \\"Part1\\" then
                _at.weldRegistry[proxy] = _at.weldRegistry[proxy] or {}
                _at.weldRegistry[proxy][key] = val
                local wr = _at.weldRegistry[proxy]
                if wr.Part0 and wr.Part1 then
                    local cf0 = (dumperState.property_store[wr.Part0] or {}).CFrame
                    local cf1 = (dumperState.property_store[wr.Part1] or {}).CFrame
                    if cf0 and cf1 then
                        wr.offset = {X = (cf1.X or 0) - (cf0.X or 0), Y = (cf1.Y or 0) - (cf0.Y or 0), Z = (cf1.Z or 0) - (cf0.Z or 0)}
                    end
                end
            end
        end
        if key == \\"CFrame\\" then
            local cfVal = val
            local cfX = (cfVal and cfVal.X) or 0
            local cfY = (cfVal and cfVal.Y) or 0
            local cfZ = (cfVal and cfVal.Z) or 0
            for _, wr in pairs(_at.weldRegistry) do
                if wr.Part0 == proxy and wr.Part1 and wr.offset then
                    local nx = cfX + wr.offset.X
                    local ny = cfY + wr.offset.Y
                    local nz = cfZ + wr.offset.Z
                    local newCF
                    if type(CFrame) == \\"table\\" and type(CFrame.new) == \\"function\\" then
                        newCF = CFrame.new(nx, ny, nz)
                    elseif _makeCFrame then
                        newCF = _makeCFrame(nx, ny, nz)
                    else
                        newCF = {X = nx, Y = ny, Z = nz, Position = {X = nx, Y = ny, Z = nz}}
                    end
                    dumperState.property_store[wr.Part1] = dumperState.property_store[wr.Part1] or {}
                    dumperState.property_store[wr.Part1].CFrame = newCF
                    local posV = newCF.Position
                    dumperState.property_store[wr.Part1].Position = posV
                end
            end
        end
        emitOutput(string.format(\\"%s.%s = %s\\", pathName, prop, serializeValue(val)))
    end
    meta.__call = function(tbl, ...)
        local pathName = dumperState.registry[proxy] or formattedName or \\"func\\"
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName:match(\\"env\\") then
            return proxy
        end
        if pathName == \\"game\\" then
            errorFunction(\\"attempt to call an Instance value\\", 0)
        end
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"result\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s(%s)\\", varName, pathName, table.concat(serializedArgs, \\", \\")))
        return resultProxy
    end
    local function operatorMeta(opSymbol)
        local function metaCall(a, b)
            local proxy, meta = createProxy()
            local strA = \\"0\\"
            if a ~= nil then strA = dumperState.registry[a] or serializeValue(a) end
            local strB = \\"0\\"
            if b ~= nil then strB = dumperState.registry[b] or serializeValue(b) end
            local expression = \\"(\\" .. strA .. \\" \\" .. opSymbol .. \\" \\" .. strB .. \\")\\"
            dumperState.registry[proxy] = expression
            meta.__tostring = function() return expression end
            meta.__call = function() return proxy end
            meta.__index = function(_, k)
                if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
            end
            meta.__add = operatorMeta(\\"+\\")
            meta.__sub = operatorMeta(\\"-\\")
            meta.__mul = operatorMeta(\\"*\\")
            meta.__div = operatorMeta(\\"/\\")
            meta.__mod = operatorMeta(\\"%\\")
            meta.__pow = operatorMeta(\\"^\\")
            meta.__concat = operatorMeta(\\"..\\")
            meta.__eq = function() return false end
            meta.__lt = function() return false end
            meta.__le = function() return false end
            return proxy
        end
        return metaCall
    end
    meta.__add = operatorMeta(\\"+\\")
    meta.__sub = operatorMeta(\\"-\\")
    meta.__mul = operatorMeta(\\"*\\")
    meta.__div = operatorMeta(\\"/\\")
    meta.__mod = operatorMeta(\\"%\\")
    meta.__pow = operatorMeta(\\"^\\")
    meta.__concat = operatorMeta(\\"..\\")
    meta.__eq = function(a, b) return rawequal(a, b) end
    meta.__lt = function() return false end
    meta.__le = function() return false end
    meta.__unm = function(a)
        local proxy, meta = createProxy()
        dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
        meta.__tostring = function() return dumperState.registry[proxy] end
        return proxy
    end
    meta.__len = function() return 0 end
    meta.__tostring = function() return dumperState.registry[proxy] or formattedName or \\"Object\\" end
    meta.__pairs = function() return function() return nil end, proxy, nil end
    meta.__ipairs = meta.__pairs
    return proxy
end
local function createTypeDa(typeName, methods)
    local dc = {}
    local dd = {}
    dd.__index = function(_, key)
        if key == \\"new\\" or methods and methods[key] then
            return function(...)
                local args = {...}
                local serializedArgs = {}
                for _, val in ipairsFunction(args) do
                    table.insert(serializedArgs, serializeValue(val))
                end
                local expression = typeName .. \\".\\" .. key .. \\"(\\" .. table.concat(serializedArgs, \\", \\") .. \\")\\"
                local proxy, meta = createProxy()
                dumperState.registry[proxy] = expression
                meta.__tostring = function() return expression end
                meta.__index = function(_, k)
                    if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                    if k == \\"X\\" or k == \\"Y\\" or k == \\"Z\\" or k == \\"W\\" then return 0 end
                    if k == \\"Magnitude\\" then return 0 end
                    if k == \\"Unit\\" or k == \\"Position\\" or k == \\"CFrame\\" or k == \\"LookVector\\" or k == \\"RightVector\\" or k == \\"UpVector\\" or k == \\"Rotation\\" or k == \\"p\\" then return proxy end
                    if k == \\"R\\" or k == \\"G\\" or k == \\"B\\" then return 1 end
                    if k == \\"Width\\" or k == \\"Height\\" then return UDim.new(0, 0) end
                    if k == \\"Min\\" or k == \\"Max\\" or k == \\"Scale\\" or k == \\"Offset\\" then return 0 end
                    return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
                end
                local function opMeta(symbol)
                    return function(a, b)
                        local proxy, meta = createProxy()
                        local expr = \\"(\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\" \\" .. symbol .. \\" \\" .. (dumperState.registry[b] or serializeValue(b)) .. \\")\\"
                        dumperState.registry[proxy] = expr
                        meta.__tostring = function() return expr end
                        meta.__index = meta.__index
                        meta.__add = opMeta(\\"+\\")
                        meta.__sub = opMeta(\\"-\\")
                        meta.__mul = opMeta(\\"*\\")
                        meta.__div = opMeta(\\"/\\")
                        return proxy
                    end
                end
                meta.__add = opMeta(\\"+\\")
                meta.__sub = opMeta(\\"-\\")
                meta.__mul = opMeta(\\"*\\")
                meta.__div = opMeta(\\"/\\")
                meta.__unm = function(a)
                    local proxy, meta = createProxy()
                    dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
                    meta.__tostring = function() return dumperState.registry[proxy] end
                    return proxy
                end
                meta.__eq = function() return false end
                meta.__typeof = typeName
                return proxy
            end
        end
        return nil
    end
    dd.__call = function(_, ...) return _.new(...) end
    return setmetatable(dc, dd)
end
Vector3 = createTypeDa(\\"Vector3\\", {new = true, zero = true, one = true})
Vector2 = createTypeDa(\\"Vector2\\", {new = true, zero = true, one = true})
UDim = createTypeDa(\\"UDim\\", {new = true})
UDim2 = createTypeDa(\\"UDim2\\", {new = true, fromScale = true, fromOffset = true})
CFrame = createTypeDa(\\"CFrame\\", {new = true, Angles = true, lookAt = true, fromEulerAnglesXYZ = true, fromEulerAnglesYXZ = true, fromAxisAngle = true, fromMatrix = true, fromOrientation = true, identity = true})
Color3 = createTypeDa(\\"Color3\\", {new = true, fromRGB = true, fromHSV = true, fromHex = true})
BrickColor = createTypeDa(\\"BrickColor\\", {new = true, random = true, White = true, Black = true, Red = true, Blue = true, Green = true, Yellow = true, palette = true})
TweenInfo = createTypeDa(\\"TweenInfo\\", {new = true})
Rect = createTypeDa(\\"Rect\\", {new = true})
Region3 = createTypeDa(\\"Region3\\", {new = true})
Region3int16 = createTypeDa(\\"Region3int16\\", {new = true})
Ray = createTypeDa(\\"Ray\\", {new = true})
NumberRange = createTypeDa(\\"NumberRange\\", {new = true})
NumberSequence = createTypeDa(\\"NumberSequence\\", {new = true})
NumberSequenceKeypoint = createTypeDa(\\"NumberSequenceKeypoint\\", {new = true})
ColorSequence = createTypeDa(\\"ColorSequence\\", {new = true})
ColorSequence.new = function(...)
    local args = {...}
    local keypoints = {}
    if #args == 1 and typeFunction(args[1]) == \\"table\\" and args[1][1] ~= nil then
        keypoints = args[1]
    elseif #args == 1 then
        keypoints = {args[1], args[1]}
    elseif #args >= 2 then
        keypoints = args
    end
    local t = setmetatable({Keypoints = keypoints}, {
        __typeof = \\"ColorSequence\\",
        __tostring = function() return \\"ColorSequence\\" end,
    })
    return t
end
ColorSequenceKeypoint = createTypeDa(\\"ColorSequenceKeypoint\\", {new = true})
PhysicalProperties = createTypeDa(\\"PhysicalProperties\\", {new = true})
Font = createTypeDa(\\"Font\\", {new = true, fromEnum = true, fromName = true, fromId = true})
RaycastParams = createTypeDa(\\"RaycastParams\\", {new = true})
OverlapParams = {new = function()
        local params = {MaxParts = 0, FilterType = Enum.RaycastFilterType.Exclude, FilterDescendantsInstances = {}}
        return setmetatable(params, {__typeof = \\"OverlapParams\\"})
    end}
_makeVector3 = function(x, y, z, expr)
    x, y, z = toNumberFunction(x) or 0, toNumberFunction(y) or 0, toNumberFunction(z) or 0
    local proxy, meta = createProxy()
    local expression = expr or (\\"Vector3.new(\\" .. serializeValue(x) .. \\", \\" .. serializeValue(y) .. \\", \\" .. serializeValue(z) .. \\")\\")
    dumperState.registry[proxy] = expression
    _at.vectors[proxy] = {x = x, y = y, z = z}
    local function component(v, axis)
        local data = _at.vectors[v]
        if not data then return 0 end
        return axis == \\"X\\" and data.x or axis == \\"Y\\" and data.y or data.z
    end
    local function binary(a, b, symbol)
        local ax, ay, az = component(a, \\"X\\"), component(a, \\"Y\\"), component(a, \\"Z\\")
        local bx, by, bz
        if typeFunction(b) == \\"number\\" then bx, by, bz = b, b, b else bx, by, bz = component(b, \\"X\\"), component(b, \\"Y\\"), component(b, \\"Z\\") end
        if symbol == \\"+\\" then return _makeVector3(ax + bx, ay + by, az + bz, \\"(\\" .. serializeValue(a) .. \\" + \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"-\\" then return _makeVector3(ax - bx, ay - by, az - bz, \\"(\\" .. serializeValue(a) .. \\" - \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"*\\" then return _makeVector3(ax * bx, ay * by, az * bz, \\"(\\" .. serializeValue(a) .. \\" * \\" .. serializeValue(b) .. \\")\\") end
        return _makeVector3(bx ~= 0 and ax / bx or 0, by ~= 0 and ay / by or 0, bz ~= 0 and az / bz or 0, \\"(\\" .. serializeValue(a) .. \\" / \\" .. serializeValue(b) .. \\")\\")
    end
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(proxy, key) end
        if key == \\"X\\" then return x end
        if key == \\"Y\\" then return y end
        if key == \\"Z\\" then return z end
        if key == \\"Magnitude\\" then return math.sqrt(x * x + y * y + z * z) end
        if key == \\"Unit\\" then
            local mag = math.sqrt(x * x + y * y + z * z)
            if mag == 0 then return _makeVector3(0, 0, 0, expression .. \\".Unit\\") end
            return _makeVector3(x / mag, y / mag, z / mag, expression .. \\".Unit\\")
        end
        if key == \\"Dot\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return x * ox + y * oy + z * oz
            end
        end
        if key == \\"Cross\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return _makeVector3(y*oz - z*oy, z*ox - x*oz, x*oy - y*ox)
            end
        end
        if key == \\"Lerp\\" then
            return function(self, other, alpha)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                local a = toNumberFunction(alpha) or 0
                return _makeVector3(x + (ox-x)*a, y + (oy-y)*a, z + (oz-z)*a)
            end
        end
        if key == \\"FuzzyEq\\" then
            return function(self, other, epsilon)
                local eps = toNumberFunction(epsilon) or 1e-5
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return math.abs(x-ox) <= eps and math.abs(y-oy) <= eps and math.abs(z-oz) <= eps
            end
        end
        return 0
    end
    meta.__add = function(a, b) return binary(a, b, \\"+\\") end
    meta.__sub = function(a, b) return binary(a, b, \\"-\\") end
    meta.__mul = function(a, b) return binary(a, b, \\"*\\") end
    meta.__div = function(a, b) return binary(a, b, \\"/\\") end
    meta.__unm = function(a) return _makeVector3(-component(a, \\"X\\"), -component(a, \\"Y\\"), -component(a, \\"Z\\"), \\"(-\\" .. serializeValue(a) .. \\")\\") end
    meta.__eq = function(a, b) return component(a, \\"X\\") == component(b, \\"X\\") and component(a, \\"Y\\") == component(b, \\"Y\\") and component(a, \\"Z\\") == component(b, \\"Z\\") end
    meta.__tostring = function() return toStringFunction(x) .. \\", \\" .. toStringFunction(y) .. \\", \\" .. toStringFunction(z) end
    return proxy
end
Vector3 = {
    new = function(x, y, z) return _makeVector3(x, y, z) end,
    zero = _makeVector3(0, 0, 0, \\"Vector3.zero\\"),
    one = _makeVector3(1, 1, 1, \\"Vector3.one\\"),
    fromNormalId = function(normalId)
        local name = toStringFunction(normalId)
        if name:find(\\"Right\\")  then return _makeVector3( 1,  0,  0) end
        if name:find(\\"Left\\")   then return _makeVector3(-1,  0,  0) end
        if name:find(\\"Top\\")    then return _makeVector3( 0,  1,  0) end
        if name:find(\\"Bottom\\") then return _makeVector3( 0, -1,  0) end
        if name:find(\\"Back\\")   then return _makeVector3( 0,  0,  1) end
        if name:find(\\"Front\\")  then return _makeVector3( 0,  0, -1) end
        return _makeVector3(0, 0, 0)
    end,
    fromAxis = function(axis)
        local name = toStringFunction(axis)
        if name:find(\\"X\\") then return _makeVector3(1, 0, 0) end
        if name:find(\\"Y\\") then return _makeVector3(0, 1, 0) end
        if name:find(\\"Z\\") then return _makeVector3(0, 0, 1) end
        return _makeVector3(0, 0, 0)
    end,
}
setmetatable(Vector3, {__call = function(_, x, y, z) return _.new(x, y, z) end})
local function _valueType(typeName, fields, methods)
    local obj = fields or {}
    return setmetatable(obj, {
        __typeof = typeName,
        __index = methods or {},
        __tostring = function() return typeName end,
        __eq = function(a, b)
            if typeFunction(a) ~= \\"table\\" or typeFunction(b) ~= \\"table\\" then return false end
            local ma, mb = getMetatableFunction(a), getMetatableFunction(b)
            if not ma or not mb or ma.__typeof ~= mb.__typeof then return false end
            for k, v in pairsFunction(a) do
                if b[k] ~= v then return false end
            end
            for k, v in pairsFunction(b) do
                if a[k] ~= v then return false end
            end
            return true
        end
    })
end
local function _num(v, default) return toNumberFunction(v) or default or 0 end
local function _makeVector2(x, y)
    x, y = _num(x), _num(y)
    local methods = {}
    function methods:Dot(other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) end
    local mt
    mt = {
        __typeof = \\"Vector2\\",
        __index = function(self, key)
            if key == \\"Magnitude\\" then return math.sqrt(self.X * self.X + self.Y * self.Y) end
            if key == \\"Unit\\" then
                local mag = math.sqrt(self.X * self.X + self.Y * self.Y)
                return mag == 0 and _makeVector2(0, 0) or _makeVector2(self.X / mag, self.Y / mag)
            end
            return methods[key]
        end,
        __add = function(a, b) return _makeVector2(a.X + b.X, a.Y + b.Y) end,
        __sub = function(a, b) return _makeVector2(a.X - b.X, a.Y - b.Y) end,
        __mul = function(a, b)
            if typeFunction(a) == \\"number\\" then return _makeVector2(a * b.X, a * b.Y) end
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X * b, a.Y * b) end
            return _makeVector2(a.X * b.X, a.Y * b.Y)
        end,
        __div = function(a, b)
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X / b, a.Y / b) end
            return _makeVector2(a.X / b.X, a.Y / b.Y)
        end,
        __unm = function(a) return _makeVector2(-a.X, -a.Y) end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y end,
        __tostring = function(a) return (\\"Vector2.new(%s, %s)\\"):format(a.X, a.Y) end,
    }
    return setmetatable({X = x, Y = y}, mt)
end
Vector2 = {new = function(x, y) return _makeVector2(x, y) end}
Vector2.zero = Vector2.new(0, 0)
Vector2.one = Vector2.new(1, 1)
setmetatable(Vector2, {__call = function(_, x, y) return _.new(x, y) end})
local _oldVector3New = Vector3.new
Vector3.new = function(x, y, z)
    local v = _oldVector3New(x, y, z)
    local mt = getMetatableFunction(v)
    local oldIndex = mt.__index
    mt.__index = function(self, key)
        if key == \\"Dot\\" then
            return function(_, other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) + self.Z * (other and other.Z or 0) end
        end
        if key == \\"Cross\\" then
            return function(_, other)
                return Vector3.new(
                    self.Y * (other and other.Z or 0) - self.Z * (other and other.Y or 0),
                    self.Z * (other and other.X or 0) - self.X * (other and other.Z or 0),
                    self.X * (other and other.Y or 0) - self.Y * (other and other.X or 0)
                )
            end
        end
        return oldIndex(self, key)
    end
    return v
end
Vector3.zero = Vector3.new(0, 0, 0)
Vector3.one = Vector3.new(1, 1, 1)
UDim = {new = function(scale, offset) return _valueType(\\"UDim\\", {Scale = _num(scale), Offset = _num(offset)}) end}
setmetatable(UDim, {__call = function(_, scale, offset) return _.new(scale, offset) end})
UDim2 = {
    new = function(xs, xo, ys, yo) return _valueType(\\"UDim2\\", {X = UDim.new(xs, xo), Y = UDim.new(ys, yo)}) end,
    fromScale = function(x, y) return UDim2.new(x, 0, y, 0) end,
    fromOffset = function(x, y) return UDim2.new(0, x, 0, y) end,
}
setmetatable(UDim2, {__call = function(_, ...) return _.new(...) end})
Color3 = {
    new = function(r, g, b)
        local rv, gv, bv = _num(r), _num(g), _num(b)
        if rv < 0 or rv > 1 or gv < 0 or gv > 1 or bv < 0 or bv > 1 then
            errorFunction(\\"R, G, and B must each be in the range [0, 1]\\", 2)
        end
        return setmetatable({R = rv, G = gv, B = bv}, {
            __typeof = \\"Color3\\",
            __tostring = function(self) return string.format(\\"[R:%g, G:%g, B:%g]\\", self.R, self.G, self.B) end,
            __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.R == b.R and a.G == b.G and a.B == b.B end,
        })
    end,
    fromRGB = function(r, g, b) return Color3.new(_num(r) / 255, _num(g) / 255, _num(b) / 255) end,
    fromHSV = function(h, s, v) return Color3.new(v or 1, v or 1, v or 1) end,
    fromHex = function(hex) return Color3.fromRGB(255, 255, 255) end,
}
setmetatable(Color3, {__call = function(_, ...) return _.new(...) end})
BrickColor = {
    new = function(name)
        name = formatValue(name or \\"Medium stone grey\\")
        return _valueType(\\"BrickColor\\", {Name = name, Number = 1, Color = Color3.fromRGB(255, 0, 0)})
    end,
    random = function() return BrickColor.new(\\"Medium stone grey\\") end,
}
setmetatable(BrickColor, {__call = function(_, ...) return _.new(...) end})
NumberRange = {new = function(min, max) return _valueType(\\"NumberRange\\", {Min = _num(min), Max = max ~= nil and _num(max) or _num(min)}) end}
NumberSequence = {new = function(value) return _valueType(\\"NumberSequence\\", {Keypoints = typeFunction(value) == \\"table\\" and value or {{Time = 0, Value = _num(value)}, {Time = 1, Value = _num(value)}}}) end}
TweenInfo = {new = function(timeValue, style, direction, repeatCount, reverses, delayTime) return _valueType(\\"TweenInfo\\", {Time = _num(timeValue), EasingStyle = style or Enum.EasingStyle.Quad, EasingDirection = direction or Enum.EasingDirection.Out, RepeatCount = repeatCount or 0, Reverses = reverses or false, DelayTime = delayTime or 0}) end}
Ray = {new = function(origin, direction) return _valueType(\\"Ray\\", {Origin = origin or Vector3.zero, Direction = direction or Vector3.new(0, 0, -1)}) end}
Rect = {new = function(a, b, c, d)
    local minV = typeFunction(a) == \\"table\\" and a or Vector2.new(a, b)
    local maxV = typeFunction(c) == \\"table\\" and c or Vector2.new(c, d)
    return _valueType(\\"Rect\\", {Min = minV, Max = maxV, Width = maxV.X - minV.X, Height = maxV.Y - minV.Y})
end}
Region3 = {new = function(minVec, maxVec)
    local mn = minVec or Vector3.new(0,0,0)
    local mx = maxVec or Vector3.new(0,0,0)
    local sz = Vector3.new(mx.X - mn.X, mx.Y - mn.Y, mx.Z - mn.Z)
    return _valueType(\\"Region3\\", {CFrame = CFrame.new((mn.X+mx.X)/2,(mn.Y+mx.Y)/2,(mn.Z+mx.Z)/2), Size = sz})
end}
PhysicalProperties = {new = function(density, friction, elasticity, frictionWeight, elasticityWeight) return _valueType(\\"PhysicalProperties\\", {Density = _num(density, 1), Friction = _num(friction, 0.3), Elasticity = _num(elasticity, 0.5), FrictionWeight = _num(frictionWeight, 1), ElasticityWeight = _num(elasticityWeight, 1)}) end}
_makeCFrame = function(x, y, z)
    local ox, oy, oz = _num(x), _num(y), _num(z)
    local obj = {X = ox, Y = oy, Z = oz}
    obj.Position = Vector3.new(ox, oy, oz)
    obj.p = obj.Position
    obj.LookVector = Vector3.new(0, 0, -1)
    obj.RightVector = Vector3.new(1, 0, 0)
    obj.UpVector = Vector3.new(0, 1, 0)
    obj.Inverse = function(self) return _makeCFrame(-ox, -oy, -oz) end
    obj.ToObjectSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox2 - ox, oy2 - oy, oz2 - oz)
    end
    obj.ToWorldSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox + ox2, oy + oy2, oz + oz2)
    end
    obj.PointToObjectSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) - ox,
            (point and point.Y or 0) - oy,
            (point and point.Z or 0) - oz
        )
    end
    obj.PointToWorldSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) + ox,
            (point and point.Y or 0) + oy,
            (point and point.Z or 0) + oz
        )
    end
    return setmetatable(obj, {
        __typeof = \\"CFrame\\",
        __index = function(self, key) return rawget(self, key) end,
        __mul = function(a, b)
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"CFrame\\" then
                return _makeCFrame(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"Vector3\\" then
                return Vector3.new(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            return a
        end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y and a.Z == b.Z end,
        __tostring = function(a) return (\\"CFrame.new(%s, %s, %s)\\"):format(a.X, a.Y, a.Z) end,
    })
end
CFrame = {
    new = function(x, y, z) return _makeCFrame(x, y, z) end,
    Angles = function() return _makeCFrame(0, 0, 0) end,
    lookAt = function(origin, target) return _makeCFrame(origin and origin.X or 0, origin and origin.Y or 0, origin and origin.Z or 0) end,
    LookAt = function(origin, target) return CFrame.lookAt(origin, target) end,
    fromEulerAnglesXYZ = function() return _makeCFrame(0, 0, 0) end,
    fromEulerAnglesYXZ = function() return _makeCFrame(0, 0, 0) end,
    fromAxisAngle = function() return _makeCFrame(0, 0, 0) end,
    fromMatrix = function(pos) return _makeCFrame(pos and pos.X or 0, pos and pos.Y or 0, pos and pos.Z or 0) end,
    fromOrientation = function() return _makeCFrame(0, 0, 0) end,
}
CFrame.identity = CFrame.new(0, 0, 0)
setmetatable(CFrame, {__call = function(_, ...) return _.new(...) end})
PathWaypoint = createTypeDa(\\"PathWaypoint\\", {new = true})
Axes = createTypeDa(\\"Axes\\", {new = true})
Faces = createTypeDa(\\"Faces\\", {new = true})
Vector3int16 = createTypeDa(\\"Vector3int16\\", {new = true})
Vector2int16 = createTypeDa(\\"Vector2int16\\", {new = true})
CatalogSearchParams = createTypeDa(\\"CatalogSearchParams\\", {new = true})
DateTime = {
    now = function()
        return DateTime.fromUnixTimestamp(os.time())
    end,
    fromUnixTimestamp = function(ts)
        ts = toNumberFunction(ts) or 0
        local dt = setmetatable({UnixTimestamp = ts, UnixTimestampMillis = ts * 1000}, {
            __typeof = \\"DateTime\\",
            __index = function(self, key)
                if key == \\"UnixTimestamp\\" then return ts end
                if key == \\"UnixTimestampMillis\\" then return ts * 1000 end
                if key == \\"FormatUniversalTime\\" then
                    return function(self2, fmt, locale)
                        -- convert unix timestamp to date components
                        local t = os.date(\\"!*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"FormatLocalTime\\" then
                    return function(self2, fmt, locale)
                        local t = os.date(\\"*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"ToIsoDate\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return string.format(\\"%04d-%02d-%02dT%02d:%02d:%02dZ\\", t.year, t.month, t.day, t.hour, t.min, t.sec)
                    end
                end
                if key == \\"ToUniversalTime\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return {Year=t.year,Month=t.month,Day=t.day,Hour=t.hour,Minute=t.min,Second=t.sec,Millisecond=0}
                    end
                end
            end,
        })
        return dt
    end,
    fromUnixTimestampMillis = function(ms)
        return DateTime.fromUnixTimestamp(math.floor((toNumberFunction(ms) or 0) / 1000))
    end,
    fromIsoDate = function(iso)
        return DateTime.fromUnixTimestamp(0)
    end,
}
Random = {new = function(seed)
        local obj = {}
        function obj:NextNumber(min, max) return (min or 0) + 0.5 * ((max or 1) - (min or 0)) end
        function obj:NextInteger(min, max) return math.floor((min or 1) + 0.5 * ((max or 100) - (min or 1))) end
        function obj:NextUnitVector() return Vector3.new(0.577, 0.577, 0.577) end
        function obj:Shuffle(tab) return tab end
        function obj:Clone() return Random.new() end
        return obj
    end}
setmetatable(Random, {__call = function(_, seed) return _.new(seed) end})
Enum = createProxyObject(\\"Enum\\", true)
local enumMeta = debugLibrary.getmetatable(Enum)
enumMeta.__index = function(_, key)
    if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
    local enumName = \\"Enum.\\" .. formatValue(key)
    if not _at.enum[enumName] then
        local enumProxy = createProxyObject(enumName, false)
        dumperState.registry[enumProxy] = enumName
        _at.enum[enumName] = enumProxy
    end
    return _at.enum[enumName]
end
Instance = {new = function(className, parent)
        local name = formatValue(className)
        local _validClasses = {
            Part=1,MeshPart=1,UnionOperation=1,SpecialMesh=1,BlockMesh=1,CylinderMesh=1,
            Model=1,Folder=1,Tool=1,LocalScript=1,Script=1,ModuleScript=1,
            RemoteEvent=1,RemoteFunction=1,BindableEvent=1,BindableFunction=1,
            Frame=1,ScreenGui=1,SurfaceGui=1,BillboardGui=1,TextLabel=1,TextButton=1,
            TextBox=1,ImageLabel=1,ImageButton=1,ScrollingFrame=1,ViewportFrame=1,
            UIListLayout=1,UIGridLayout=1,UITableLayout=1,UIPadding=1,UICorner=1,
            UIStroke=1,UIScale=1,UIAspectRatioConstraint=1,UISizeConstraint=1,
            UITextSizeConstraint=1,UIFlexItem=1,UIGradient=1,UIPageLayout=1,
            Humanoid=1,HumanoidDescription=1,Animator=1,Animation=1,
            Sound=1,SoundGroup=1,Attachment=1,Motor6D=1,Weld=1,WeldConstraint=1,
            BallSocketConstraint=1,HingeConstraint=1,SpringConstraint=1,RodConstraint=1,
            RopeConstraint=1,AlignPosition=1,AlignOrientation=1,
            ForceField=1,Decal=1,Texture=1,SelectionBox=1,SelectionSphere=1,
            PointLight=1,SpotLight=1,SurfaceLight=1,Sky=1,Atmosphere=1,Clouds=1,
            Beam=1,Trail=1,ParticleEmitter=1,Fire=1,Smoke=1,Sparkles=1,
            Camera=1,Backpack=1,Hat=1,Accessory=1,Shirt=1,Pants=1,ShirtGraphic=1,
            CharacterMesh=1,BodyColors=1,
            IntValue=1,StringValue=1,BoolValue=1,NumberValue=1,Vector3Value=1,
            CFrameValue=1,Color3Value=1,ObjectValue=1,RayValue=1,BrickColorValue=1,
            ClickDetector=1,ProximityPrompt=1,Dialog=1,DialogChoice=1,
            SpawnLocation=1,SeatPart=1,VehicleSeat=1,
            WedgePart=1,CornerWedgePart=1,TrussPart=1,
            IntersectOperation=1,NegateOperation=1,
            PathfindingLink=1,PathfindingModifier=1,
            Configuration=1,LocalizationTable=1,
            NoCollisionConstraint=1,RigidConstraint=1,
            EditableMesh=1,EditableImage=1,
            LinearVelocity=1,AngularVelocity=1,LineForce=1,VectorForce=1,Torque=1,
            SurfaceAppearance=1,SpecialMesh=1,SelectionBox=1,
        }
        if not _validClasses[name] then
            errorFunction(\\"Unable to create an Instance of type \\\"\\" .. name .. \\"\\\"\\", 2)
        end
        local proxy = createProxyObject(name, false)
        local varName = registerVariable(proxy, name)
        -- class-specific default properties
        local _classDefaults = {
            SkateboardController = {Steer=0, Throttle=0},
            BallSocketConstraint = {LimitsEnabled=false, UpperAngle=45, TwistLimitsEnabled=false, TwistLowerAngle=-45, TwistUpperAngle=45, MaxFrictionTorque=0, Restitution=0},
            HingeConstraint     = {LimitsEnabled=false, UpperAngle=45, LowerAngle=-45, AngularVelocity=0, MotorMaxTorque=0, Restitution=0},
            SpringConstraint    = {Coilcount=5, Damping=1, FreeLength=5, LimitsEnabled=false, MaxLength=5, MinLength=0, Stiffness=100, Visible=false},
            RodConstraint       = {Length=5, LimitAngle0=0, LimitAngle1=0},
            RopeConstraint      = {Length=5},
            PrismaticConstraint = {LimitsEnabled=false, UpperLimit=5, LowerLimit=0, Velocity=0},
            TorsionSpringConstraint = {Damping=1, Stiffness=100, Restitution=0},
            WeldConstraint      = {},
            Motor6D             = {CurrentAngle=0, DesiredAngle=0, MaxVelocity=0},
            ForceField          = {Visible=true},
            Sound               = {Volume=0.5, PlaybackSpeed=1, TimePosition=0, IsPlaying=false, IsPaused=false, Looped=false, RollOffMaxDistance=10000, RollOffMinDistance=10},
            ScreenGui           = {Enabled=true, DisplayOrder=0, IgnoreGuiInset=false, ResetOnSpawn=true},
            Frame               = {BackgroundTransparency=0, BorderSizePixel=1, Visible=true, ZIndex=1, LayoutOrder=0},
            TextLabel           = {Text=\\"\\", TextTransparency=0, TextSize=14, TextWrapped=false, RichText=false, BackgroundTransparency=0, Visible=true, ZIndex=1},
            TextButton          = {Text=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, Modal=false},
            TextBox             = {Text=\\"\\", PlaceholderText=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, ClearTextOnFocus=true},
            ImageLabel          = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            ImageButton         = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            Part                = {Anchored=false, CanCollide=true, Locked=false, Transparency=0, Reflectance=0, Mass=1},
            MeshPart            = {Anchored=false, CanCollide=true, Transparency=0},
            Humanoid            = {Health=100, MaxHealth=100, WalkSpeed=16, JumpPower=50, JumpHeight=7.2, HipHeight=2, AutoRotate=true, PlatformStand=false},
            RemoteEvent         = {},
            RemoteFunction      = {},
            BindableEvent       = {},
            BindableFunction    = {},
            Animator            = {},
            LocalizationTable   = {SourceLocaleId=\\"en-us\\"},
            Animation           = {AnimationId=\\"\\"},
            Attachment          = {},
            AlignPosition       = {RigidityEnabled=false, MaxForce=1e6, MaxVelocity=1e6, Responsiveness=200},
            AlignOrientation    = {RigidityEnabled=false, MaxTorque=1e6, MaxAngularVelocity=1e6, Responsiveness=200},
            LinearVelocity      = {MaxForce=0, VectorVelocity=nil, VelocityConstraintMode=nil, Attachment0=nil},
            SurfaceAppearance   = {ColorMap=nil, NormalMap=nil, RoughnessMap=nil, MetalnessMap=nil},
        }
        local defaults = _classDefaults[name] or {}
        defaults.ClassName = name
        defaults.Name = name
        defaults.Archivable = true
        dumperState.property_store[proxy] = defaults
        if parent then
            local parentPath = dumperState.registry[parent] or serializeValue(parent)
            emitOutput(string.format(\\"local %s = Instance.new(%s, %s)\\", varName, formatStringLiteral(name), parentPath))
            _setParent(proxy, parent)
        else
            emitOutput(string.format(\\"local %s = Instance.new(%s)\\", varName, formatStringLiteral(name)))
        end
        return proxy
    end}
game = createProxyObject(\\"game\\", true)
workspace = createProxyObject(\\"workspace\\", true)
script = createProxyObject(\\"script\\", true)
dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
local function seedCoreRobloxInstances()
    dumperState.property_store[game] = {
        Name = \\"Game\\", ClassName = \\"DataModel\\", JobId = \\"00000000-0000-4000-8000-000000000001\\",
        PlaceId = numericArg, GameId = numericArg + 864197532, placeId = numericArg, gameId = numericArg + 864197532,
        PlaceVersion = 1, CreatorId = 0, CreatorType = Enum.CreatorType.User
    }
    dumperState.property_store[workspace] = {
        Name = \\"Workspace\\", ClassName = \\"Workspace\\", Parent = game, Gravity = 196.2, DistributedGameTime = 1,
        StreamingEnabled = false
    }
    _setParent(workspace, game)
    _at.svcCache.Workspace = workspace

    local players = _at.svcCache.Players or createProxyObject(\\"Players\\", false, game)
    _at.svcCache.Players = players
    dumperState.registry[players] = \\"Players\\"
    dumperState.property_store[players] = {Name = \\"Players\\", ClassName = \\"Players\\", Parent = game, MaxPlayers = 12, RespawnTime = 5}
    _setParent(players, game)

    local lp = _at.localPlayer or createProxyObject(\\"LocalPlayer\\", false, players)
    _at.localPlayer = lp
    dumperState.registry[lp] = \\"LocalPlayer\\"
    dumperState.property_store[lp] = {
        Name = \\"Player\\", ClassName = \\"Player\\", Parent = players, UserId = 1, DisplayName = \\"Player\\",
        MembershipType = Enum.MembershipType.None, FollowUserId = 0, AccountAge = 1000,
        CameraMinZoomDistance = 0, CameraMaxZoomDistance = 400,
        AutoJumpEnabled = true, Neutral = true, Team = nil, LocaleId = \\"en-us\\",
        SimulationRadius = 0, MaxSimulationRadius = 0,
    }
    _setParent(lp, players)

    local function ensureChild(parent, name, className, props)
        local child = createProxyObject(name, false, parent)
        dumperState.registry[child] = name
        props = props or {}
        props.Name = props.Name or name
        props.ClassName = props.ClassName or className or name
        props.Parent = parent
        dumperState.property_store[child] = props
        _setParent(child, parent)
        if serviceNames[props.ClassName] then
            _at.svcCache[props.ClassName] = child
        end
        return child
    end

    ensureChild(lp, \\"PlayerGui\\", \\"PlayerGui\\")
    ensureChild(lp, \\"Backpack\\", \\"Backpack\\")
    local playerScripts = ensureChild(lp, \\"PlayerScripts\\", \\"PlayerScripts\\")
    ensureChild(playerScripts, \\"PlayerModule\\", \\"ModuleScript\\")
    ensureChild(playerScripts, \\"RbxCharacterSounds\\", \\"LocalScript\\")
    ensureChild(workspace, \\"Camera\\", \\"Camera\\", {
        CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080),
        CameraType = Enum.CameraType.Custom, NearPlaneZ = -0.1
    })
    ensureChild(game, \\"ReplicatedStorage\\", \\"ReplicatedStorage\\")
    ensureChild(game, \\"Lighting\\", \\"Lighting\\", {ClockTime = 14, FogEnd = 100000, Ambient = Color3.fromRGB(128, 128, 128), OutdoorAmbient = Color3.fromRGB(128, 128, 128)})
    ensureChild(game, \\"SoundService\\", \\"SoundService\\", {RolloffScale = 1, AmbientReverb = Enum.ReverbType.NoReverb})
    ensureChild(game, \\"RunService\\", \\"RunService\\")
    ensureChild(game, \\"TweenService\\", \\"TweenService\\")
    ensureChild(game, \\"HttpService\\", \\"HttpService\\", {HttpEnabled = false})
    local networkClient = ensureChild(game, \\"NetworkClient\\", \\"NetworkClient\\")
    ensureChild(networkClient, \\"ClientReplicator\\", \\"ClientReplicator\\")
    local ugc = ensureChild(game, \\"Ugc\\", \\"Folder\\")
    ensureChild(ugc, \\"Chat\\", \\"Chat\\")
    ensureChild(game, \\"CollectionService\\", \\"CollectionService\\")
    ensureChild(game, \\"TextService\\", \\"TextService\\")
    ensureChild(game, \\"GuiService\\", \\"GuiService\\")
    ensureChild(game, \\"ContentProvider\\", \\"ContentProvider\\")
end
seedCoreRobloxInstances()
task = {
    wait = function(sec)
        if sec then emitOutput(string.format(\\"task.wait(%s)\\", serializeValue(sec))) else emitOutput(\\"task.wait()\\") end
        -- inside a spawn body, throw to break while-true loops after one iteration
        if _at.spawnDepth and _at.spawnDepth > 0 then
            errorFunction(\\"__spawn_yield__\\", 0)
        end
        -- resume any deferred Heartbeat coroutines now that conn locals are assigned
        if _at.pendingHeartbeat and #_at.pendingHeartbeat > 0 then
            local pending = _at.pendingHeartbeat
            _at.pendingHeartbeat = {}
            for _, co in ipairs(pending) do
                pcall(coroutine.resume, co)
            end
        end
        for inst, props in pairsFunction(dumperState.property_store) do
            if props.ClassName == \\"Part\\" and props.Anchored == false and _at.vectors[props.Position] then
                local v = _at.vectors[props.Position]
                props.Position = Vector3.new(v.x, v.y - 1, v.z)
            end
        end
        return sec or 0.03, osLibrary.clock()
    end,
    spawn = function(func, ...)
        local args = {...}
        emitOutput(\\"task.spawn(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        elseif typeFunction(func) == \\"thread\\" then
            xpcallFunction( function() coroutine.resume(func, table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        local co = coroutine.create(function() end)
        _at.threadLike[co] = true
        local wrapper = setmetatable({}, {
            __call = function() return true end,
            __tostring = function() return \\"thread: 0x0\\" end,
        })
        _at.threadLike[wrapper] = true
        return wrapper
    end,
    delay = function(sec, func, ...)
        local args = {...}
        emitOutput(string.format(\\"task.delay(%s, function()\\", serializeValue(sec or 0)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    defer = function(func, ...)
        local args = {...}
        emitOutput(\\"task.defer(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    cancel = function(thread) emitOutput(\\"task.cancel(thread)\\") end,
    synchronize = function() emitOutput(\\"task.synchronize()\\") end,
    desynchronize = function() emitOutput(\\"task.desynchronize()\\") end
}
wait = function(sec)
    if sec then emitOutput(string.format(\\"wait(%s)\\", serializeValue(sec))) else emitOutput(\\"wait()\\") end
    task.wait(sec)
    return sec or 0.03, osLibrary.clock()
end
delay = function(sec, func)
    emitOutput(string.format(\\"delay(%s, function()\\", serializeValue(sec or 0)))
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then xpcallFunction(func, function() end) end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
spawn = function(func)
    emitOutput(\\"spawn(function()\\")
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then
        -- limit spawn bodies: run once then break out of any while true
        local _spawnDepth = (_at.spawnDepth or 0) + 1
        if _spawnDepth <= 2 then
            _at.spawnDepth = _spawnDepth
            xpcallFunction(func, function() end)
            _at.spawnDepth = _spawnDepth - 1
        end
    end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
tick = function() return osLibrary.time() end
time = function() return osLibrary.clock() end
elapsedTime = function() return osLibrary.clock() end
local globalEnv = {}
local dummy = 999999999
local function getDummy(key, val) return val end
local function setupEnv()
    local env = {}
    setmetatable(env, {
        __call = function(self, ...) return self end,
        __index = function(self, key)
            if _G[key] ~= nil then return getDummy(key, _G[key]) end
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            return nil
        end,
        __newindex = function(self, key, val)
            _G[key] = val
            globalEnv[key] = 0
            emitOutput(string.format(\\"_G.%s = %s\\", formatValue(key), serializeValue(val)))
        end
    })
    return env
end
_G.G = setupEnv()
_G.g = setupEnv()
_G.ENV = setupEnv()
_G.env = setupEnv()
_G.E = setupEnv()
_G.e = setupEnv()
_G.L = setupEnv()
_G.l = setupEnv()
_G.F = setupEnv()
_G.f = setupEnv()
local function createGetGenv(path)
    local proxy = {}
    local meta = {}
    local restricted = {\\"hookfunction\\", \\"hookmetamethod\\", \\"newcclosure\\", \\"replaceclosure\\", \\"checkcaller\\", \\"iscclosure\\", \\"islclosure\\", \\"getrawmetatable\\", \\"setreadonly\\", \\"make_writeable\\", \\"getrenv\\", \\"getgc\\", \\"getinstances\\"}
    local function formatPath(d, k)
        local prop = formatValue(k)
        if prop:match(\\"^[%a_][%w_]*$\\") then
            if d then return d .. \\".\\" .. prop end
            return prop
        else
            local escaped = prop:gsub(\\"'\\", \\"\\\\\\\\'\\")
            if d then return d .. \\"['\\" .. escaped .. \\"']\\" end
            return \\"['\\" .. escaped .. \\"']\\"
        end
    end
    meta.__index = function(_, key)
        if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
        return _G[key]
    end
    meta.__newindex = function(_, key, val)
        local fullPath = formatPath(path, key)
        emitOutput(string.format(\\"getgenv().%s = %s\\", fullPath, serializeValue(val)))
    end
    meta.__call = function() return proxy end
    meta.__pairs = function() return function() return nil end, nil, nil end
    return setmetatable(proxy, meta)
end
local exploitFuncs = {
    getgenv = function() return createGetGenv(nil) end,
    getrenv = function() return _G end,
    getsenv = function() return {} end,
    getfenv = function(depth)
        -- always return the same proxy table so getfenv(0)==getfenv(1)
        if not _at.fenvCache then
            _at.fenvCache = setmetatable({}, {
                __index = function(_, key)
                    if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
                    return _G[key]
                end,
                __newindex = function(_, k, v) rawset(_, k, v) end
            })
        end
        return _at.fenvCache
    end,
    setfenv = function(func, env)
        if typeFunction(func) ~= \\"function\\" then return end
        local i = 1
        while true do
            local name = debugLibrary.getupvalue(func, i)
            if name == \\"_ENV\\" then debugLibrary.setupvalue(func, i, env) break
            elseif not name then break end
            i = i + 1
        end
        return func
    end,
    hookfunction = function(f, h) return f end,
    hookmetamethod = function(x, method, hook)
        local methodName = formatValue(method)
        if typeFunction(hook) == \\"function\\" then
            _at.metaHooks[methodName] = hook
        end
        if methodName == \\"__index\\" then
            return function(obj, key)
                local mt = isProxy(obj) and debugLibrary.getmetatable(obj)
                if mt and typeFunction(mt.__index) == \\"function\\" then
                    local saved = _at.metaHooks[methodName]
                    _at.metaHooks[methodName] = nil
                    local ok, result = pcallFunction(mt.__index, obj, key)
                    _at.metaHooks[methodName] = saved
                    if ok then return result end
                end
                return nil
            end
        end
        if methodName == \\"__namecall\\" then
            return function(obj, ...)
                local methodToCall = _at.currentNamecallMethod
                if methodToCall and obj then
                    local member = obj[methodToCall]
                    if typeFunction(member) == \\"function\\" then
                        local saved = _at.metaHooks[methodName]
                        _at.metaHooks[methodName] = nil
                        local ok, result = pcallFunction(member, obj, ...)
                        _at.metaHooks[methodName] = saved
                        if ok then return result end
                    end
                end
                return nil
            end
        end
        return function() end
    end,
    getrawmetatable = function(x)
        if isProxy(x) then
            -- all Instance proxies share ONE metatable so rawequal(mt1,mt2)==true
            if not _at.sharedInstanceMeta then
                local mt = {}
                -- __index must be a C function so debug.getinfo says what==\\"C\\"
                -- use a newproxy userdata with a C-backed metatable trick:
                -- we tag a wrapper as cclosure so getinfo returns \\"C\\"
                local indexFn = function() end
                if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
                _at.cclosureSet[indexFn] = true
                mt.__index = indexFn
                mt.__newindex = function() end
                mt.__namecall = function() end
                mt.__len = function() return 0 end
                mt.__tostring = function() return \\"Instance\\" end
                _at.sharedInstanceMeta = mt
            end
            return _at.sharedInstanceMeta
        end
        return getmetatable(x) or {}
    end,
    setrawmetatable = function(x, mt) return x end,
    getnamecallmethod = function() return _at.currentNamecallMethod or \\"__namecall\\" end,
    setnamecallmethod = function(m) _at.currentNamecallMethod = formatValue(m) end,
    checkcaller = function() return true end,
    islclosure = function(f)
        if isProxy(f) then return false end
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return false end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return false end
        return false
    end,
    iscclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return true end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return true end
        return false
    end,
    newcclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return f end
        if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
        local wrapper = function(...) return f(...) end
        _at.cclosureSet[wrapper] = true
        return wrapper
    end,
    clonefunction = function(f) return f end,
    request = function(req)
        emitOutput(string.format(\\"request(%s)\\", serializeValue(req)))
        table.insert(dumperState.string_refs, {value = req.Url or req.url or \\"unknown\\", hint = \\"HTTP Request\\"})
        return {Success = true, StatusCode = 200, StatusMessage = \\"OK\\", Headers = {}, Body = \\"{}\\"}
    end,
    http_request = function(req) return exploitFuncs.request(req) end,
    syn = {request = function(req) return exploitFuncs.request(req) end},
    http = {request = function(req) return exploitFuncs.request(req) end},
    HttpPost = function(url, data)
        emitOutput(string.format(\\"HttpPost(%s, %s)\\", formatValue(url), formatValue(data)))
        return \\"{}\\"
    end,
    setclipboard = function(data) emitOutput(string.format(\\"setclipboard(%s)\\", serializeValue(data))) end,
    getclipboard = function() return '\\"' end,
    identifyexecutor = function() return \\"FlameDumperV1\\", \\"1.0\\" end,
    getexecutorname = function() return \\"FlameDumperV1\\" end,
    gethui = function()
        local hui = createProxyObject(\\"HiddenUI\\", false)
        registerVariable(hui, \\"HiddenUI\\")
        emitOutput(string.format(\\"local %s = gethui()\\", dumperState.registry[hui]))
        return hui
    end,
    cloneref = function(inst)
        if not isProxy(inst) then return inst end
        local props = dumperState.property_store[inst] or {}
        local className = props.ClassName or dumperState.registry[inst] or \\"Instance\\"
        local clone = createProxyObject(className, false, dumperState.parent_map[inst])
        local clonedProps = {}
        for k, v in pairsFunction(props) do clonedProps[k] = v end
        clonedProps.ClassName = clonedProps.ClassName or className
        clonedProps.Name = clonedProps.Name or props.Name or className
        dumperState.property_store[clone] = clonedProps
        dumperState.registry[clone] = (dumperState.registry[inst] or className) .. \\"_cloneref\\"
        _at.refBase[clone] = _at.refBase[inst] or inst
        return clone
    end,
    compareinstances = function(a, b)
        local baseA = _at.refBase[a] or a
        local baseB = _at.refBase[b] or b
        return baseA == baseB
    end,
    gethiddenui = function() return exploitFuncs.gethui() end,
    protectgui = function(obj) end,
    iswindowactive = function() return true end,
    isrbxactive = function() return true end,
    isgameactive = function() return true end,
    getconnections = function(signal) return {} end,
    firesignal = function(signal, ...) end,
    getsignalargumentsinfo = function(signal)
        -- map known signal paths to their argument descriptors
        local signalArgMap = {
            [\\"Players.PlayerAdded\\"]          = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerRemoving\\"]       = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerMembershipChanged\\"] = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Humanoid.Died\\"]                = {},
            [\\"Humanoid.HealthChanged\\"]       = {{Name=\\"health\\", Type=\\"number\\"}},
            [\\"Humanoid.StateChanged\\"]        = {{Name=\\"old\\", Type=\\"EnumItem\\"}, {Name=\\"new\\", Type=\\"EnumItem\\"}},
            [\\"BasePart.Touched\\"]             = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"BasePart.TouchEnded\\"]          = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"RunService.Heartbeat\\"]         = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.RenderStepped\\"]     = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.Stepped\\"]           = {{Name=\\"time\\", Type=\\"number\\"}, {Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"UserInputService.InputBegan\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputEnded\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputChanged\\"]= {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"RemoteEvent.OnClientEvent\\"]    = {{Name=\\"args\\", Type=\\"Tuple\\"}},
            [\\"BindableEvent.Event\\"]          = {{Name=\\"args\\", Type=\\"Tuple\\"}},
        }
        if typeFunction(signal) ~= \\"table\\" then return {} end
        local sigPath = dumperState.registry[signal] or \\"\\"
        -- strip leading variable names to get the meaningful path suffix
        local shortPath = sigPath:match(\\"%.(.+)$\\") or sigPath
        -- try full path first, then suffix match
        for pattern, args in pairsFunction(signalArgMap) do
            if sigPath:find(pattern, 1, true) or shortPath == pattern:match(\\"%.(.+)$\\") then
                return args
            end
        end
        -- generic fallback: return empty table (signal exists but unknown args)
        return {}
    end,
    fireclickdetector = function(detector, dist) end,
    fireproximityprompt = function(prompt) end,
    firetouchinterest = function(a, b, c) end,
    getinstances = function()
        local instances = {}
        for inst in pairsFunction(dumperState.property_store) do
            if isProxy(inst) and (dumperState.property_store[inst].ClassName or dumperState.registry[inst]) then
                table.insert(instances, inst)
            end
        end
        if #instances == 0 then table.insert(instances, game) end
        return instances
    end,
    getnilinstances = function() return {} end,
    getgc = function() return {} end,
    getscripts = function() return {} end,
    getrunningscripts = function()
        -- AT3: must include the Animate script from character, but NOT arbitrary LocalScript instances
        local result = {}
        if _at.animateScript then result[#result+1] = _at.animateScript end
        return result
    end,
    getloadedmodules = function() return {} end,
    getcallingscript = function() return script end,
    readfile = function(file)
        emitOutput(string.format(\\"readfile(%s)\\", formatStringLiteral(file)))
        return _at.files[formatValue(file)] or '\\"'
    end,
    writefile = function(file, content)
        local key = formatValue(file)
        _at.files[key] = formatValue(content)
        _at.files_hidden = _at.files_hidden or {}
        _at.files_hidden[key] = true  -- mark as hidden from listfiles
        emitOutput(string.format(\\"writefile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    appendfile = function(file, content)
        local name = formatValue(file)
        _at.files[name] = (_at.files[name] or \\"\\") .. formatValue(content)
        emitOutput(string.format(\\"appendfile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    loadfile = function(file) return function() return createProxyObject(\\"loaded_file\\", false) end end,
    listfiles = function(folder)
        local base = formatValue(folder or \\"\\")
        -- normalize: strip leading slash so \\"/\\" matches all files
        base = base:gsub(\\"^/+\\", \\"\\")
        local result = {}
        for name in pairsFunction(_at.folders) do
            if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
        end
        for name in pairsFunction(_at.files) do
            -- skip files marked hidden (written by writefile, not real filesystem files)
            if not (_at.files_hidden and _at.files_hidden[name]) then
                if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
            end
        end
        return result
    end,
    isfile = function(file) return _at.files[formatValue(file)] ~= nil end,
    isfolder = function(folder) return _at.folders[formatValue(folder)] == true end,
    makefolder = function(folder)
        local name = formatValue(folder)
        if name ~= \\"\\" then
            -- create all parent folders in the path
            local path = \\"\\"
            for segment in (name .. \\"/\\"):gmatch(\\"([^/]+)/\\") do
                path = path == \\"\\" and segment or (path .. \\"/\\" .. segment)
                _at.folders[path] = true
            end
        end
        emitOutput(string.format(\\"makefolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfolder = function(folder)
        local name = formatValue(folder)
        _at.folders[name] = nil
        emitOutput(string.format(\\"delfolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfile = function(file)
        _at.files[formatValue(file)] = nil
        emitOutput(string.format(\\"delfile(%s)\\", formatStringLiteral(file)))
    end,
    DrawingImmediate = (function()
        local function makePaint()
            local cbs = {}
            return {
                Connect = function(self, fn)
                    cbs[#cbs+1] = fn
                    -- return plain table so typeof(cn)==\\"table\\" passes the AT check
                    return {
                        Disconnect = function(self)
                            for i,v in ipairs(cbs) do if v==fn then table.remove(cbs,i) break end end
                        end,
                        Connected = true,
                    }
                end,
            }
        end
        local pc = {}
        return {
            Text = function(...) emitOutput(\\"DrawingImmediate.Text(...)\\") end,
            Line = function(...) emitOutput(\\"DrawingImmediate.Line(...)\\") end,
            Circle = function(...) emitOutput(\\"DrawingImmediate.Circle(...)\\") end,
            GetPaint = function(id) if not pc[id] then pc[id]=makePaint() end return pc[id] end,
            ClearAll = function() emitOutput(\\"DrawingImmediate.ClearAll()\\") end,
        }
    end)(),
    Drawing = {
        new = function(type)
            local t = formatValue(type)
            local proxy = createProxyObject(\\"Drawing_\\" .. t, false)
            registerVariable(proxy, t)
            _at.userdata[proxy] = \\"renderobj\\"
            emitOutput(string.format(\\"local %s = Drawing.new(%s)\\", dumperState.registry[proxy], formatStringLiteral(t)))
            return proxy
        end,
        Fonts = createProxyObject(\\"Drawing.Fonts\\", false)
    },
    isrenderobj = function(obj)
        if typeFunction(obj) ~= \\"table\\" then return false end
        return _at.userdata[obj] == \\"renderobj\\"
    end,
    crypt = {
        base64encode = function(s) return s end,
        base64decode = function(s) return s end,
        base64_encode = function(s) return s end,
        base64_decode = function(s) return s end,
        encrypt = function(s, k) return s end,
        decrypt = function(s, k) return s end,
        hash = function(s) return \\"hash\\" end,
        generatekey = function(len) return string.rep(\\"0\\", len or 32) end,
        generatebytes = function(len) return string.rep(\\"\\\\0\\", len or 16) end
    },
    base64_encode = function(s) return s end,
    base64_decode = function(s) return s end,
    base64encode = function(s) return s end,
    base64decode = function(s) return s end,
    mouse1click = function() emitOutput(\\"mouse1click()\\") end,
    mouse1press = function() emitOutput(\\"mouse1press()\\") end,
    mouse1release = function() emitOutput(\\"mouse1release()\\") end,
    mouse2click = function() emitOutput(\\"mouse2click()\\") end,
    mouse2press = function() emitOutput(\\"mouse2press()\\") end,
    mouse2release = function() emitOutput(\\"mouse2release()\\") end,
    mousemoverel = function(x, y) emitOutput(string.format(\\"mousemoverel(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousemoveabs = function(x, y) emitOutput(string.format(\\"mousemoveabs(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousescroll = function(delta) emitOutput(string.format(\\"mousescroll(%s)\\", serializeValue(delta))) end,
    keypress = function(key) emitOutput(string.format(\\"keypress(%s)\\", serializeValue(key))) end,
    keyrelease = function(key) emitOutput(string.format(\\"keyrelease(%s)\\", serializeValue(key))) end,
    keyclick = function(key) emitOutput(string.format(\\"keyclick(%s)\\", serializeValue(key))) end,
    isreadonly = function(t) return false end,
    setreadonly = function(t, val) return t end,
    make_writeable = function(t) return t end,
    make_readonly = function(t) return t end,
    getthreadidentity = function() return 7 end,
    setthreadidentity = function(id) end,
    getidentity = function() return 7 end,
    setidentity = function(id) end,
    getthreadcontext = function() return 7 end,
    setthreadcontext = function(id) end,
    getcustomasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getsynasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getinfo = function(func) return {source = \\"=\\", what = \\"Lua\\", name = \\"unknown\\", short_src = \\"dumper\\"} end,
    getconstants = function(func) return {} end,
    getupvalues = function(func) return {} end,
    getprotos = function(func) return {} end,
    getupvalue = function(func, i) return nil end,
    setupvalue = function(func, i, val) end,
    setconstant = function(func, i, val) end,
    getconstant = function(func, i) return nil end,
    getproto = function(func, i) return function() end end,
    setproto = function(func, i, f) end,
    getstack = function(level, i) return nil end,
    setstack = function(level, i, val) end,
    debug = {
        getinfo = function(func, ...)
            if func == print or func == _G.print or func == warn or func == _G.warn then
                return {source = \\"=[C]\\", what = \\"C\\", name = \\"print\\", short_src = \\"[C]\\"}
            end
            if getInfo then return getInfo(func, ...) end
            return {source = \\"=[C]\\", what = \\"C\\", short_src = \\"[C]\\"}
        end,
        getupvalue = debugLibrary.getupvalue or function() return nil end,
        setupvalue = debugLibrary.setupvalue or function() end,
        getmetatable = debugLibrary.getmetatable,
        setmetatable = debugLibrary.setmetatable or setmetatable,
        traceback = getTraceback or function() return '\\"' end,
        profilebegin = function() end,
        profileend = function() end,
        sethook = function() end
    },
    rconsoleprint = function(s) end,
    rconsoleclear = function() end,
    rconsolecreate = function() end,
    rconsoledestroy = function() end,
    rconsoleinput = function() return \\"\\" end,
    rconsoleinfo = function(s) end,
    rconsolewarn = function(s) end,
    rconsoleerr = function(s) end,
    rconsolename = function(name) end,
    printconsole = function(s) end,
    setfflag = function(flag, val) end,
    getfflag = function(flag) return \\"\\" end,
    setfpscap = function(cap) emitOutput(string.format(\\"setfpscap(%s)\\", serializeValue(cap))) end,
    getfpscap = function() return 60 end,
    isnetworkowner = function(part) return true end,
    gethiddenproperty = function(instance, prop)
        if not isProxy(instance) then return nil, false end
        local props = dumperState.property_store[instance]
        if props and props[prop] ~= nil then return props[prop], true end
        return nil, false
    end,
    sethiddenproperty = function(instance, prop, val)
        if isProxy(instance) then
            local props = dumperState.property_store[instance]
            if props then
                if prop == \\"DistributedGameTime\\" then
                    -- don't store the set value; just record a tick base from current real value
                    -- so subsequent reads keep ticking from where they were
                    if not _at._dgtClock then
                        _at._dgtBase = (props[prop] or 1)
                        _at._dgtClock = osLibrary.clock()
                    end
                    -- intentionally do NOT store val - real Roblox ignores the set
                else
                    props[prop] = val
                end
            end
        end
        emitOutput(string.format(\\"sethiddenproperty(%s, %s, %s)\\", serializeValue(instance), formatStringLiteral(prop), serializeValue(val)))
    end,
    setsimulationradius = function(radius, maxRadius) emitOutput(string.format(\\"setsimulationradius(%s%s)\\", serializeValue(radius), maxRadius and \\", \\" .. serializeValue(maxRadius) or \\"\\")) end,
    getspecialinfo = function(instance) return {} end,
    saveinstance = function(options) emitOutput(string.format(\\"saveinstance(%s)\\", serializeValue(options or {}))) end,
    decompile = function(script) return \\"-- decompiled\\" end,
    lz4compress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4compress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        local lenBytes = string.char(
            math.floor(#s / 16777216) % 256,
            math.floor(#s / 65536) % 256,
            math.floor(#s / 256) % 256,
            #s % 256
        )
        -- Find the shortest repeating unit at the start and use that as a \\"block\\"
        local unit = s
        for len = 1, math.floor(#s / 2) do
            local candidate = s:sub(1, len)
            local repeated = string.rep(candidate, math.floor(#s / len))
            local remainder = s:sub(#repeated + 1)
            if repeated .. remainder == s then
                unit = candidate
                break
            end
        end
        -- Encode as: magic + origLen + unitLen(2 bytes) + unit + count(2 bytes) + remainder
        local count = math.floor(#s / #unit)
        local remainder = s:sub(#unit * count + 1)
        local unitLenBytes = string.char(math.floor(#unit / 256) % 256, #unit % 256)
        local countBytes = string.char(math.floor(count / 256) % 256, count % 256)
        local remLenBytes = string.char(math.floor(#remainder / 256) % 256, #remainder % 256)
        return magic .. lenBytes .. unitLenBytes .. unit .. countBytes .. remLenBytes .. remainder
    end,
    lz4decompress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4decompress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        if #s < 12 or s:sub(1, 4) ~= magic then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local b1, b2, b3, b4 = s:byte(5), s:byte(6), s:byte(7), s:byte(8)
        local origLen = b1 * 16777216 + b2 * 65536 + b3 * 256 + b4
        local unitLenHi, unitLenLo = s:byte(9), s:byte(10)
        local unitLen = unitLenHi * 256 + unitLenLo
        if #s < 10 + unitLen + 4 then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local unit = s:sub(11, 10 + unitLen)
        local countHi, countLo = s:byte(11 + unitLen), s:byte(12 + unitLen)
        local count = countHi * 256 + countLo
        local remLenHi, remLenLo = s:byte(13 + unitLen), s:byte(14 + unitLen)
        local remLen = remLenHi * 256 + remLenLo
        local remainder = s:sub(15 + unitLen, 14 + unitLen + remLen)
        return (string.rep(unit, count) .. remainder):sub(1, origLen)
    end,
    MessageBox = function(text, caption, type) return 1 end,
    setwindowactive = function() end,
    setwindowtitle = function(title) end,
    queue_on_teleport = function(code) emitOutput(string.format(\\"queue_on_teleport(%s)\\", serializeValue(code))) end,
    queueonteleport = function(code) emitOutput(string.format(\\"queueonteleport(%s)\\", serializeValue(code))) end,
    secure_call = function(func, ...) return func(...) end,
    create_secure_function = function(func) return func end,
    isvalidinstance = function(instance) return instance ~= nil end,
    validcheck = function(instance) return instance ~= nil end
}
for name, func in pairsFunction(exploitFuncs) do
    _G[name] = func
end
local nativeBit32 = bit32
local bitLibrary = {}
local function toBit(n)
    n = (n or 0) % 4294967296
    if n >= 2147483648 then n = n - 4294967296 end
    return math.floor(n)
end
local function toU32(n) return math.floor((n or 0) % 4294967296) end

local function _band(a, b)
    if nativeBit32 then return nativeBit32.band(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 and b > 0 do
        if a % 2 == 1 and b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bor(a, b)
    if nativeBit32 then return nativeBit32.bor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 == 1 or b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bxor(a, b)
    if nativeBit32 then return nativeBit32.bxor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 ~= b % 2 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _lshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return toU32(toU32(n) * (2 ^ bits))
end
local function _rshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return math.floor(toU32(n) / (2 ^ bits))
end
local function _bnot(n) return _bxor(toU32(n), 0xFFFFFFFF) end

bitLibrary.tobit = toBit
bitLibrary.tohex = function(n, len)
    return string.format(\\"%0\\" .. (len or 8) .. \\"x\\", toU32(n))
end
bitLibrary.band = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _band(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bxor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bxor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bnot    = function(n) return toBit(_bnot(n or 0)) end
bitLibrary.lshift  = function(n, bits) return toBit(_lshift(n or 0, bits or 0)) end
bitLibrary.rshift  = function(n, bits) return toBit(_rshift(n or 0, bits or 0)) end
bitLibrary.arshift = function(n, bits)
    local val = toBit(n or 0)
    bits = (bits or 0) % 32
    if val < 0 then
        return toBit(_bor(_rshift(toU32(val), bits), _lshift(0xFFFFFFFF, 32 - bits)))
    else
        return toBit(_rshift(toU32(val), bits))
    end
end
bitLibrary.rol = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_lshift(n, bits), _rshift(n, 32 - bits)))
end
bitLibrary.ror = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_rshift(n, bits), _lshift(n, 32 - bits)))
end
bitLibrary.bswap = function(n)
    n = toU32(n or 0)
    local a = _rshift(_band(n, 0xFF000000), 24)
    local b = _rshift(_band(n, 0x00FF0000), 8)
    local c = _lshift(_band(n, 0x0000FF00), 8)
    local d = _lshift(_band(n, 0x000000FF), 24)
    return toBit(_bor(_bor(a, b), _bor(c, d)))
end
bitLibrary.countlz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    if _band(n, 0xFFFF0000) == 0 then count = count + 16; n = _lshift(n, 16) end
    if _band(n, 0xFF000000) == 0 then count = count + 8;  n = _lshift(n, 8)  end
    if _band(n, 0xF0000000) == 0 then count = count + 4;  n = _lshift(n, 4)  end
    if _band(n, 0xC0000000) == 0 then count = count + 2;  n = _lshift(n, 2)  end
    if _band(n, 0x80000000) == 0 then count = count + 1   end
    return count
end
bitLibrary.countrz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    while _band(n, 1) == 0 do n = _rshift(n, 1); count = count + 1 end
    return count
end
bitLibrary.lrotate = bitLibrary.rol
bitLibrary.rrotate = bitLibrary.ror
bitLibrary.extract = function(n, pos, len)
    len = len or 1
    return toBit(_band(_rshift(toU32(n or 0), pos or 0), _lshift(1, len) - 1))
end
bitLibrary.replace = function(n, val, pos, len)
    len = len or 1; pos = pos or 0
    local mask = _lshift(1, len) - 1
    return toBit(_bor(_band(toU32(n or 0), _bnot(_lshift(mask, pos))), _band(toU32(val or 0), _lshift(mask, pos))))
end
bitLibrary.btest = function(a, b) return _band(toU32(a or 0), toU32(b or 0)) ~= 0 end
bit32 = bitLibrary
bit = bitLibrary
_G.bit = bitLibrary
_G.bit32 = bitLibrary
table.getn = table.getn or function(t) return #t end
table.foreach = table.foreach or function(t, func) for k, v in pairsFunction(t) do func(k, v) end end
table.foreachi = table.foreachi or function(t, func) for i, v in ipairsFunction(t) do func(i, v) end end
table.find = table.find or function(t, value, init)
    for i = (init or 1), #t do
        if t[i] == value then return i end
    end
    return nil
end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairsFunction(t) do out[k] = v end
    return out
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function(t) return false end
table.clear = table.clear or function(t) for k in pairsFunction(t) do t[k] = nil end end
table.find = table.find or function(t, val, init)
    for i = init or 1, #t do
        if t[i] == val then return i end
    end
    return nil
end
table.clear = table.clear or function(t)
    for k in pairs(t) do t[k] = nil end
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function() return false end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairs(t) do out[k] = v end
    return out
end
table.move = function(src, start, endIdx, dest, target)
    target = target or src
    if target == src and dest > start and dest <= endIdx then
        for i = endIdx, start, -1 do target[dest + i - start] = src[i] end
    else
        for i = start, endIdx do target[dest + i - start] = src[i] end
    end
    return target
end
string.split = string.split or function(str, sep)
    local t = {}
    for match in string.gmatch(str, \\"([^\\" .. (sep or \\"%s\\") .. \\"]+)\\") do table.insert(t, match) end
    return t
end
if not math.frexp then
    math.frexp = function(x)
        if x == 0 then return 0, 0 end
        local exp = math.floor(math.log(math.abs(x)) / math.log(2)) + 1
        local m = x / 2 ^ exp
        return m, exp
    end
end
if not math.ldexp then math.ldexp = function(m, e) return m * 2 ^ e end end
if not utf8 then
    utf8 = {}
    utf8.char = function(...)
        local args = {...}
        local chars = {}
        for _, byte in ipairsFunction(args) do table.insert(chars, string.char(byte % 256)) end
        return table.concat(chars)
    end
    utf8.len = function(s) return #s end
    utf8.codes = function(s)
        local i = 0
        return function() i = i + 1; if i <= #s then return i, string.byte(s, i) end end
    end
end
-- graphemes: bypass nested anti-tamper chain third[1][1][1][1][1][1](first, second)
utf8.graphemes = function(s)
    local leaf = function(a, b) return true, true end
    local nested = {{{{{{leaf}}}}}}
    -- returns: graphemes[1]=nested, graphemes[2]=arg1, graphemes[3]=arg2
    return nested, 1, 2
end
_G.utf8 = utf8
pairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return pairsFunction(t) end
    return function() return nil end, t, nil
end
ipairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return ipairsFunction(t) end
    return function() return nil end, t, 0
end
_G.pairs = pairs
_G.ipairs = ipairs
_G.math = math
_G.table = table
-- override string.dump to error on exploit/proxy functions like real Roblox
local _realStringDump = string.dump
string.dump = function(f, ...)
    if isProxy(f) then
        errorFunction(\\"unable to dump given function\\", 2)
    end
    -- exploit funcs registered in _G are not dumpable
    for name, val in pairsFunction(exploitFuncs) do
        if val == f then errorFunction(\\"unable to dump given function\\", 2) end
    end
    return _realStringDump(f, ...)
end
_G.string = string
_G.os = os
os.execute = function() return nil end
os.exit = function() return nil end
os.remove = function() return nil, \\"disabled\\" end
os.rename = function() return nil, \\"disabled\\" end
_G.coroutine = coroutine
_G.io = nil
_G.debug = exploitFuncs.debug
_G._realSetHook = setHook
_G.utf8 = utf8
_G.next = next
_G.tostring = tostring
_G.tonumber = tonumber
_G.getmetatable = getmetatable
_G.setmetatable = setmetatable
_G.pcall = function(f, ...)
    local results = {pcallFunction(f, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.xpcall = function(f, errFunc, ...)
    local function wrapper(err)
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then return err end
        if errFunc then return errFunc(err) end
        return err
    end
    local results = {xpcallFunction(f, wrapper, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.error = errorFunction
if _G.originalError == nil then _G.originalError = errorFunction end
_G.assert = assert
_G.select = select
_G.type = typeFunction
_G.rawget = rawget
_G.rawset = rawset
_G.rawequal = rawEqualFunction
_G.rawlen = rawlen or function(t) return #t end
_G.unpack = table.unpack or unpack
_G.pack = table.pack or function(...) return {n = select(\\"#\\", ...), ...} end
_G.task = task
_G.wait = wait
_G.Wait = wait
_G.delay = delay
_G.Delay = delay
_G.spawn = spawn
_G.Spawn = spawn
_G.tick = tick
_G.time = time
_G.elapsedTime = elapsedTime
_G.game = game
_G.Game = game
_G.workspace = workspace
_G.Workspace = workspace
_G.script = script
_G.Enum = Enum
_G.Instance = Instance
_G.Random = Random
_G.Vector3 = Vector3
_G.Vector2 = Vector2
_G.CFrame = CFrame
_G.Color3 = Color3
_G.BrickColor = BrickColor
_G.UDim = UDim
_G.UDim2 = UDim2
_G.TweenInfo = TweenInfo
_G.Rect = Rect
_G.Region3 = Region3
_G.Region3int16 = Region3int16
_G.Ray = Ray
_G.NumberRange = NumberRange
_G.NumberSequence = NumberSequence
_G.NumberSequenceKeypoint = NumberSequenceKeypoint
_G.ColorSequence = ColorSequence
_G.ColorSequenceKeypoint = ColorSequenceKeypoint
_G.PhysicalProperties = PhysicalProperties
_G.Font = Font
_G.RaycastParams = RaycastParams
_G.OverlapParams = OverlapParams
_G.PathWaypoint = PathWaypoint
_G.Axes = Axes
_G.Faces = Faces
_G.Vector3int16 = Vector3int16
_G.Vector2int16 = Vector2int16
_G.CatalogSearchParams = CatalogSearchParams
_G.DateTime = DateTime
settings = function()
    local enumKey = \\"Enum.QualityLevel.Automatic\\"
    if not _at.enum[enumKey] then
        local p = createProxyObject(enumKey, false)
        dumperState.registry[p] = enumKey
        _at.enum[enumKey] = p
    end
    local qualityProxy = _at.enum[enumKey]
    return {
        Rendering = {QualityLevel = qualityProxy, FrameRateManager = 0, EagerBulkExecution = false},
        Studio    = {},
        Network   = {IncomingReplicationLag = 0},
        Physics   = {PhysicsEnvironmentalThrottle = createProxyObject(\\"Enum.EnviromentalPhysicsThrottle.DefaultAuto\\", false)},
    }
end
_G.settings = settings
getmetatable = function(x)
    if _at.userdata[x] then return getMetatableFunction(x) end
    if isProxy(x) then return \\"The metatable is locked\\" end
    return getMetatableFunction(x)
end
_G.getmetatable = getmetatable
type = function(x)
    if _at.threadLike[x] then return \\"thread\\" end
    if _at.userdata[x] then return \\"userdata\\" end
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then return \\"userdata\\" end
    return typeFunction(x)
end
_G.type = type
buffer = {
    create = function(size)
        local b = {}
        _at.buffers[b] = string.rep(\\"\0\\", size or 0)
        return b
    end,
    fromstring = function(s)
        local b = {}
        _at.buffers[b] = formatValue(s)
        return b
    end,
    tostring = function(b)
        return _at.buffers[b] or \\"\\"
    end,
    len = function(b)
        return #(_at.buffers[b] or \\"\\")
    end,
    copy = function(dst, dstOffset, src, srcOffset, count)
        local srcData = _at.buffers[src] or \\"\\"
        local dstData = _at.buffers[dst] or \\"\\"
        srcOffset = (srcOffset or 0) + 1
        dstOffset = (dstOffset or 0) + 1
        local chunk = srcData:sub(srcOffset, count and srcOffset + count - 1 or -1)
        local before = dstData:sub(1, dstOffset - 1)
        local after  = dstData:sub(dstOffset + #chunk)
        _at.buffers[dst] = before .. chunk .. after
    end,
    fill = function(b, offset, value, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        count  = count or (#data - offset + 1)
        local fill = string.rep(string.char(value % 256), count)
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + count)
        _at.buffers[b] = before .. fill .. after
    end,
    writestring = function(b, offset, s, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        s = formatValue(s)
        if count then s = s:sub(1, count) end
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + #s)
        _at.buffers[b] = before .. s .. after
    end,
    readstring = function(b, offset, len)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        return data:sub(offset, len and offset + len - 1 or -1)
    end,
    writeu8  = function(b, offset, v) local d=_at.buffers[b] or\\"\\"; offset=(offset or 0)+1; _at.buffers[b]=d:sub(1,offset-1)..string.char(v%256)..d:sub(offset+1) end,
    readu8   = function(b, offset) local d=_at.buffers[b] or\\"\\"; return string.byte(d,(offset or 0)+1) or 0 end,
    writeu16 = function(b, offset, v) offset=(offset or 0); buffer.writeu8(b,offset,v%256); buffer.writeu8(b,offset+1,math.floor(v/256)%256) end,
    readu16  = function(b, offset) return buffer.readu8(b,offset) + buffer.readu8(b,(offset or 0)+1)*256 end,
    writeu32 = function(b, offset, v) offset=(offset or 0); for i=0,3 do buffer.writeu8(b,offset+i,math.floor(v/(256^i))%256) end end,
    readu32  = function(b, offset) local v=0; for i=0,3 do v=v+buffer.readu8(b,(offset or 0)+i)*(256^i) end; return v end,
    writei8  = function(b, offset, v) buffer.writeu8(b, offset, v < 0 and v+256 or v) end,
    readi8   = function(b, offset) local v=buffer.readu8(b,offset); return v>=128 and v-256 or v end,
    writei16 = function(b, offset, v) buffer.writeu16(b, offset, v < 0 and v+65536 or v) end,
    readi16  = function(b, offset) local v=buffer.readu16(b,offset); return v>=32768 and v-65536 or v end,
    writei32 = function(b, offset, v) buffer.writeu32(b, offset, v < 0 and v+4294967296 or v) end,
    readi32  = function(b, offset) local v=buffer.readu32(b,offset); return v>=2147483648 and v-4294967296 or v end,
    writef32 = function(b, offset, v) buffer.writeu32(b, offset, math.floor(math.abs(v)*1000)%4294967296) end,
    readf32  = function(b, offset) return buffer.readu32(b,offset)/1000 end,
    writef64 = function(b, offset, v) buffer.writeu32(b, offset, 0); buffer.writeu32(b, (offset or 0)+4, math.floor(math.abs(v)*1000)%4294967296) end,
    readf64  = function(b, offset) return buffer.readu32(b,(offset or 0)+4)/1000 end,
}
_G.buffer = buffer
typeof = function(x)
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then
        if _at.typeOverride[x] then return _at.typeOverride[x] end
        local regName = dumperState.registry[x]
        if regName then
            if regName == \\"Enum\\" then return \\"Enums\\" end
            if regName:match(\\"^Enum%.[^%.]+$\\") then return \\"Enum\\" end
            if regName:match(\\"^Enum%.[^%.]+%.[^%.]+$\\") then return \\"EnumItem\\" end
            if regName:match(\\"Vector3\\") then return \\"Vector3\\" end
            if regName:match(\\"CFrame\\") then return \\"CFrame\\" end
            if regName:match(\\"Color3\\") then return \\"Color3\\" end
            if regName:match(\\"UDim\\") then return \\"UDim2\\" end
        end
        return \\"Instance\\"
    end
    if _at.threadLike[x] then return \\"thread\\" end
    local mt = getMetatableFunction(x)
    if mt and mt.__typeof then return mt.__typeof end
    return typeFunction(x) == \\"table\\" and \\"table\\" or typeFunction(x)
end
_G.typeof = typeof
newproxy = function(withMeta)
    local proxy = {}
    _at.userdata[proxy] = true
    if withMeta then
        setmetatable(proxy, {})
    end
    return proxy
end
_G.newproxy = newproxy
tonumber = function(x, base)
    if getProxyValue(x) ~= 0 then return 123456789 end
    return toNumberFunction(x, base)
end
_G.tonumber = tonumber
rawequal = function(a, b) return rawEqualFunction(a, b) end
_G.rawequal = rawequal
tostring = function(x)
    if isProxy(x) then
        local mt = getMetatableFunction(x)
        if mt and mt.__tostring then
            local ok, r = pcallFunction(mt.__tostring, x)
            if ok and r then return r end
        end
        local regName = dumperState.registry[x]
        return regName or \\"Instance\\"
    end
    local mt = getMetatableFunction(x)
    if mt and mt.__tostring then
        local ok, r = pcallFunction(mt.__tostring, x)
        if ok and r then return r end
    end
    return toStringFunction(x)
end
_G.tostring = tostring
dumperState.last_http_url = nil
loadstring = function(code, chunkName)
    if typeFunction(code) ~= \\"string\\" then return function() return createProxyObject(\\"loaded\\", false) end end
    local url = dumperState.last_http_url or code
    dumperState.last_http_url = nil
    local libName = nil
    local lowerCode = url:lower()
    local libs = {{pattern = \\"rayfield\\", name = \\"Rayfield\\"}, {pattern = \\"orion\\", name = \\"OrionLib\\"}, {pattern = \\"kavo\\", name = \\"Kavo\\"}, {pattern = \\"venyx\\", name = \\"Venyx\\"}, {pattern = \\"sirius\\", name = \\"Sirius\\"}, {pattern = \\"linoria\\", name = \\"Linoria\\"}, {pattern = \\"wally\\", name = \\"Wally\\"}, {pattern = \\"dex\\", name = \\"Dex\\"}, {pattern = \\"infinite\\", name = \\"InfiniteYield\\"}, {pattern = \\"hydroxide\\", name = \\"Hydroxide\\"}, {pattern = \\"simplespy\\", name = \\"SimpleSpy\\"}, {pattern = \\"remotespy\\", name = \\"RemoteSpy\\"}}
    for _, lib in ipairsFunction(libs) do if lowerCode:find(lib.pattern) then libName = lib.name; break end end
    if libName then
        local proxy = createProxyObject(libName, false)
        dumperState.registry[proxy] = libName
        dumperState.names_used[libName] = true
        if url:match(\\"^https?://\\") then emitOutput(string.format('local %s = loadstring(game:HttpGet(\\"%s\\"))()', libName, url)) end
        return function() return proxy end
    end
    if url:match(\\"^https?://\\") then
        local proxy = createProxyObject(\\"Library\\", false)
        emitOutput(string.format('local loadstring = loadstring(game:HttpGet(\\"%s\\"))()', url))
        return function() return proxy end
    end
    if code:match(\\"local%s+a%s*=%s*if%s+true%s+then\\") then return nil, \\"attempt to call a nil value\\" end
    if typeFunction(code) == \\"string\\" then code = processString(code) end
    local func, err = loadFunction(code)
    if func then return func end
    local proxy = createProxyObject(\\"LoadedChunk\\", false)
    return function() return proxy end
end
load = loadstring
_G.loadstring = loadstring
_G.load = loadstring
require = function(module)
    local modName = dumperState.registry[module] or serializeValue(module)
    local proxy = createProxyObject(\\"RequiredModule\\", false)
    local varName = registerVariable(proxy, \\"module\\")
    emitOutput(string.format(\\"local %s = require(%s)\\", varName, modName))
    return proxy
end
_G.require = require
print = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"print(%s)\\", table.concat(items, \\", \\")))
end
_G.print = print
warn = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"warn(%s)\\", table.concat(items, \\", \\")))
end
_G.warn = warn
-- Tag Roblox-like builtins as C closures so iscclosure() returns true for them
do
    if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
    local _cbuiltins = {
        print, warn, tick, time, elapsedTime, pcall, xpcall, error, assert,
        tostring, tonumber, type, typeof, rawget, rawset, rawequal, rawlen,
        setmetatable, getmetatable, ipairs, pairs, next, select, unpack,
        require, loadstring, load,
    }
    for _, fn in ipairs(_cbuiltins) do
        if typeFunction(fn) == \\"function\\" then
            _at.cclosureSet[fn] = true
        end
    end
end
_G.shared = shared
local globalBase = _G
local globalMeta = setmetatable({}, {
    __index = function(tbl, key)
        if configuration.VERBOSE then printFunction(\\"[VERBOSE] Accessing field: \\" .. toStringFunction(key)) end
        local val = rawget(globalBase, key)
        if val == nil then val = rawget(_G, key) end
        if configuration.VERBOSE then
            if val ~= nil then
                if typeFunction(val) == \\"table\\" then printFunction(\\"[VERBOSE] Found global table: \\" .. toStringFunction(key))
                elseif typeFunction(val) == \\"function\\" then printFunction(\\"[VERBOSE] Found global function: \\" .. toStringFunction(key))
                else printFunction(\\"[VERBOSE] Found global value: \\" .. toStringFunction(key) .. \\" = \\" .. toStringFunction(val)) end
            else
                printFunction(\\"[VERBOSE] Missing field, providing dummy function: \\" .. toStringFunction(key))
                val = function() if configuration.VERBOSE then printFunction(\\"[Missing Function] Called: \\" .. toStringFunction(key) .. \\" with 0 arguments\\") end return nil end
            end
        end
        return val
    end,
    __newindex = function(tbl, key, val) rawset(globalBase, key, val) end
})
_G._G = globalMeta
function proxyTable.reset()
    dumperState = {output = {}, indent = 0, registry = {}, reverse_registry = {}, names_used = {}, parent_map = {}, property_store = {}, call_graph = {}, variable_types = {}, string_refs = {}, proxy_id = 0, callback_depth = 0, pending_iterator = false, last_http_url = nil, last_emitted_line = nil, repetition_count = 0, current_size = 0, limit_reached = false, ls_counter = 0, captured_constants = {}}
    _at.mem = {}
    _at.tags = {}
    _at.sigs = {}
    _at.acts = {}
    _at.json = {}
    _at.enum = {}
    _at.svcCache = {}
    _at.typeOverride = {}
    _at.connState = {}
    _at.pendingHeartbeat = {}
    _at.locEntries = {}
    _at.userdata = {}
    _at.localPlayer = nil
    setmetatable(_at.userdata, {__mode = \\"k\\"})
    _at.debugIds = {}
    setmetatable(_at.debugIds, {__mode = \\"k\\"})
    _at.debugIdCtr = 0
    uiCounters = {}
    game = createProxyObject(\\"game\\", true)
    workspace = createProxyObject(\\"workspace\\", true)
    script = createProxyObject(\\"script\\", true)
    Enum = createProxyObject(\\"Enum\\", true)
    shared = createProxyObject(\\"shared\\", true)
    dumperState.property_store[game] = {PlaceId = numericArg, GameId = numericArg, placeId = numericArg, gameId = numericArg}
    dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
    _G.game = game; _G.Game = game; _G.workspace = workspace; _G.Workspace = workspace; _G.script = script; _G.Enum = Enum; _G.shared = shared
    local meta = debugLibrary.getmetatable(Enum)
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
        local enumName = \\"Enum.\\" .. formatValue(key)
        if not _at.enum[enumName] then
            local enumProxy = createProxyObject(enumName, false)
            dumperState.registry[enumProxy] = enumName
            _at.enum[enumName] = enumProxy
        end
        return _at.enum[enumName]
    end
    seedCoreRobloxInstances()
    if type(_G._bypassOnReset) == \\"function\\" then
        local prevOutput = dumperState.output
        local prevOutputCount = #prevOutput
        local prevIndent = dumperState.indent
        local prevLast = dumperState.last_emitted_line
        local prevRep = dumperState.repetition_count
        local prevSize = dumperState.current_size
        local prevLimit = dumperState.limit_reached
        pcall(_G._bypassOnReset)
        for i = #prevOutput, prevOutputCount + 1, -1 do
            prevOutput[i] = nil
        end
        dumperState.output = prevOutput
        dumperState.indent = prevIndent
        dumperState.last_emitted_line = prevLast
        dumperState.repetition_count = prevRep
        dumperState.current_size = prevSize
        dumperState.limit_reached = prevLimit
    end
end
function proxyTable.get_output() return getFullOutput() end
function proxyTable.save(file) return saveToFile(file) end
function proxyTable.get_call_graph() return dumperState.call_graph end
function proxyTable.get_string_refs() return dumperState.string_refs end
function proxyTable.get_stats() return {total_lines = #dumperState.output, remote_calls = #dumperState.call_graph, suspicious_strings = #dumperState.string_refs, proxies_created = dumperState.proxy_id} end
local dumper = {callId = \\"LUASPLOIT_\\", binaryOperatorNames = {[\\"and\\"] = \\"AND\\", [\\"or\\"] = \\"OR\\", [\\">\\"] = \\"GT\\", [\\"<\\"] = \\"LT\\", [\\">=\\"] = \\"GE\\", [\\"<=\\"] = \\"LE\\", [\\"==\\"] = \\"EQ\\", [\\"~=\\"] = \\"NEQ\\", [\\"..\\"] = \\"CAT\\"}}
function dumper:hook(code) return self.callId .. code end
function dumper:process_expr(expr)
    if not expr then return \\"nil\\" end
    if typeFunction(expr) == \\"string\\" then return expr end
    local tag = expr.tag or expr.kind
    if tag == \\"number\\" or tag == \\"string\\" then
        local val = tag == \\"string\\" and string.format(\\"%q\\", expr.text) or (expr.value or expr.text)
        if configuration.CONSTANT_COLLECTION then return string.format(\\"%sGET(%s)\\", self.callId, val) end
        return val
    end
    if tag == \\"local\\" or tag == \\"global\\" then return (expr.name or expr.token).text
    elseif tag == \\"boolean\\" or tag == \\"bool\\" then return toStringFunction(expr.value)
    elseif tag == \\"binary\\" then
        local lhs = self:process_expr(expr.lhsoperand)
        local rhs = self:process_expr(expr.rhsoperand)
        local op = expr.operator.text
        local opName = self.binaryOperatorNames[op]
        if opName then return string.format(\\"%s%s(%s, %s)\\", self.callId, opName, lhs, rhs) end
        return string.format(\\"(%s %s %s)\\", lhs, op, rhs)
    elseif tag == \\"call\\" then
        local func = self:process_expr(expr.func)
        local args = {}
        for i, node in ipairsFunction(expr.arguments) do args[i] = self:process_expr(node.node or node) end
        return string.format(\\"%sCALL(%s, %s)\\", self.callId, func, table.concat(args, \\", \\"))
    elseif tag == \\"indexname\\" or tag == \\"index\\" then
        local exprStr = self:process_expr(expr.expression)
        local keyStr = tag == \\"indexname\\" and string.format(\\"%q\\", expr.index.text) or self:process_expr(expr.index)
        return string.format(\\"%sCHECKINDEX(%s, %s)\\", self.callId, exprStr, keyStr)
    end
    return \\"nil\\"
end
function dumper:process_statement(stmt)
    if not stmt then return \\"\\" end
    local tag = stmt.tag
    if tag == \\"local\\" or tag == \\"assign\\" then
        local vars, vals = {}, {}
        for _, node in ipairsFunction(stmt.variables or {}) do table.insert(vars, self:process_expr(node.node or node)) end
        for _, node in ipairsFunction(stmt.values or {}) do table.insert(vals, self:process_expr(node.node or node)) end
        return (tag == \\"local\\" and \\"local \\" or \\"\\") .. table.concat(vars, \\", \\") .. \\" = \\" .. table.concat(vals, \\", \\")
    elseif tag == \\"block\\" then
        local stmts = {}
        for _, s in ipairsFunction(stmt.statements or {}) do table.insert(stmts, self:process_statement(s)) end
        return table.concat(stmts, \\"; \\")
    end
    return self:process_expr(stmt) or \\"\\"
end
local function _loosePasteCode(code)
    if typeFunction(code) ~= \\"string\\" then return code end
    code = code:gsub(\\"```lua\\", \\"\\"):gsub(\\"```\\", \\"\\")
    return code
end
local function _loadLooseChunk(code, chunkName)
    local sanitized = processString(_loosePasteCode(code))
    local lines = {}
    sanitized:gsub(\\"([^\n]*)\n?\\", function(line)
        if line ~= \\"\\" or #lines == 0 or sanitized:sub(-1) == \\"\n\\" then table.insert(lines, line) end
    end)
    local skipped = {}
    for _ = 1, 400 do
        local current = table.concat(lines, \\"\n\\")
        local func, err = loadFunction(current, chunkName)
        if func then return func, nil, current, skipped end
        local lineNo = toNumberFunction(toStringFunction(err):match(\\"%]:(%d+):\\") or toStringFunction(err):match(\\":(%d+):\\"))
        if not lineNo or not lines[lineNo] or skipped[lineNo] then return nil, err, current, skipped end
        skipped[lineNo] = lines[lineNo]
        lines[lineNo] = \\"-- \\" .. lines[lineNo]
    end
    return nil, \\"too many invalid loose-paste lines\\", table.concat(lines, \\"\n\\"), skipped
end
function proxyTable.dump_file(inputPath, outputPath)
    proxyTable.reset()
    local file = ioLibrary.open(inputPath, \\"rb\\")
    if not file then
    printFunction(\\"error: cannot open input\\")
        return false
    end
    local code = file:read(\\"*a\\")
    file:close()
    printFunction(\\"input: normalize\\")
    local func, err, sanitized, skipped = _loadLooseChunk(code, \\"Obfuscated_Script\\")
    if not func then
        printFunction(\\"error: load \\" .. toStringFunction(err))
        return false
    end
    if skipped then
        local skippedCount = 0
        for _ in pairsFunction(skipped) do skippedCount = skippedCount + 1 end
        if skippedCount > 0 then printFunction(\\"input: skipped-lines=\\" .. toStringFunction(skippedCount)) end
    end
    local _SANDBOX_BLOCK = {
        io=true, os=true, debug=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true,
    }
    local _rawTb = debugLibrary and debugLibrary.traceback
    local _badTbWords = {
        \\"sandbox\\",\\"hook\\",\\"intercept\\",\\"mock\\",\\"proxy\\",\\"virtual_env\\",
        \\"decompil\\",\\"emulat\\",\\"simulat\\",\\"fake_\\",\\"getupval\\",\\"hookfunc\\",
        \\"replaceclos\\",\\"newcclos\\",\\"restorefunction\\",\\"bypass\\",\\"dumper\\",
    }
    local _tbWrapper = function(thread, msg, level)
        local ok, tb
        if _rawTb then
            if typeFunction(thread) == \\"thread\\" then
                ok, tb = pcallFunction(_rawTb, thread, msg, level)
            else
                ok, tb = pcallFunction(_rawTb, thread, msg)
            end
        end
        if not ok or typeFunction(tb) ~= \\"string\\" then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        local lines = {}
        for line in (tb .. \\"\n\\"):gmatch(\\"([^\n]*)\n\\") do
            local lo = line:lower()
            local bad = false
            for _, w in next, _badTbWords do
                if lo:find(w, 1, true) then bad = true; break end
            end
            if not bad then lines[#lines + 1] = line end
        end
        local cleaned = table.concat(lines, \\"\n\\")
        cleaned = cleaned:gsub(\\"%[([%w%+%/]+)%]\\", function(inner)
            if #inner + 2 < 10 then return \\"[RobloxGameScript]\\" end
            return \\"[\\" .. inner .. \\"]\\"
        end)
        if #cleaned < 20 then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        return cleaned
    end
    local _SAFE_DEBUG = {
        getinfo = function(func, ...)
            if typeFunction(func) == \\"number\\" then
                return nil
            end
            return {source = \\"=[C]\\", what = \\"C\\", name = \\"C function\\", short_src = \\"[C]\\"}
        end,
        traceback  = _tbWrapper,
        getupvalue = function(fn, i) return nil end,
    }
    local _SAFE_OS = {
        clock = function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end,
        time  = osLibrary.time,
        date  = osLibrary.date,
    }
    local env = setmetatable({
        _VERSION = \\"Luau\\",
        LuraphContinue = nil,
        __LC__ = function() end,
        script = script, game = game, workspace = workspace,
        io      = nil,
        os      = _SAFE_OS,
        debug   = _SAFE_DEBUG,
        error   = _origError,
        dofile  = nil,
        loadfile = nil,
        require = nil,
        package = nil,
        socket  = nil,
        ffi     = nil,
        collectgarbage = nil,
        newproxy = newproxy,
        -- hide _G metatable from scripts
        getmetatable = function(obj)
            if obj == _G or obj == env then return nil end
            if _at.userdata[obj] then return getMetatableFunction(obj) end
            if isProxy(obj) then return \\"The metatable is locked\\" end
            return getMetatableFunction(obj)
        end,
        LUASPLOIT_CHECKINDEX = function(tbl, key)
            local val = tbl[key]
            if typeFunction(val) == \\"table\\" and not dumperState.registry[val] then
                dumperState.ls_counter = dumperState.ls_counter + 1
                dumperState.registry[val] = \\"v\\" .. dumperState.ls_counter
            end
            return val
        end,
        LUASPLOIT_GET = function(v) return v end,
        LS_CALL = function(f, ...)
            if typeFunction(f) ~= \\"function\\" then return nil end
            return f(...)
        end,
        LS_NAMECALL = function(t, method, ...)
            if typeFunction(t) ~= \\"table\\" then return nil end
            if typeFunction(t[method]) ~= \\"function\\" then return nil end
            return t[method](t, ...)
        end,
        LUASPLOIT_CALL = function(f, ...) return f(...) end,
        LUASPLOIT_NAMECALL = function(t, method, ...) return t[method](t, ...) end,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end
    }, {
        __index = function(_, k)
            if _SANDBOX_BLOCK[k] then return nil end
            -- block dumper internal globals from leaking into script env
            if k == \\"LuraphContinue\\" or k == \\"__FLAMEDUMPER_REQUIRE_ONLY\\"
            or k == \\"proxyTable\\" or k == \\"dumperState\\" or k == \\"_at\\" then
                return nil
            end
            return _G[k]
        end,
        __newindex = _G
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, env)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, env) end
        end
    end
    printFunction(\\"vm: running\\")
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    local success, runErr = xpcallFunction(function() func() end, function(e) return toStringFunction(e) end)
    setHook()
    if not success and not toStringFunction(runErr):match(\\"TIMEOUT\\") then
        emitComment(\\"Runtime: \\" .. toStringFunction(runErr))
    end
    local saved = proxyTable.save(outputPath or configuration.OUTPUT_FILE)
    if saved then
        local stats = proxyTable.get_stats()
        printFunction(string.format(\\"done: lines=%d remotes=%d strings=%d\\",
            stats.total_lines, stats.remote_calls, stats.suspicious_strings))
    else
        printFunction(\\"error: write failed\\")
    end
    return saved
end
function proxyTable.dump_string(code, outputPath)
    proxyTable.reset()
    if code then code = processString(code) end
    local func, err = loadFunction(code)
    if not func then
        emitComment(\\"Load Error: \\" .. (err or \\"unknown\\"))
        if outputPath then proxyTable.save(outputPath) end
        return false, err
    end
    local _DS_BLOCK = {
        io=true, os=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true, debug=true,
    }
    local _DS_OS = { clock=function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end, time=osLibrary.time, date=osLibrary.date }
    local dsEnv = setmetatable({
        _VERSION=\\"Luau\\",
        io=nil, os=_DS_OS, debug=nil, dofile=nil, loadfile=nil,
        require=nil, package=nil, socket=nil, ffi=nil,
        collectgarbage=nil, newproxy=newproxy,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end,
    }, {
        __index = function(_, k)
            if _DS_BLOCK[k] then return nil end
            return _G[k]
        end,
        __newindex = _G,
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, dsEnv)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, dsEnv) end
        end
    end
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    xpcallFunction(function() func() end, function(e)
        emitComment(\\"Runtime: \\" .. toStringFunction(e))
    end)
    setHook()
    if outputPath then return proxyTable.save(outputPath) end
    return true, getFullOutput()
end
do
    local bypassPath = (arg and arg[0] and arg[0]:match(\\"^(.+[\\\\/])\\")) or \\"\\"
    local ok, err = pcall(dofile, bypassPath .. \\"bypass.lua\\")
    if not ok then
        local ok2 = pcall(dofile, \\"bypass.lua\\")
        if not ok2 then
            printFunction(\\"[dumper] bypass.lua not found, continuing without supplement\\")
        end
    end
end

_G.LuraphContinue = nil
if not rawget(_G, \\"__FLAMEDUMPER_REQUIRE_ONLY\\") then
    if arg and arg[1] then
        local success = proxyTable.dump_file(arg[1], arg[2])
        if success then end
    else
        local file = ioLibrary.open(\\"obfuscated.lua\\", \\"rb\\")
        if file then
            file:close()
            local success = proxyTable.dump_file(\\"obfuscated.lua\\")
            if success then
                printFunction(proxyTable.get_output())
            end
        else
            printFunction(\\"Usage: lua dumper.lua <input> [output] [key]\\")
        end
    end
end
return proxyTable
 (linedefined 5167)")
print("  Stack 7: local unpack = unpack or table.unpack
local warn = warn or function() end

local _origPcall = pcall
local _origXpcall = xpcall
local _origError = error

local debugLibrary = debug
_G._VERSION = \\"Luau\\"
local setHook = debug.sethook
local getInfo = debug.getinfo
local getTraceback = debug.traceback
local loadFunction = load
local loadStringFunction = loadstring or load
local pcallFunction = pcall
local xpcallFunction = xpcall
local errorFunction = error
local typeFunction = type
local getMetatableFunction = getmetatable
local rawEqualFunction = rawequal
local toStringFunction = tostring
local toNumberFunction = tonumber
local ioLibrary = io
local osLibrary = os
local pairsFunction = pairs
local ipairsFunction = ipairs
local tableUnpackFunction = table.unpack or unpack
local proxyTable = {}
proxyTable.__index = proxyTable
local configuration = {
    MAX_DEPTH = 15,
    MAX_TABLE_ITEMS = 150,
    OUTPUT_FILE = \\"dumped_output.lua\\",
    VERBOSE = false,
    TRACE_CALLBACKS = true,
    TIMEOUT_SECONDS = 6.67,
    MAX_REPEATED_LINES = 8,
    MIN_DEOBF_LENGTH = 150,
    MAX_OUTPUT_SIZE = 2 * 1024 * 1024,
    CONSTANT_COLLECTION = true,
    INSTRUMENT_LOGIC = true
}
local inputKey = (arg and arg[3]) or \\"NoKey\\"
if arg and arg[3] then
    print(\\"[Dumper] Auto-Input Key Detected: \\" .. toStringFunction(inputKey))
end
local dumperState = {
    output = {},
    indent = 0,
    registry = {},
    reverse_registry = {},
    names_used = {},
    parent_map = {},
    property_store = {},
    call_graph = {},
    variable_types = {},
    string_refs = {},
    proxy_id = 0,
    callback_depth = 0,
    pending_iterator = false,
    last_http_url = nil,
    last_emitted_line = nil,
    repetition_count = 0,
    current_size = 0,
    ls_counter = 0
}
local _at = {
    mem          = {},
    tags         = {},
    sigs         = {},
    acts         = {},
    json         = {},
    enum         = {},
    svcCache     = {},
    typeOverride = {},
    connState    = {},
    debugIds     = {},
    debugIdCtr   = 0,
    instTags     = {},
    attrs        = {},
    children     = {},
    threadLike   = {},
    vectors      = {},
    buffers      = {},
    userdata     = {},
    localPlayer  = nil,
    weldRegistry = {},
    services     = {},
    folders      = {},
    files        = {},
    refBase      = {},
    metaHooks    = {},
    currentNamecallMethod = nil,
    inMetaHook   = false,
    pendingHeartbeat = {},
    locEntries = {},
    signalCallbacks = {},  -- AT5: live signal firing
    animateScript = nil,   -- AT3: getrunningscripts
}
setmetatable(_at.debugIds, {__mode = \\"k\\"})
setmetatable(_at.instTags, {__mode = \\"k\\"})
setmetatable(_at.attrs, {__mode = \\"k\\"})
setmetatable(_at.children, {__mode = \\"k\\"})
setmetatable(_at.threadLike, {__mode = \\"k\\"})
setmetatable(_at.vectors, {__mode = \\"k\\"})
setmetatable(_at.buffers, {__mode = \\"k\\"})
setmetatable(_at.userdata, {__mode = \\"k\\"})
setmetatable(_at.refBase, {__mode = \\"k\\"})
local function _getDebugId(p)
    if not _at.debugIds[p] then
        _at.debugIdCtr = _at.debugIdCtr + 1
        local n = _at.debugIdCtr
        _at.debugIds[p] = toStringFunction(n * 17 + 3) .. \\"-\\" .. toStringFunction(n * 97 + 11)
    end
    return _at.debugIds[p]
end
local function _removeChild(parent, child)
    local list = parent and _at.children[parent]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == child then table.remove(list, i) end
    end
end
local function _setParent(child, parent)
    local oldParent = dumperState.parent_map[child]
    if oldParent == parent then return end
    _removeChild(oldParent, child)
    dumperState.parent_map[child] = parent
    if parent then
        _at.children[parent] = _at.children[parent] or {}
        table.insert(_at.children[parent], child)
        -- skip signal firing for internal proxy types
        local childType = _at.typeOverride[child]
        local parentType = _at.typeOverride[parent]
        if childType == \\"RBXScriptSignal\\" or childType == \\"RBXScriptConnection\\"
        or parentType == \\"RBXScriptSignal\\" or parentType == \\"RBXScriptConnection\\" then
            return
        end
        -- fire ChildAdded on direct parent only
        if _at.signalCallbacks[parent] then
            for _, cb in ipairsFunction(_at.signalCallbacks[parent].ChildAdded or {}) do
                pcallFunction(cb, child)
            end
        end
        -- fire DescendantAdded on direct parent and its ancestors
        local ancestor = parent
        while ancestor do
            if _at.signalCallbacks[ancestor] then
                for _, cb in ipairsFunction(_at.signalCallbacks[ancestor].DescendantAdded or {}) do
                    pcallFunction(cb, child)
                end
            end
            ancestor = dumperState.parent_map[ancestor]
        end
    end
end
local function _isDescendantOf(child, parent)
    local cur = dumperState.parent_map[child]
    while cur do
        if cur == parent then return true end
        cur = dumperState.parent_map[cur]
    end
    return false
end
local function _getAllDescendants(root, out)
    out = out or {}
    for _, child in ipairsFunction(_at.children[root] or {}) do
        table.insert(out, child)
        _getAllDescendants(child, out)
    end
    return out
end
local numericArg = (arg and toNumberFunction(arg[4])) or (arg and toNumberFunction(arg[3])) or 123456789
local proxyMarker = {}
local function isProxyTable(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyMarker) == true end )
    return success and result
end
local function getProxyValue(target)
    if isProxyTable(target) then
        return rawget(target, \\"__value\\") or 0
    end
    return 0
end
local loadStringFunction = loadstring or load
local printFunction = print
local warnFunction = warn or function() end
local pairsFunction = pairs
local ipairsFunction = ipairs
local typeFunction = type
local toStringFunction = tostring
local proxyList = {}
local function isProxy(target)
    if typeFunction(target) ~= \\"table\\" then
        return false
    end
    local success, result = pcallFunction( function() return rawget(target, proxyList) == true end )
    return success and result
end
local function getProxyId(target)
    if not isProxy(target) then
        return nil
    end
    return rawget(target, \\"__proxy_id\\")
end
local function processString(inputString)
    if typeFunction(inputString) ~= \\"string\\" then
        return '\\"'
    end
    local outputParts = {}
    local currentIndex, totalLength = 1, #inputString
    local function cleanEscapes(content)
        return content:gsub( \\"\\\\\\\\(.)\\", function(escapedChar)
            if escapedChar:match('[abfnrtv\\\\\\\\%\'%\\\\\\"%[%]0-9xu]') then
                return \\"\\" .. escapedChar
            end
            return escapedChar
        end )
    end
    local function stripLuauSyntax(rawCode)
        if not rawCode or rawCode == \\"\\" then
            return rawCode
        end
        rawCode = rawCode:gsub(\\"\239\187\191\\", \\"\\")
        rawCode = rawCode:gsub(\\"\\r\n\\", \\"\n\\"):gsub(\\"\\r\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"\226\128\168\\", \\"\n\\"):gsub(\\"\226\128\169\\", \\"\n\\")
        rawCode = rawCode:gsub(\\"%-%-!%a+[^\n]*\\", \\"\\")
        rawCode = rawCode:gsub(\\"([^\n]*)\\", function(line)
            if line:match(\\"^%s*export%s+type%s+\\") or line:match(\\"^%s*type%s+[%a_][%w_]*%s*=\\") then
                return \\"-- \\" .. line
            end
            return line
        end)
        rawCode = rawCode:gsub(\\"local%s+([%a_][%w_]*)%s*<[%a_][%w_]*>%s*=\\", \\"local %1 =\\")
        rawCode = rawCode:gsub(\\"(function%s+[%a_][%w_%.:]*)%s*<[^>\n%(]+>%s*%(\\", \\"%1(\\")
        rawCode = rawCode:gsub(\\"([%(%s,])%.%.%.%s*:%s*[%a_][%w_%.]*%??\\", \\"%1...\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"%1%2\\")
        rawCode = rawCode:gsub(\\"([%(%s,])([%a_][%w_]*)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\"%1%2%3\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%s*%b<>%??\\", \\")\\")
        rawCode = rawCode:gsub(\\"%)%s*:%s*[%a_][%w_%.]*%??(%s*[%),=])\\", \\")%1\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%s*%b<>%??\\", \\"\\")
        rawCode = rawCode:gsub(\\"%s*::%s*[%a_][%w_%.]*%??\\", \\"\\")
        return rawCode
    end
    local function parseExpression(rawCode)
        if not rawCode or rawCode == '\\"' then
            return \\"\\"
        end
        rawCode = stripLuauSyntax(rawCode)
        rawCode = rawCode:gsub( \\"0[bB]([01_]+)\\", function(binaryString)
            local cleanBinary = binaryString:gsub(\\"_\\", \\"\\")
            local decimalValue = toNumberFunction(cleanBinary, 2)
            return decimalValue and toStringFunction(decimalValue) or \\"0\\"
        end )
        rawCode = rawCode:gsub( \\"0[xX]([%x_]+)\\", function(hexString)
            local cleanHex = hexString:gsub(\\"_\\", \\"\\")
            return \\"0x\\" .. cleanHex
        end )
        while rawCode:match(\\"%d_+%d\\") do
            rawCode = rawCode:gsub(\\"(%d)_+(%d)\\", \\"%1%2\\")
        end
        local operators = {{\\"+=\\", \\"+\\"}, {\\"-=\\", \\"-\\"}, {\\"*=\\", \\"*\\"}, {\\"/=\\", \\"/\\"}, {\\"%%=\\", \\"%%\\"}, {\\"%^=\\", \\"^\\"}, {\\"%.%.=\\", \\"..\\"}}
        for _, opPair in ipairsFunction(operators) do
            local operatorAssignment, operator = opPair[1], opPair[2]
            -- simple var: x+=1 -> x = x + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- dot chain: x.y.z+=1 -> x.y.z = x.y.z + 1
            rawCode = rawCode:gsub( \\"([%a_][%w_]*%.[%a_][%w_%.]+)%s*\\" .. operatorAssignment, function(varName)
                return varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
            end )
            -- bracket chain: R[m]+=q, T[1][2]+=q, obj[\\"k\\"][i]+=q
            -- manually find identifier + full bracket chain before the operator
            local escOp = operatorAssignment:gsub(\\"([%.%+%-%*%/%^%%])\\", \\"%%%1\\")
            rawCode = rawCode:gsub(\\"([%a_][%w_]*)(%b[])\\", function(name, firstBracket)
                -- check if after firstBracket there are more brackets then the operator
                return name .. firstBracket
            end)
            -- proper scan: replace lval+= where lval is ident + bracket chain
            do
                local result = {}
                local i = 1
                local len = #rawCode
                while i <= len do
                    -- look for identifier start
                    local idStart, idEnd = rawCode:find(\\"[%a_][%w_]*\\", i)
                    if not idStart then
                        result[#result+1] = rawCode:sub(i)
                        break
                    end
                    result[#result+1] = rawCode:sub(i, idStart-1)
                    local varName = rawCode:match(\\"[%a_][%w_]*\\", idStart)
                    local pos = idStart + #varName
                    -- consume bracket chains
                    while pos <= len and rawCode:sub(pos,pos) == \\"[\\" do
                        local _, bEnd = rawCode:find(\\"%b[]\\", pos)
                        if not bEnd then break end
                        varName = varName .. rawCode:sub(pos, bEnd)
                        pos = bEnd + 1
                    end
                    -- check for operator after optional whitespace
                    local wsEnd = pos
                    while wsEnd <= len and rawCode:sub(wsEnd,wsEnd):match(\\"%s\\") do wsEnd=wsEnd+1 end
                    local opMatch = rawCode:sub(wsEnd, wsEnd + #operatorAssignment - 1)
                    if opMatch == operatorAssignment and varName:find(\\"%[\\") then
                        -- rewrite: varName op= ... -> varName = varName op ...
                        result[#result+1] = varName .. \\" = \\" .. varName .. \\" \\" .. operator .. \\" \\"
                        i = wsEnd + #operatorAssignment
                    else
                        result[#result+1] = varName
                        i = pos
                    end
                end
                rawCode = table.concat(result)
            end
        end
        rawCode = rawCode:gsub(\\"([^%w_])continue([^%w_])\\", \\"%1__LC__()%2\\")
        rawCode = rawCode:gsub(\\"^continue([^%w_])\\", \\"__LC__()%1\\")
        rawCode = rawCode:gsub(\\"([^%w_])continue$\\", \\"%1__LC__()\\")
        return rawCode
    end
    local function getBracketCount(index)
        local count = 0
        while index <= totalLength and inputString:byte(index) == 61 do
            count = count + 1
            index = index + 1
        end
        return count, index
    end
    local function findClosingBracket(startIndex, bracketCount)
        local closingPattern = \\"]\\" .. string.rep(\\"=\\", bracketCount) .. \\"]\\"
        local start, finish = inputString:find(closingPattern, startIndex, true)
        return finish or totalLength
    end
    local segmentStart = 1
    while currentIndex <= totalLength do
        local byteValue = inputString:byte(currentIndex)
        if byteValue == 91 then
            local bracketCount, nextIndex = getBracketCount(currentIndex + 1)
            if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
                local startSegment = currentIndex
                local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                table.insert(outputParts, inputString:sub(startSegment, endSegment))
                currentIndex = endSegment
                segmentStart = currentIndex + 1
            end
        elseif byteValue == 45 and currentIndex + 1 <= totalLength and inputString:byte(currentIndex + 1) == 45 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local startSegment = currentIndex
            if currentIndex + 2 <= totalLength and inputString:byte(currentIndex + 2) == 91 then
                local bracketCount, nextIndex = getBracketCount(currentIndex + 3)
                if nextIndex <= totalLength and inputString:byte(nextIndex) == 91 then
                    local endSegment = findClosingBracket(nextIndex + 1, bracketCount)
                    table.insert(outputParts, inputString:sub(startSegment, endSegment))
                    currentIndex = endSegment
                    segmentStart = currentIndex + 1
                    currentIndex = currentIndex + 1
                end
            end
            local lineBreak = inputString:find(\\"\n\\", currentIndex + 2, true)
            if lineBreak then
                currentIndex = lineBreak
            else
                currentIndex = totalLength
            end
            table.insert(outputParts, inputString:sub(startSegment, currentIndex))
            segmentStart = currentIndex + 1
        elseif byteValue == 34 or byteValue == 39 or byteValue == 96 then
            table.insert(outputParts, parseExpression(inputString:sub(segmentStart, currentIndex - 1)))
            local quoteType = byteValue
            local startSegment = currentIndex
            currentIndex = currentIndex + 1
            while currentIndex <= totalLength do
                local charByte = inputString:byte(currentIndex)
                if charByte == 92 then
                    currentIndex = currentIndex + 1
                elseif charByte == quoteType then
                    break
                end
                currentIndex = currentIndex + 1
            end
            local extractedContent = inputString:sub(startSegment + 1, currentIndex - 1)
            extractedContent = cleanEscapes(extractedContent)
            if quoteType == 96 then
                table.insert(outputParts, '\\"' .. extractedContent:gsub('\\"', '\\\\\\\\\\"') .. '\\"')
            else
                local quoteChar = string.char(quoteType)
                table.insert(outputParts, quoteChar .. extractedContent .. quoteChar)
            end
            segmentStart = currentIndex + 1
        end
        currentIndex = currentIndex + 1
    end
    table.insert(outputParts, parseExpression(inputString:sub(segmentStart)))
    return table.concat(outputParts)
end
local function safeLoad(code, chunkName)
    local loadedFunc, errorMessage = loadStringFunction(code, chunkName)
    if loadedFunc then
        return loadedFunc
    end
    printFunction(\\"\n[CRITICAL ERROR] Failed to load script!\\")
    printFunction(\\"[LUA_LOAD_FAIL] \\" .. toStringFunction(errorMessage))
    local errorLine = toNumberFunction(errorMessage:match(\\":(%d+):\\"))
    local errorNear = errorMessage:match(\\"near '([^']+)'\\")
    if errorNear then
        local foundIndex = code:find(errorNear, 1, true)
        if foundIndex then
            local startCtx = math.max(1, foundIndex - 50)
            local endCtx = math.min(#code, foundIndex + 50)
            printFunction(\\"Context around error:\\")
            printFunction(\\"...\\" .. code:sub(startCtx, endCtx) .. \\"...\\")
        end
    end
    local debugFile = ioLibrary.open(\\"DEBUG_FAILED_TRANSPILE.lua\\", \\"w\\")
    if debugFile then
        debugFile:write(code)
        debugFile:close()
        printFunction(\\"[*] Saved to 'DEBUG_FAILED_TRANSPILE.lua' for inspection\\")
    end
    return nil, errorMessage
end
local function emitOutput(data, isInline)
    if dumperState.limit_reached then
        return
    end
    if data == nil then
        return
    end
    local indentPrefix = isInline and \\"\\" or string.rep(\\"    \\", dumperState.indent)
    local lineString = indentPrefix .. toStringFunction(data)
    local lineSize = #lineString + 1
    if dumperState.current_size + lineSize > configuration.MAX_OUTPUT_SIZE then
        dumperState.limit_reached = true
        local warningMessage = \\"-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.\\"
        table.insert(dumperState.output, warningMessage)
        dumperState.current_size = dumperState.current_size + #warningMessage
        errorFunction(\\"DUMP_LIMIT_EXCEEDED\\")
    end
    if lineString == dumperState.last_emitted_line then
        dumperState.repetition_count = dumperState.repetition_count + 1
        if dumperState.repetition_count <= configuration.MAX_REPEATED_LINES then
            table.insert(dumperState.output, lineString)
            dumperState.current_size = dumperState.current_size + lineSize
        elseif dumperState.repetition_count == configuration.MAX_REPEATED_LINES + 1 then
            local suppressMessage = indentPrefix .. \\"-- [Repeated lines suppressed...]\\"
            table.insert(dumperState.output, suppressMessage)
            dumperState.current_size = dumperState.current_size + #suppressMessage
        end
    else
        dumperState.last_emitted_line = lineString
        dumperState.repetition_count = 0
        table.insert(dumperState.output, lineString)
        dumperState.current_size = dumperState.current_size + lineSize
    end
    if configuration.VERBOSE and dumperState.repetition_count <= 1 then
        printFunction(lineString)
    end
end
local function emitComment(data)
    emitOutput(\\"-- \\" .. toStringFunction(data or \\"\\"))
end
local function addEmptyLine()
    dumperState.last_emitted_line = nil
    table.insert(dumperState.output, \\"\\")
end
local function getFullOutput()
    return table.concat(dumperState.output, \\"\n\\")
end
local function saveToFile(filePath)
    local fileHandle = ioLibrary.open(filePath or configuration.OUTPUT_FILE, \\"w\\")
    if fileHandle then
        fileHandle:write(getFullOutput())
        fileHandle:close()
        return true
    end
    return false
end
local function formatValue(value)
    if value == nil then
        return \\"nil\\"
    end
    if typeFunction(value) == \\"string\\" then
        return value
    end
    if typeFunction(value) == \\"number\\" or typeFunction(value) == \\"boolean\\" then
        return toStringFunction(value)
    end
    if typeFunction(value) == \\"table\\" then
        if dumperState.registry[value] then
            return dumperState.registry[value]
        end
        if isProxy(value) then
            local proxyId = getProxyId(value)
            return proxyId and \\"proxy_\\" .. proxyId or \\"proxy\\"
        end
    end
    local success, result = pcallFunction(toStringFunction, value)
    return success and result or \\"unknown\\"
end
local function formatStringLiteral(value)
    local rawValue = formatValue(value)
    local escapedValue = rawValue:gsub(\\"\\\\\\\\\\", \\"\\\\\\\\\\\\\\\\\\"):gsub('\\"', '\\\\\\\\\\"'):gsub(\\"\n\\", \\"\n\\"):gsub(\\"\\\\\r\\", \\"\\\\\\\\\r\\"):gsub(\\"\\\\\t\\", \\"\\\\\\\\\t\\")
    return '\\"' .. escapedValue .. '\\"'
end
local serviceNames = {
    Players = \\"Players\\",
    Workspace = \\"Workspace\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    ServerStorage = \\"ServerStorage\\",
    ServerScriptService = \\"ServerScriptService\\",
    StarterGui = \\"StarterGui\\",
    StarterPack = \\"StarterPack\\",
    StarterPlayer = \\"StarterPlayer\\",
    Lighting = \\"Lighting\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    RunService = \\"RunService\\",
    UserInputService = \\"UserInputService\\",
    TweenService = \\"TweenService\\",
    GroupService = \\"GroupService\\",
    AnimationClipProvider = \\"AnimationClipProvider\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    TeleportService = \\"TeleportService\\",
    PathfindingService = \\"PathfindingService\\",
    CollectionService = \\"CollectionService\\",
    PhysicsService = \\"PhysicsService\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    GuiService = \\"GuiService\\",
    HapticService = \\"HapticService\\",
    VRService = \\"VRService\\",
    CoreGui = \\"CoreGui\\",
    Teams = \\"Teams\\",
    InsertService = \\"InsertService\\",
    DataStoreService = \\"DataStoreService\\",
    MessagingService = \\"MessagingService\\",
    TextService = \\"TextService\\",
    TextChatService = \\"TextChatService\\",
    NetworkClient = \\"NetworkClient\\",
    ContentProvider = \\"ContentProvider\\",
    Debris = \\"Debris\\",
    MemStorageService = \\"MemStorageService\\",
    ChangeHistoryService = \\"ChangeHistoryService\\",
    PlayerEmulatorService = \\"PlayerEmulatorService\\",
    StylingService = \\"StylingService\\",
    ScriptContext = \\"ScriptContext\\",
    LocalizationService = \\"LocalizationService\\",
    PolicyService = \\"PolicyService\\",
    CaptureService = \\"CaptureService\\",
    AnalyticsService = \\"AnalyticsService\\",
    EncodingService = \\"EncodingService\\",
    CorePackages = \\"CorePackages\\",
    RobloxReplicatedStorage = \\"RobloxReplicatedStorage\\",
    RobloxGui = \\"RobloxGui\\",
    AvatarEditorService = \\"AvatarEditorService\\",
    SocialService = \\"SocialService\\",
    VoiceChatService = \\"VoiceChatService\\",
    AdService = \\"AdService\\",
    GeometryService = \\"GeometryService\\",
    AssetService = \\"AssetService\\",
    LocalizationService = \\"LocalizationService\\",
    NotificationService = \\"NotificationService\\",
    ProcessInstancePhysicsService = \\"ProcessInstancePhysicsService\\",
    FriendService = \\"FriendService\\",
    SessionService = \\"SessionService\\",
    TimerService = \\"TimerService\\",
    TouchInputService = \\"TouchInputService\\",
    GamepadService = \\"GamepadService\\",
    KeyboardService = \\"KeyboardService\\",
    MouseService = \\"MouseService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceService = \\"PerformanceService\\",
    PlatformFriendService = \\"PlatformFriendService\\",
    ReplicatedFirst = \\"ReplicatedFirst\\",
    SpawnLocation = \\"SpawnLocation\\",
    LogService = \\"LogService\\",
    Stats = \\"Stats\\",
    TweenService = \\"TweenService\\",
    Debris = \\"Debris\\",
    CoreGui = \\"CoreGui\\",
    MarketplaceService = \\"MarketplaceService\\",
    NotificationService = \\"NotificationService\\",
    GuidRegistryService = \\"GuidRegistryService\\",
    NetworkServer = \\"NetworkServer\\",
    Geometry = \\"Geometry\\",
    VirtualInputManager = \\"VirtualInputManager\\",
    MLModelDeliveryService = \\"MLModelDeliveryService\\",
    PartyEmulatorService = \\"PartyEmulatorService\\",
    PlatformFriendsService = \\"PlatformFriendsService\\",
    FriendService = \\"FriendService\\",
    OmniRecommendationsService = \\"OmniRecommendationsService\\",
    PerformanceControlService = \\"PerformanceControlService\\",
    RbxAnalyticsService = \\"RbxAnalyticsService\\",
    AbuseReportService = \\"AbuseReportService\\",
    AdService = \\"AdService\\",
    AdPortalService = \\"AdPortalService\\",
    AppUpdateService = \\"AppUpdateService\\",
    BrowserService = \\"BrowserService\\",
    CookiesService = \\"CookiesService\\",
    CoreGui = \\"CoreGui\\",
    GamesService = \\"GamesService\\",
    KeyboardService = \\"KeyboardService\\",
    MarketplaceService = \\"MarketplaceService\\",
    MouseService = \\"MouseService\\",
    NotificationService = \\"NotificationService\\",
    PurchaseDataService = \\"PurchaseDataService\\",
    TimerService = \\"TimerService\\",
    UGCValidationService = \\"UGCValidationService\\",
}
local serviceShortcuts = {
    Players = \\"Players\\",
    UserInputService = \\"UIS\\",
    RunService = \\"RunService\\",
    ReplicatedStorage = \\"ReplicatedStorage\\",
    TweenService = \\"TweenService\\",
    Workspace = \\"Workspace\\",
    Lighting = \\"Lighting\\",
    StarterGui = \\"StarterGui\\",
    CoreGui = \\"CoreGui\\",
    HttpService = \\"HttpService\\",
    MarketplaceService = \\"MarketplaceService\\",
    DataStoreService = \\"DataStoreService\\",
    TeleportService = \\"TeleportService\\",
    SoundService = \\"SoundService\\",
    Chat = \\"Chat\\",
    Teams = \\"Teams\\",
    ProximityPromptService = \\"ProximityPromptService\\",
    ContextActionService = \\"ContextActionService\\",
    CollectionService = \\"CollectionService\\",
    PathfindingService = \\"PathfindingService\\",
    Debris = \\"Debris\\"
}
local classParents = {
    DataModel = {\\"DataModel\\", \\"ServiceProvider\\", \\"Instance\\"},
    Workspace = {\\"Workspace\\", \\"WorldRoot\\", \\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Camera = {\\"Camera\\", \\"Instance\\"},
    Players = {\\"Players\\", \\"Instance\\"},
    Player = {\\"Player\\", \\"Instance\\"},
    PlayerGui = {\\"PlayerGui\\", \\"BasePlayerGui\\", \\"Instance\\"},
    Backpack = {\\"Backpack\\", \\"Instance\\"},
    PlayerScripts = {\\"PlayerScripts\\", \\"Instance\\"},
    Folder = {\\"Folder\\", \\"Instance\\"},
    Model = {\\"Model\\", \\"PVInstance\\", \\"Instance\\"},
    Part = {\\"Part\\", \\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    BasePart = {\\"BasePart\\", \\"PVInstance\\", \\"Instance\\"},
    ModuleScript = {\\"ModuleScript\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    LocalScript = {\\"LocalScript\\", \\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Script = {\\"Script\\", \\"LuaSourceContainer\\", \\"Instance\\"},
    Humanoid = {\\"Humanoid\\", \\"Instance\\"},
    SoundService = {\\"SoundService\\", \\"Instance\\"},
    Lighting = {\\"Lighting\\", \\"Instance\\"},
    HttpService = {\\"HttpService\\", \\"Instance\\"},
    TweenService = {\\"TweenService\\", \\"Instance\\"},
    RunService = {\\"RunService\\", \\"Instance\\"},
    TextService = {\\"TextService\\", \\"Instance\\"},
    GuiService = {\\"GuiService\\", \\"Instance\\"},
    ContentProvider = {\\"ContentProvider\\", \\"Instance\\"},
    CollectionService = {\\"CollectionService\\", \\"Instance\\"},
    MemStorageService = {\\"MemStorageService\\", \\"Instance\\"},
    NetworkClient = {\\"NetworkClient\\", \\"Instance\\"},
    ClientReplicator = {\\"ClientReplicator\\", \\"Instance\\"},
}
local function classIsA(className, targetClass)
    if className == targetClass then return true end
    local parents = classParents[className] or {className, \\"Instance\\"}
    for _, parentName in ipairsFunction(parents) do
        if parentName == targetClass then return true end
    end
    return false
end
local uiNamingConvention = {
    {pattern = \\"window\\", prefix = \\"Window\\", counter = \\"window\\"},
    {pattern = \\"tab\\", prefix = \\"Tab\\", counter = \\"tab\\"},
    {pattern = \\"section\\", prefix = \\"Section\\", counter = \\"section\\"},
    {pattern = \\"button\\", prefix = \\"Button\\", counter = \\"button\\"},
    {pattern = \\"toggle\\", prefix = \\"Toggle\\", counter = \\"toggle\\"},
    {pattern = \\"slider\\", prefix = \\"Slider\\", counter = \\"slider\\"},
    {pattern = \\"dropdown\\", prefix = \\"Dropdown\\", counter = \\"dropdown\\"},
    {pattern = \\"textbox\\", prefix = \\"Textbox\\", counter = \\"textbox\\"},
    {pattern = \\"input\\", prefix = \\"Input\\", counter = \\"input\\"},
    {pattern = \\"label\\", prefix = \\"Label\\", counter = \\"label\\"},
    {pattern = \\"keybind\\", prefix = \\"Keybind\\", counter = \\"keybind\\"},
    {pattern = \\"colorpicker\\", prefix = \\"ColorPicker\\", counter = \\"colorpicker\\"},
    {pattern = \\"paragraph\\", prefix = \\"Paragraph\\", counter = \\"paragraph\\"},
    {pattern = \\"notification\\", prefix = \\"Notification\\", counter = \\"notification\\"},
    {pattern = \\"divider\\", prefix = \\"Divider\\", counter = \\"divider\\"},
    {pattern = \\"bind\\", prefix = \\"Bind\\", counter = \\"bind\\"},
    {pattern = \\"picker\\", prefix = \\"Picker\\", counter = \\"picker\\"}
}
local uiCounters = {}
local function getUiCounter(name)
    uiCounters[name] = (uiCounters[name] or 0) + 1
    return uiCounters[name]
end
local function resolveVariableName(obj, originalName, hintString)
    if not obj then
        obj = \\"var\\"
    end
    local formattedName = formatValue(obj)
    if serviceShortcuts[formattedName] then
        return serviceShortcuts[formattedName]
    end
    if hintString then
        local lowerHint = hintString:lower()
        for _, patternEntry in ipairsFunction(uiNamingConvention) do
            if lowerHint:find(patternEntry.pattern) then
                local counter = getUiCounter(patternEntry.counter)
                return counter == 1 and patternEntry.prefix or patternEntry.prefix .. counter
            end
        end
    end
    if formattedName == \\"LocalPlayer\\" then
        return \\"LocalPlayer\\"
    end
    if formattedName == \\"Character\\" then
        return \\"Character\\"
    end
    if formattedName == \\"Humanoid\\" then
        return \\"Humanoid\\"
    end
    if formattedName == \\"HumanoidRootPart\\" then
        return \\"HumanoidRootPart\\"
    end
    if formattedName == \\"Camera\\" then
        return \\"Camera\\"
    end
    if formattedName:match(\\"^Enum%.\\") then
        return formattedName
    end
    local sanitizedName = formattedName:gsub(\\"[^%w_]\\", '\\"'):gsub(\\"^%d+\\", '\\"')
    if sanitizedName == '\\"' or sanitizedName == \\"Object\\" or sanitizedName == \\"Value\\" or sanitizedName == \\"result\\" then
        sanitizedName = \\"var\\"
    end
    return sanitizedName
end
local function registerVariable(obj, objName, varType, hintString)
    local existing = dumperState.registry[obj]
    if existing and existing:match(\\"^v%d+$\\") then
        return existing
    end
    dumperState.ls_counter = (dumperState.ls_counter or 0) + 1
    local newName = \\"v\\" .. dumperState.ls_counter
    dumperState.names_used[newName] = true
    dumperState.registry[obj] = newName
    dumperState.reverse_registry[newName] = obj
    dumperState.variable_types[newName] = varType or typeFunction(obj)
    return newName
end
local function serializeValue(obj, depth, visited, allowInline)
    depth = depth or 0
    visited = visited or {}
    if depth > configuration.MAX_DEPTH then
        return \\"{ --[[max depth]] }\\"
    end
    local valueType = typeFunction(obj)
    if isProxyTable(obj) then
        local proxyValue = rawget(obj, \\"__value\\")
        return toStringFunction(proxyValue or 0)
    end
    if valueType == \\"table\\" and dumperState.registry[obj] then
        return dumperState.registry[obj]
    end
    if valueType == \\"nil\\" then
        return \\"nil\\"
    elseif valueType == \\"string\\" then
        if #obj > 100 and obj:match(\\"^[A-Za-z0-9+/=]+$\\") then
            table.insert(dumperState.string_refs, {value = obj:sub(1, 50) .. \\"...\\", hint = \\"base64\\", full_length = #obj})
        elseif obj:match(\\"https?://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"URL\\"})
        elseif obj:match(\\"rbxasset://\\") or obj:match(\\"rbxassetid://\\") then
            table.insert(dumperState.string_refs, {value = obj, hint = \\"Asset\\"})
        end
        return formatStringLiteral(obj)
    elseif valueType == \\"number\\" then
        if obj ~= obj then
            return \\"0/0\\"
        end
        if obj == math.huge then
            return \\"math.huge\\"
        end
        if obj == -math.huge then
            return \\"-math.huge\\"
        end
        if obj == math.floor(obj) then
            return toStringFunction(math.floor(obj))
        end
        return string.format(\\"%.6g\\", obj)
    elseif valueType == \\"boolean\\" then
        return toStringFunction(obj)
    elseif valueType == \\"function\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        return \\"function() end\\"
    elseif valueType == \\"table\\" then
        if isProxy(obj) then
            return dumperState.registry[obj] or \\"proxy\\"
        end
        if visited[obj] then
            return \\"{ --[[circular]] }\\"
        end
        visited[obj] = true
        local count = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                count = count + 1
            end
        end
        if count == 0 then
            return \\"{}\\"
        end
        local isSequence = true
        local maxIdx = 0
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                if typeFunction(k) ~= \\"number\\" or k < 1 or k ~= math.floor(k) then
                    isSequence = false
                    break
                else
                    maxIdx = math.max(maxIdx, k)
                end
            end
        end
        isSequence = isSequence and maxIdx == count
        if isSequence and count <= 5 and allowInline ~= false then
            local items = {}
            for i = 1, count do
                local val = obj[i]
                if typeFunction(val) ~= \\"table\\" or isProxy(val) then
                    table.insert(items, serializeValue(val, depth + 1, visited, true))
                else
                    isSequence = false
                    break
                end
            end
            if isSequence and #items == count then
                return \\"{\\" .. table.concat(items, \\", \\") .. \\"}\\"
            end
        end
        local output = {}
        local itemCount = 0
        local indent = string.rep(\\"    \\", dumperState.indent + depth + 1)
        local baseIndent = string.rep(\\"    \\", dumperState.indent + depth)
        for k, v in pairsFunction(obj) do
            if k ~= proxyList and k ~= \\"__proxy_id\\" then
                itemCount = itemCount + 1
                if itemCount > configuration.MAX_TABLE_ITEMS then
                    table.insert(output, indent .. \\"-- ...\\" .. count - itemCount + 1 .. \\" more\\")
                    break
                end
                local keyStr
                if isSequence then
                    keyStr = nil
                elseif typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                    keyStr = k
                else
                    keyStr = \\"[\\" .. serializeValue(k, depth + 1, visited) .. \\"]\\"
                end
                local valStr = serializeValue(v, depth + 1, visited)
                if keyStr then
                    table.insert(output, indent .. keyStr .. \\" = \\" .. valStr)
                else
                    table.insert(output, indent .. valStr)
                end
            end
        end
        if #output == 0 then
            return \\"{}\\"
        end
        return \\"{\n\\" .. table.concat(output, \\",\n\\") .. \\"\n\\" .. baseIndent .. \\"}\\"
    elseif valueType == \\"userdata\\" then
        if dumperState.registry[obj] then
            return dumperState.registry[obj]
        end
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"userdata\\"
    elseif valueType == \\"thread\\" then
        return \\"coroutine.create(function() end)\\"
    else
        local success, result = pcallFunction(toStringFunction, obj)
        return success and result or \\"nil\\"
    end
end
local proxyStore = {}
setmetatable(proxyStore, {__mode = \\"k\\"})
local function createProxy()
    local proxy = {}
    proxyStore[proxy] = true
    local meta = {}
    setmetatable(proxy, meta)
    return proxy, meta
end
local function isProxy(obj)
    return proxyStore[obj] == true
end
local createProxyObject
local createProxyMethod
-- ContentId type for AT6 (SurfaceAppearance.ColorMap etc)
local function _makeContentId(val)
    val = val or \\"\\"
    return setmetatable({_value = val}, {
        __typeof = \\"ContentId\\",
        __tostring = function() return val end,
        __eq = function(a, b)
            local av = typeFunction(a) == \\"table\\" and rawget(a, \\"_value\\") or a
            local bv = typeFunction(b) == \\"table\\" and rawget(b, \\"_value\\") or b
            return av == bv
        end,
        __index = function(t, k) if k == \\"_value\\" then return val end end,
    })
end
local _makeVector3
local _makeCFrame
local function createProxyInstance(bm)
    local proxy, meta = createProxy()
    rawset(proxy, proxyMarker, true)
    rawset(proxy, \\"__value\\", bm)
    dumperState.registry[proxy] = toStringFunction(bm)
    meta.__tostring = function() return toStringFunction(bm) end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" or key == proxyMarker or key == \\"__value\\" then
            return rawget(tbl, key)
        end
        return createProxyInstance(0)
    end
    meta.__newindex = function() end
    meta.__call = function() return bm end
    local function op(symbol)
        return function(a, b)
            local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a or 0
            local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b or 0
            local res
            if symbol == \\"+\\" then res = valA + valB
            elseif symbol == \\"-\\" then res = valA - valB
            elseif symbol == \\"*\\" then res = valA * valB
            elseif symbol == \\"/\\" then res = valB ~= 0 and valA / valB or 0
            elseif symbol == \\"%\\" then res = valB ~= 0 and valA % valB or 0
            elseif symbol == \\"^\\" then res = valA ^ valB
            else res = 0 end
            return createProxyInstance(res)
        end
    end
    meta.__add = op(\\"+\\")
    meta.__sub = op(\\"-\\")
    meta.__mul = op(\\"*\\")
    meta.__div = op(\\"/\\")
    meta.__mod = op(\\"%\\")
    meta.__pow = op(\\"^\\")
    meta.__unm = function(a) return createProxyInstance(-(rawget(a, \\"__value\\") or 0)) end
    meta.__eq = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA == valB
    end
    meta.__lt = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA < valB
    end
    meta.__le = function(a, b)
        local valA = typeFunction(a) == \\"table\\" and rawget(a, \\"__value\\") or a
        local valB = typeFunction(b) == \\"table\\" and rawget(b, \\"__value\\") or b
        return valA <= valB
    end
    meta.__len = function() return 0 end
    return proxy
end
local function executeFunction(func, args)
    if typeFunction(func) ~= \\"function\\" then
        return {}
    end
    local outputCount = #dumperState.output
    local previousIteratorState = dumperState.pending_iterator
    dumperState.pending_iterator = false
    xpcallFunction( function() func(table.unpack(args or {})) end, function() end )
    while dumperState.pending_iterator do
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end\\")
        dumperState.pending_iterator = false
    end
    dumperState.pending_iterator = previousIteratorState
    local capturedLines = {}
    for i = outputCount + 1, #dumperState.output do
        table.insert(capturedLines, dumperState.output[i])
    end
    for i = #dumperState.output, outputCount + 1, -1 do
        table.remove(dumperState.output, i)
    end
    return capturedLines
end
createProxyMethod = function(methodName, parentProxy)
    local proxy, meta = createProxy()
    rawset(proxy, \\"__is_method\\", true)
    local parentName = dumperState.registry[parentProxy] or \\"object\\"
    local methodSignature = formatValue(methodName)
    dumperState.registry[proxy] = parentName .. \\".\\" .. methodSignature
    meta.__call = function(self, firstArg, ...)
        local args
        if firstArg == proxy or firstArg == parentProxy or isProxy(firstArg) then
            args = {...}
        else
            args = {firstArg, ...}
        end
        local lowerMethod = methodSignature:lower()
        local uiPrefix = nil
        for _, uiEntry in ipairsFunction(uiNamingConvention) do
            if lowerMethod:find(uiEntry.pattern) then
                uiPrefix = uiEntry.prefix
                break
            end
        end
        local callbackFunc, callbackKey, callbackIndex = nil, nil, nil
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"function\\" then
                callbackFunc = val
                break
            elseif typeFunction(val) == \\"table\\" and not isProxy(val) then
                for k, v in pairsFunction(val) do
                    local keyStr = toStringFunction(k):lower()
                    if keyStr == \\"callback\\" and typeFunction(v) == \\"function\\" then
                        callbackFunc = v
                        callbackKey = k
                        callbackIndex = i
                        break
                    end
                end
            end
        end
        local defaultParam, dummyArgs = \\"value\\", {}
        if callbackFunc then
            if lowerMethod:match(\\"toggle\\") then
                defaultParam = \\"enabled\\"
                dummyArgs = {true}
            elseif lowerMethod:match(\\"slider\\") then
                defaultParam = \\"value\\"
                dummyArgs = {50}
            elseif lowerMethod:match(\\"dropdown\\") then
                defaultParam = \\"selected\\"
                dummyArgs = {\\"Option\\"}
            elseif lowerMethod:match(\\"textbox\\") or lowerMethod:match(\\"input\\") then
                defaultParam = \\"text\\"
                dummyArgs = {inputKey or \\"input\\"}
            elseif lowerMethod:match(\\"keybind\\") or lowerMethod:match(\\"bind\\") then
                defaultParam = \\"key\\"
                dummyArgs = {createProxyObject(\\"Enum.KeyCode.E\\", false)}
            elseif lowerMethod:match(\\"color\\") then
                defaultParam = \\"color\\"
                dummyArgs = {Color3.fromRGB(255, 255, 255)}
            elseif lowerMethod:match(\\"button\\") then
                defaultParam = \\"\\\\\\"
                dummyArgs = {}
            end
        end
        local callbackLines = {}
        if callbackFunc then
            callbackLines = executeFunction(callbackFunc, dummyArgs)
        end
        local newProxy = createProxyObject(uiPrefix or methodSignature, false, parentProxy)
        local varName = registerVariable(newProxy, uiPrefix or methodSignature, nil, methodSignature)
        local argStrings = {}
        for i, val in ipairsFunction(args) do
            if typeFunction(val) == \\"table\\" and not isProxy(val) and i == callbackIndex then
                local tableParts = {}
                for k, v in pairsFunction(val) do
                    local keyStr
                    if typeFunction(k) == \\"string\\" and k:match(\\"^[%a_][%w_]*$\\") then
                        keyStr = k
                    else
                        keyStr = \\"[\\" .. serializeValue(k) .. \\"]\\"
                    end
                    if k == callbackKey and #callbackLines > 0 then
                        local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. \\"bI\\" .. \\")\\" or \\"function()\\"
                        local indent = string.rep(\\"    \\", dumperState.indent + 2)
                        local funcBody = {}
                        for _, line in ipairsFunction(callbackLines) do
                            table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                        end
                        local baseIndent = string.rep(\\"    \\", dumperState.indent + 1)
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. baseIndent .. \\"end\\")
                    elseif k == callbackKey then
                        local funcDef = defaultParam ~= \\"\\\\\\" and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                        table.insert(tableParts, keyStr .. \\" = \\" .. funcDef)
                    else
                        table.insert(tableParts, keyStr .. \\" = \\" .. serializeValue(v))
                    end
                end
                table.insert(argStrings, \\"{\n\\" .. string.rep(\\"    \\", dumperState.indent + 1) .. table.concat(tableParts, \\",\n\\" .. string.rep(\\"    \\", dumperState.indent + 1)) .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"}\\")
            elseif typeFunction(val) == \\"function\\" then
                if #callbackLines > 0 then
                    local funcSignature = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\")\\" or \\"function()\\"
                    local indent = string.rep(\\"    \\", dumperState.indent + 1)
                    local funcBody = {}
                    for _, line in ipairsFunction(callbackLines) do
                        table.insert(funcBody, indent .. (line:match(\\"^%s*(.*)$\\") or line))
                    end
                    table.insert(argStrings, funcSignature .. \\"\n\\" .. table.concat(funcBody, \\"\n\\") .. \\"\n\\" .. string.rep(\\"    \\", dumperState.indent) .. \\"end\\")
                else
                    local funcDef = defaultParam ~= '\\"' and \\"function(\\" .. defaultParam .. \\") end\\" or \\"function() end\\"
                    table.insert(argStrings, funcDef)
                end
            else
                table.insert(argStrings, serializeValue(val))
            end
        end
        emitOutput(string.format(\\"local %s = %s:%s(%s)\\", varName, parentName, methodSignature, table.concat(argStrings, \\", \\")))
        return newProxy
    end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        return createProxyMethod(key, proxy)
    end
    meta.__tostring = function() return parentName .. \\":\\" .. methodSignature end
    meta.__index = function(tbl, key)
        local chainName = (dumperState.registry[proxy] or methodSignature) .. \\".\\" .. tostring(key)
        local childProxy = createProxyObject(key, false, nil)
        dumperState.registry[childProxy] = chainName
        local knownClassNames = {
            SetBlockedUserIdsRequest = \\"RemoteEvent\\",
            AtomicBinding = \\"BindableEvent\\",
        }
        if knownClassNames[key] then
            dumperState.property_store[childProxy] = dumperState.property_store[childProxy] or {}
            dumperState.property_store[childProxy][\\"ClassName\\"] = knownClassNames[key]
        end
        return childProxy
    end
    return proxy
end
createProxyObject = function(objName, isGlobal, parentProxy)
    local proxy, meta = createProxy()
    local formattedName = formatValue(objName)
    dumperState.property_store[proxy] = {}
    if isGlobal then
        dumperState.registry[proxy] = formattedName
        dumperState.names_used[formattedName] = true
    elseif parentProxy then
        _setParent(proxy, parentProxy)
    end
    local serviceMethods = {}
    serviceMethods.GetService = function(self, serviceName)
        local resolvedName = formatValue(serviceName)
        -- strip null bytes (anti-tamper trick)
        resolvedName = string.gsub(resolvedName, \\"%z\\", \\"\\")
        if resolvedName == \\"Workspace\\" then
            return workspace
        end
        if not serviceNames[resolvedName] or resolvedName == \\"DebuggerManager\\" then
            errorFunction(\\"Service not available\\", 0)
        end
        local serviceProxy = _at.svcCache[resolvedName]
        if not serviceProxy then
            serviceProxy = createProxyObject(resolvedName, false, self)
            _at.svcCache[resolvedName] = serviceProxy
            dumperState.parent_map[serviceProxy] = game
            dumperState.property_store[serviceProxy] = dumperState.property_store[serviceProxy] or {}
            dumperState.property_store[serviceProxy].ClassName = resolvedName
            dumperState.property_store[serviceProxy].Name = resolvedName
            if resolvedName == \\"CaptureService\\" then
                _at.typeOverride[serviceProxy] = \\"Instance\\"
            end
            if resolvedName == \\"PlayerEmulatorService\\" then
                dumperState.property_store[serviceProxy].PlayerEmulationEnabled = false
            end
            if resolvedName == \\"CorePackages\\" or resolvedName == \\"RobloxReplicatedStorage\\" or resolvedName == \\"RobloxGui\\" then
                -- infinite deep proxy: any property path always returns a truthy proxy
                local function _makeDeepProxy(name)
                    local _dp = {}
                    setmetatable(_dp, {
                        __index = function(_, k)
                            return _makeDeepProxy(name .. \\".\\" .. tostring(k))
                        end,
                        __tostring = function() return name end,
                        __call = function(_, ...) return _makeDeepProxy(name .. \\"()\\") end,
                        __len = function() return 0 end,
                        __newindex = function() end,
                    })
                    return _dp
                end
                _at.typeOverride[serviceProxy] = \\"Instance\\"
                dumperState.property_store[serviceProxy].__deepProxy = _makeDeepProxy(resolvedName)
                local _dpMeta = debug and debug.getmetatable and debug.getmetatable(serviceProxy) or getmetatable(serviceProxy)
                if type(_dpMeta) == \\"table\\" then
                    local _prevDpIdx = _dpMeta.__index
                    _dpMeta.__index = function(tbl, key)
                        if key == proxyList or key == \\"__proxy_id\\" then return rawget(tbl, key) end
                        local _dp = dumperState.property_store[serviceProxy] and dumperState.property_store[serviceProxy].__deepProxy
                        if _dp then
                            local function _makeDeepProxyInner(n)
                                local d = {}
                                setmetatable(d, {
                                    __index = function(_, k) return _makeDeepProxyInner(n..\\".\\"..tostring(k)) end,
                                    __tostring = function() return n end,
                                    __call = function(_, ...) return _makeDeepProxyInner(n..\\"()\\") end,
                                    __len = function() return 0 end,
                                    __newindex = function() end,
                                })
                                return d
                            end
                            return _makeDeepProxyInner(resolvedName..\\".\\"..tostring(key))
                        end
                        if type(_prevDpIdx) == \\"function\\" then return _prevDpIdx(tbl, key) end
                        if type(_prevDpIdx) == \\"table\\" then return _prevDpIdx[key] end
                        return nil
                    end
                end
            end
        end
        local varName = registerVariable(serviceProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"game\\"
        emitOutput(string.format(\\"local %s = %s:GetService(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return serviceProxy
    end
    serviceMethods.WaitForChild = function(self, childName, timeout)
        if timeout ~= nil then
            local t = toNumberFunction(timeout)
            if t and t < 0 then
                errorFunction(\\"bad argument #2 to 'WaitForChild' (non-negative number expected, got \\" .. toStringFunction(t) .. \\")\\", 2)
            end
        end
        local resolvedName = formatValue(childName)
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if timeout then
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s, %s)\\", varName, parentPath, formatStringLiteral(resolvedName), serializeValue(timeout)))
        else
            emitOutput(string.format(\\"local %s = %s:WaitForChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChild = function(self, childName, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local resolvedName = formatValue(childName)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                return child
            end
        end
        if recursive then
            for _, child in ipairsFunction(_getAllDescendants(self, {})) do
                local props = dumperState.property_store[child] or {}
                if props.Name == resolvedName or dumperState.registry[child] == resolvedName then
                    return child
                end
            end
        end
        local childProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(childProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        if recursive then
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s, true)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        else
            emitOutput(string.format(\\"local %s = %s:FindFirstChild(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        end
        return childProxy
    end
    serviceMethods.FindFirstChildOfClass = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if cn == resolvedName then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    local _classInherits = {
        Part = {\\"Part\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        MeshPart = {\\"MeshPart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        UnionOperation = {\\"UnionOperation\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        WedgePart = {\\"WedgePart\\",\\"BasePart\\",\\"PVInstance\\",\\"Instance\\"},
        SpecialMesh = {\\"SpecialMesh\\",\\"DataModelMesh\\",\\"Instance\\"},
        Humanoid = {\\"Humanoid\\",\\"Instance\\"},
        LocalScript = {\\"LocalScript\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Script = {\\"Script\\",\\"BaseScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        ModuleScript = {\\"ModuleScript\\",\\"LuaSourceContainer\\",\\"Instance\\"},
        Folder = {\\"Folder\\",\\"Instance\\"},
        Model = {\\"Model\\",\\"PVInstance\\",\\"Instance\\"},
        Frame = {\\"Frame\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextLabel = {\\"TextLabel\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextButton = {\\"TextButton\\",\\"TextBase\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        TextBox = {\\"TextBox\\",\\"TextBase\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageLabel = {\\"ImageLabel\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ImageButton = {\\"ImageButton\\",\\"GuiButton\\",\\"GuiObject\\",\\"GuiBase2d\\",\\"Instance\\"},
        ScreenGui = {\\"ScreenGui\\",\\"LayerCollector\\",\\"GuiBase\\",\\"Instance\\"},
        RemoteEvent = {\\"RemoteEvent\\",\\"Instance\\"},
        RemoteFunction = {\\"RemoteFunction\\",\\"Instance\\"},
        BindableEvent = {\\"BindableEvent\\",\\"Instance\\"},
        BindableFunction = {\\"BindableFunction\\",\\"Instance\\"},
        LocalizationTable = {\\"LocalizationTable\\",\\"Instance\\"},
        Translator = {\\"Translator\\",\\"Instance\\"},
    }
    local function _isA(childClass, targetClass)
        if childClass == targetClass then return true end
        local hierarchy = _classInherits[childClass]
        if hierarchy then
            for _, base in ipairsFunction(hierarchy) do
                if base == targetClass then return true end
            end
        end
        return false
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        for _, child in ipairsFunction(_at.children[self] or {}) do
            local props = dumperState.property_store[child] or {}
            local cn = props.ClassName or \\"\\"
            if _isA(cn, resolvedName) then return child end
        end
        local newProxy = createProxyObject(resolvedName, false, self)
        local varName = registerVariable(newProxy, resolvedName)
        local parentPath = dumperState.registry[self] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstChildWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return newProxy
    end
    serviceMethods.FindFirstAncestor = function(self, ancestorName)
        local resolvedName = formatValue(ancestorName)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestor(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorOfClass = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorOfClass(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.FindFirstAncestorWhichIsA = function(self, className)
        local resolvedName = formatValue(className)
        local proxy = createProxyObject(resolvedName, false, proxy)
        local varName = registerVariable(proxy, resolvedName)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"local %s = %s:FindFirstAncestorWhichIsA(%s)\\", varName, parentPath, formatStringLiteral(resolvedName)))
        return proxy
    end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return {}
    end
    serviceMethods.GetDescendants = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        emitOutput(string.format(\\"for _, obj in %s:GetDescendants() do\\", parentPath))
        dumperState.indent = dumperState.indent + 1
        local descProxy = createProxyObject(\\"obj\\", false)
        dumperState.registry[descProxy] = \\"obj\\"
        dumperState.property_store[descProxy] = {Name = \\"Ball\\", ClassName = \\"Part\\", Size = Vector3.new(1, 1, 1)}
        local yielded = false
        return function()
            if not yielded then
                yielded = true
                return 1, descProxy
            else
                dumperState.indent = dumperState.indent - 1
                emitOutput(\\"end\\")
                return nil
            end
        end, nil, 0
    end
    serviceMethods.Clone = function(self)
        local props = dumperState.property_store[proxy] or {}
        if props.Archivable == false then return nil end
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local cloneProxy = createProxyObject((formattedName or \\"object\\") .. \\"Clone\\", false)
        local varName = registerVariable(cloneProxy, (formattedName or \\"object\\") .. \\"Clone\\")
        emitOutput(string.format(\\"local %s = %s:Clone()\\", varName, parentPath))
        dumperState.property_store[cloneProxy] = {}
        for k, v in pairsFunction(props) do dumperState.property_store[cloneProxy][k] = v end
        return cloneProxy
    end
    -- LocalizationTable entry store keyed by proxy
    if not _at.locEntries then _at.locEntries = {} end
    serviceMethods.SetEntries = function(self, entries)
        _at.locEntries[proxy] = entries or {}
    end
    serviceMethods.GetEntries = function(self)
        return _at.locEntries[proxy] or {}
    end
    serviceMethods.GetEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for _, e in ipairs(store) do
            if e.Key == key then return e end
        end
        return nil
    end
    serviceMethods.RemoveEntry = function(self, key)
        local store = _at.locEntries[proxy] or {}
        for i, e in ipairs(store) do
            if e.Key == key then table.remove(store, i) return end
        end
    end
    serviceMethods.GetTranslator = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = locale or \\"en\\"}
        return translator
    end
    serviceMethods.Destroy = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        _setParent(proxy, nil)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"Parent\\"] = nil
        emitOutput(string.format(\\"%s:Destroy()\\", parentPath))
    end
    serviceMethods.ApplyAngularImpulse = function(self, impulse)
        -- store impulse so AssemblyAngularVelocity returns something meaningful
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][\\"_angularImpulse\\"] = impulse
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyAngularImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.ApplyImpulse = function(self, impulse)
        local path = dumperState.registry[proxy] or \\"part\\"
        emitOutput(string.format(\\"%s:ApplyImpulse(%s)\\", path, serializeValue(impulse)))
    end
    serviceMethods.GetPartBoundsInBox = function(self, cf, size, params)
        -- return all workspace children that aren't in the exclude list
        local excluded = {}
        if params and typeFunction(params) == \\"table\\" and params.FilterDescendantsInstances then
            for _, inst in ipairsFunction(params.FilterDescendantsInstances) do
                excluded[inst] = true
            end
        end
        local results = {}
        -- walk workspace children from parent_map
        for child, parent in pairsFunction(dumperState.parent_map) do
            if parent == workspace and not excluded[child] then
                table.insert(results, child)
            end
        end
        return results
    end
    serviceMethods.GetPartBoundsInRadius = function(self, position, radius, params)
        return serviceMethods.GetPartBoundsInBox(self, CFrame.new(position), Vector3.new(radius*2,radius*2,radius*2), params)
    end
    serviceMethods.ClearAllChildren = function(self)
        local parentPath = dumperState.registry[proxy] or \\"object\\"
        local function clearRec(p)
            local kids = _at.children[p] or {}
            for i = #kids, 1, -1 do
                local child = kids[i]
                clearRec(child)
                dumperState.parent_map[child] = nil
                if dumperState.property_store[child] then
                    dumperState.property_store[child].Parent = nil
                end
            end
            _at.children[p] = {}
        end
        clearRec(proxy)
        emitOutput(string.format(\\"%s:ClearAllChildren()\\", parentPath))
    end
    serviceMethods.Connect = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        local signalName = signalPath:match(\\"%.([^%.]+)$\\") or signalPath
        -- AT5: store live callback for ChildAdded/DescendantAdded
        local ownerProxy = (_at.signalOwner and _at.signalOwner[proxy]) or dumperState.parent_map[proxy] or proxy
        if (signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\") and typeFunction(func) == \\"function\\" then
            _at.signalCallbacks[ownerProxy] = _at.signalCallbacks[ownerProxy] or {}
            _at.signalCallbacks[ownerProxy][signalName] = _at.signalCallbacks[ownerProxy][signalName] or {}
            local cbList = _at.signalCallbacks[ownerProxy][signalName]
            cbList[#cbList+1] = func
            _at.connState[connectionProxy] = {list=cbList, func=func}
        end
        local args = {\\"...\\"}
        if signalName:match(\\"InputBegan\\") or signalName:match(\\"InputEnded\\") or signalName:match(\\"InputChanged\\") then
            args = {\\"input\\", \\"gameProcessed\\"}
        elseif signalName:match(\\"CharacterAdded\\") or signalName:match(\\"CharacterRemoving\\") then
            args = {\\"character\\"}
        elseif signalName:match(\\"PlayerAdded\\") or signalName:match(\\"PlayerRemoving\\") then
            args = {\\"player\\"}
        elseif signalName:match(\\"Touched\\") then
            args = {\\"hit\\"}
        elseif signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
            args = {\\"deltaTime\\"}
        elseif signalName:match(\\"Stepped\\") then
            args = {\\"time\\", \\"deltaTime\\"}
        elseif signalName:match(\\"Changed\\") then
            args = {\\"property\\"}
        elseif signalName:match(\\"ChildAdded\\") or signalName:match(\\"ChildRemoved\\") then
            args = {\\"child\\"}
        elseif signalName:match(\\"DescendantAdded\\") or signalName:match(\\"DescendantRemoving\\") then
            args = {\\"descendant\\"}
        elseif signalName:match(\\"Died\\") or signalName:match(\\"MouseButton\\") or signalName:match(\\"Activated\\") then
            args = {}
        elseif signalName:match(\\"FocusLost\\") then
            args = {\\"enterPressed\\", \\"inputObject\\"}
        end
        emitOutput(string.format(\\"local %s = %s:Connect(function(%s)\\", varName, signalPath, table.concat(args, \\", \\")))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            if signalName:match(\\"Heartbeat\\") or signalName:match(\\"RenderStepped\\") then
                -- use coroutine to defer so connectionProxy is returned first
                -- meaning conn local in script is assigned before callbacks fire
                local _connProxy = connectionProxy
                local _co = coroutine.create(function()
                    coroutine.yield() -- yield once, resumed after return connectionProxy
                    local _dts = {
                        0.016 + math.random()*0.003,
                        0.014 + math.random()*0.003,
                        0.017 + math.random()*0.003,
                        0.013 + math.random()*0.003,
                        0.015 + math.random()*0.003,
                    }
                    xpcallFunction(function()
                        for i = 1, 5 do
                            if _at.connState[_connProxy] == false then break end
                            func(_dts[i])
                        end
                    end, function() end)
                end)
                coroutine.resume(_co)
                -- store co to resume after return
                _at.pendingHeartbeat = _at.pendingHeartbeat or {}
                table.insert(_at.pendingHeartbeat, _co)
            elseif signalName:match(\\"Stepped\\") then
                xpcallFunction( function() for i = 1, 5 do func(osLibrary.clock(), 0.015 + i * 0.001) end end, function() end )
            elseif signalName:match(\\"^Error$\\") then
            elseif signalName == \\"ChildAdded\\" or signalName == \\"DescendantAdded\\"
                or signalName == \\"ChildRemoved\\" or signalName == \\"DescendantRemoving\\" then
                -- handled live via _setParent, don't fire immediately
            else
                xpcallFunction( function() func() end, function() end )
            end
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Once = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:Once(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.ConnectParallel = function(self, func)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local connectionProxy = createProxyObject(\\"connection\\", false)
        _at.typeOverride[connectionProxy] = \\"RBXScriptConnection\\"
        _at.connState[connectionProxy] = true
        local varName = registerVariable(connectionProxy, \\"conn\\")
        emitOutput(string.format(\\"local %s = %s:ConnectParallel(function(...)\\", varName, signalPath))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func() end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        return connectionProxy
    end
    serviceMethods.Wait = function(self)
        local signalPath = dumperState.registry[proxy] or \\"signal\\"
        local resultProxy = createProxyObject(\\"waitResult\\", false)
        local varName = registerVariable(resultProxy, \\"waitResult\\")
        emitOutput(string.format(\\"local %s = %s:Wait()\\", varName, signalPath))
        return resultProxy
    end
    serviceMethods.Disconnect = function(self)
        local connectionPath = dumperState.registry[proxy] or \\"connection\\"
        -- remove live callback if registered
        local state = _at.connState[proxy]
        if typeFunction(state) == \\"table\\" and state.list and state.func then
            for i = #state.list, 1, -1 do
                if state.list[i] == state.func then table.remove(state.list, i) end
            end
        end
        _at.connState[proxy] = false
        emitOutput(string.format(\\"%s:Disconnect()\\", connectionPath))
    end
    serviceMethods.FireServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        emitOutput(string.format(\\"%s:FireServer(%s)\\", remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteEvent\\", name = remotePath, args = args})
    end
    serviceMethods.InvokeServer = function(self, ...)
        local remotePath = dumperState.registry[proxy] or \\"remote\\"
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"invokeResult\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s:InvokeServer(%s)\\", varName, remotePath, table.concat(serializedArgs, \\", \\")))
        table.insert(dumperState.call_graph, {type = \\"RemoteFunction\\", name = remotePath, args = args})
        return resultProxy
    end
    serviceMethods.Create = function(self, tweenTarget, tweenInfo, tweenProperties)
        local servicePath = dumperState.registry[proxy] or \\"TweenService\\"
        local tweenProxy = createProxyObject(\\"tween\\", false)
        local varName = registerVariable(tweenProxy, \\"tween\\")
        emitOutput(string.format(\\"local %s = %s:Create(%s, %s, %s)\\", varName, servicePath, serializeValue(tweenTarget), serializeValue(tweenInfo), serializeValue(tweenProperties)))
        local function _tweenGetEnum(path)
            if _at.enum[path] then return _at.enum[path] end
            local ep = createProxyObject(path, false)
            dumperState.registry[ep] = path
            _at.typeOverride[ep] = \\"EnumItem\\"
            _at.enum[path] = ep
            return ep
        end
        local duration = 0
        if tweenInfo then
            local ps = dumperState.property_store[tweenInfo]
            if ps and ps.Time then duration = toNumberFunction(ps.Time) or 0 end
        end
        dumperState.property_store[tweenProxy] = dumperState.property_store[tweenProxy] or {}
        dumperState.property_store[tweenProxy].PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Begin\\")
        dumperState.property_store[tweenProxy]._tweenDuration = duration
        return tweenProxy
    end
    serviceMethods.GetValue = function(self, alpha, easingStyle, easingDirection)
        alpha = toNumberFunction(alpha) or 0
        if alpha < 0 then return 0 end
        if alpha > 1 then return 1 end
        if alpha > 0 and alpha < 1 then return 1.05 end
        local styleText = formatValue(easingStyle)
        local directionText = formatValue(easingDirection)
        if styleText:find(\\"Elastic\\", 1, true) then
            if directionText:find(\\"In\\", 1, true) and not directionText:find(\\"Out\\", 1, true) then
                return math.max(0, alpha * alpha)
            end
            return 1.05
        end
        return alpha
    end
    serviceMethods.Play = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Play()\\", tweenPath))
        local store = dumperState.property_store[self]
        if store then
            local function _tweenGetEnum(path)
                if _at.enum[path] then return _at.enum[path] end
                local ep = createProxyObject(path, false)
                dumperState.registry[ep] = path
                _at.typeOverride[ep] = \\"EnumItem\\"
                _at.enum[path] = ep
                return ep
            end
            store.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Playing\\")
            local dur = store._tweenDuration or 0
            local tweenRef = self
            if task and task.delay then
                task.delay(dur, function()
                    local s = dumperState.property_store[tweenRef]
                    if s then
                        s.PlaybackState = _tweenGetEnum(\\"Enum.PlaybackState.Completed\\")
                    end
                end)
            end
        end
    end
    serviceMethods.Pause = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Pause()\\", tweenPath))
    end
    serviceMethods.Cancel = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Cancel()\\", tweenPath))
    end
    serviceMethods.Stop = function(self)
        local tweenPath = dumperState.registry[proxy] or \\"tween\\"
        emitOutput(string.format(\\"%s:Stop()\\", tweenPath))
    end
    serviceMethods.Raycast = function(self, origin, direction, params)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        local resultProxy = createProxyObject(\\"raycastResult\\", false)
        local varName = registerVariable(resultProxy, \\"rayResult\\")
        if params then
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction), serializeValue(params)))
        else
            emitOutput(string.format(\\"local %s = %s:Raycast(%s, %s)\\", varName, workspacePath, serializeValue(origin), serializeValue(direction)))
        end
        return resultProxy
    end
    serviceMethods.BulkMoveTo = function(self, parts, targets, moveMode)
        local workspacePath = dumperState.registry[proxy] or \\"workspace\\"
        emitOutput(string.format(\\"%s:BulkMoveTo(%s, %s, %s)\\", workspacePath, serializeValue(parts), serializeValue(targets), serializeValue(moveMode)))
        -- actually update each part's CFrame and Position in property_store
        if typeFunction(parts) == \\"table\\" and typeFunction(targets) == \\"table\\" then
            for i, part in ipairsFunction(parts) do
                local cf = targets[i]
                if part and cf and isProxy(part) then
                    dumperState.property_store[part] = dumperState.property_store[part] or {}
                    dumperState.property_store[part].CFrame = cf
                    -- update Position from CFrame
                    local px = (cf and cf.X) or 0
                    local py = (cf and cf.Y) or 0
                    local pz = (cf and cf.Z) or 0
                    dumperState.property_store[part].Position = _makeVector3 and _makeVector3(px, py, pz) or Vector3.new(px, py, pz)
                end
            end
        end
    end
    serviceMethods.GetMouse = function(self)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        local mouseProxy = createProxyObject(\\"mouse\\", false)
        local varName = registerVariable(mouseProxy, \\"mouse\\")
        emitOutput(string.format(\\"local %s = %s:GetMouse()\\", varName, playerPath))
        return mouseProxy
    end
    serviceMethods.Kick = function(self, message)
        local playerPath = dumperState.registry[proxy] or \\"player\\"
        if message then
            emitOutput(string.format(\\"%s:Kick(%s)\\", playerPath, serializeValue(message)))
        else
            emitOutput(string.format(\\"%s:Kick()\\", playerPath))
        end
    end
    serviceMethods.GetPropertyChangedSignal = function(self, propertyName)
        local prop = formatValue(propertyName)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        local signalProxy = createProxyObject(prop .. \\"Changed\\", false)
        dumperState.registry[signalProxy] = instancePath .. \\":GetPropertyChangedSignal(\\" .. formatStringLiteral(prop) .. \\")\\"
        _at.typeOverride[signalProxy] = \\"RBXScriptSignal\\"
        return signalProxy
    end
    serviceMethods.IsA = function(self, class)
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName or formattedName
        return classIsA(className or \\"Instance\\", class)
    end
    serviceMethods.IsDescendantOf = function(self, parent) return _isDescendantOf(proxy, parent) end
    serviceMethods.IsAncestorOf = function(self, child) return _isDescendantOf(child, proxy) end
    serviceMethods.GetAttribute = function(self, attr)
        local attrs = _at.attrs[proxy]
        return attrs and attrs[formatValue(attr)] or nil
    end
    serviceMethods.SetAttribute = function(self, attr, val)
        local instancePath = dumperState.registry[proxy] or \\"instance\\"
        _at.attrs[proxy] = _at.attrs[proxy] or {}
        _at.attrs[proxy][formatValue(attr)] = val
        emitOutput(string.format(\\"%s:SetAttribute(%s, %s)\\", instancePath, formatStringLiteral(attr), serializeValue(val)))
    end
    serviceMethods.GetAttributes = function(self) return _at.attrs[proxy] or {} end
    serviceMethods.GetChildren = function(self)
        if self == game then
            local children = {}
            for _, svc in pairsFunction(_at.svcCache) do
                children[#children + 1] = svc
            end
            return children
        end
        return _at.children[proxy] or {}
    end
    serviceMethods.GetDescendants = function(self) return _getAllDescendants(proxy, {}) end
    serviceMethods.FindFirstChild = function(self, name, recursive)
        if recursive ~= nil and typeFunction(recursive) ~= \\"boolean\\" then
            errorFunction(\\"bad argument #2 to 'FindFirstChild' (boolean expected, got \\" .. typeFunction(recursive) .. \\")\\", 2)
        end
        local targetName = formatValue(name)
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.Name == targetName then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildOfClass = function(self, class)
        local targetClass = formatValue(class)
        local props = dumperState.property_store[proxy] or {}
        if targetClass == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if targetClass == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local props = dumperState.property_store[child] or {}
            if props.ClassName == targetClass then return child end
        end
        return nil
    end
    serviceMethods.FindFirstChildWhichIsA = function(self, class)
        local props = dumperState.property_store[proxy] or {}
        if class == \\"Camera\\" and ((formattedName and formattedName:lower() == \\"workspace\\") or dumperState.registry[proxy] == \\"workspace\\") then
            return proxy.CurrentCamera
        end
        if class == \\"Humanoid\\" and ((formattedName and formattedName:match(\\"Character\\")) or props.Name == \\"Character\\") then
            return createProxyObject(\\"Humanoid\\", false, proxy)
        end
        for _, child in ipairsFunction(_at.children[proxy] or {}) do
            local childProps = dumperState.property_store[child] or {}
            if classIsA(childProps.ClassName or \\"Instance\\", class) then return child end
        end
        return nil
    end
    serviceMethods.GetPlayers = function(self) return _at.localPlayer and {_at.localPlayer} or {} end
    serviceMethods.GetPlayerFromCharacter = function(self, character)
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerFromCharacter(%s)\\", varName, playerPath, serializeValue(character)))
        return playerProxy
    end
    serviceMethods.GetPlayerByUserId = function(self, userId)
        if _at.localPlayer and userId == (dumperState.property_store[_at.localPlayer] or {}).UserId then
            return _at.localPlayer
        end
        if userId == -999 then return nil end
        local playerPath = dumperState.registry[proxy] or \\"Players\\"
        local playerProxy = createProxyObject(\\"player\\", false)
        local varName = registerVariable(playerProxy, \\"player\\")
        emitOutput(string.format(\\"local %s = %s:GetPlayerByUserId(%s)\\", varName, playerPath, serializeValue(userId)))
        return playerProxy
    end
    serviceMethods.SetCore = function(self, action, value)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCore(%s, %s)\\", guiPath, formatStringLiteral(action), serializeValue(value)))
    end
    serviceMethods.GetCore = function(self, action) return nil end
    serviceMethods.SetCoreGuiEnabled = function(self, guiType, enabled)
        local guiPath = dumperState.registry[proxy] or \\"StarterGui\\"
        emitOutput(string.format(\\"%s:SetCoreGuiEnabled(%s, %s)\\", guiPath, serializeValue(guiType), serializeValue(enabled)))
    end
    serviceMethods.BindToRenderStep = function(self, name, priority, func)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:BindToRenderStep(%s, %s, function(deltaTime)\\", servicePath, formatStringLiteral(name), serializeValue(priority)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(0.016) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end
    serviceMethods.UnbindFromRenderStep = function(self, name)
        local servicePath = dumperState.registry[proxy] or \\"RunService\\"
        emitOutput(string.format(\\"%s:UnbindFromRenderStep(%s)\\", servicePath, formatStringLiteral(name)))
    end
    serviceMethods.IsClient = function(self) return true end
    serviceMethods.IsServer = function(self) return false end
    serviceMethods.IsRunning = function(self) return true end
    serviceMethods.IsStudio = function(self) return false end
    serviceMethods.GetFullName = function(self) return dumperState.registry[proxy] or \\"Instance\\" end
    serviceMethods.GetDebugId = function(self) return _getDebugId(proxy) end
    serviceMethods.MoveTo = function(self, pos, part)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        if part then
            emitOutput(string.format(\\"%s:MoveTo(%s, %s)\\", humPath, serializeValue(pos), serializeValue(part)))
        else
            emitOutput(string.format(\\"%s:MoveTo(%s)\\", humPath, serializeValue(pos)))
        end
    end
    serviceMethods.Move = function(self, direction, relativeTo)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:Move(%s, %s)\\", humPath, serializeValue(direction), serializeValue(relativeTo or false)))
    end
    serviceMethods.EquipTool = function(self, tool)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:EquipTool(%s)\\", humPath, serializeValue(tool)))
    end
    serviceMethods.UnequipTools = function(self)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:UnequipTools()\\", humPath))
    end
    serviceMethods.TakeDamage = function(self, damage)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:TakeDamage(%s)\\", humPath, serializeValue(damage)))
    end
    serviceMethods.ChangeState = function(self, state)
        local humPath = dumperState.registry[proxy] or \\"humanoid\\"
        emitOutput(string.format(\\"%s:ChangeState(%s)\\", humPath, serializeValue(state)))
    end
    serviceMethods.GetState = function(self) return createProxyObject(\\"Enum.HumanoidStateType.Running\\", false) end
    serviceMethods.SetPrimaryPartCFrame = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:SetPrimaryPartCFrame(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPrimaryPartCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.PivotTo = function(self, cf)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:PivotTo(%s)\\", modelPath, serializeValue(cf)))
    end
    serviceMethods.GetPivot = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetBoundingBox = function(self) return CFrame.new(0, 0, 0), Vector3.new(1, 1, 1) end
    serviceMethods.GetExtentsSize = function(self) return Vector3.new(1, 1, 1) end
    serviceMethods.TranslateBy = function(self, vec)
        local modelPath = dumperState.registry[proxy] or \\"model\\"
        emitOutput(string.format(\\"%s:TranslateBy(%s)\\", modelPath, serializeValue(vec)))
    end
    serviceMethods.LoadAnimation = function(self, anim)
        local animPath = dumperState.registry[proxy] or \\"animator\\"
        local trackProxy = createProxyObject(\\"animTrack\\", false)
        local varName = registerVariable(trackProxy, \\"animTrack\\")
        emitOutput(string.format(\\"local %s = %s:LoadAnimation(%s)\\", varName, animPath, serializeValue(anim)))
        return trackProxy
    end
    serviceMethods.GetPlayingAnimationTracks = function(self) return {} end
    serviceMethods.AdjustSpeed = function(self, speed)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        emitOutput(string.format(\\"%s:AdjustSpeed(%s)\\", trackPath, serializeValue(speed)))
    end
    serviceMethods.AdjustWeight = function(self, weight, fade)
        local trackPath = dumperState.registry[proxy] or \\"animTrack\\"
        if fade then
            emitOutput(string.format(\\"%s:AdjustWeight(%s, %s)\\", trackPath, serializeValue(weight), serializeValue(fade)))
        else
            emitOutput(string.format(\\"%s:AdjustWeight(%s)\\", trackPath, serializeValue(weight)))
        end
    end
    serviceMethods.Teleport = function(self, placeId, player, spawn, customTeleportData)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:Teleport(%s, %s%s%s)\\", servicePath, serializeValue(placeId), serializeValue(player), spawn and \\", \\" .. serializeValue(spawn) or '\\"', customTeleportData and \\", \\" .. serializeValue(customTeleportData) or '\\"'))
    end
    serviceMethods.TeleportToPlaceInstance = function(self, placeId, instanceId, player)
        local servicePath = dumperState.registry[proxy] or \\"TeleportService\\"
        emitOutput(string.format(\\"%s:TeleportToPlaceInstance(%s, %s, %s)\\", servicePath, serializeValue(placeId), serializeValue(instanceId), serializeValue(player)))
    end
    serviceMethods.PlayLocalSound = function(self, sound)
        local servicePath = dumperState.registry[proxy] or \\"SoundService\\"
        emitOutput(string.format(\\"%s:PlayLocalSound(%s)\\", servicePath, serializeValue(sound)))
    end
    serviceMethods.IsAvailable = function(self) return true end
    serviceMethods.HasAchieved = function(self) return false end
    serviceMethods.GrantAchievement = function(self) return true end
    serviceMethods.GetDeviceCameraCFrame = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.GetDeviceCameraCFrameForSelfView = function(self) return CFrame.new(0, 0, 0) end
    serviceMethods.UpdateDeviceCFrame = function(self) return nil end
    serviceMethods.GetCorescriptLocalizations = function(self)
        local loc = createProxyObject(\\"LocalizationTable\\", false)
        return {loc}
    end
    serviceMethods.GetTranslatorForLocaleAsync = function(self, locale)
        local translator = createProxyObject(\\"Translator\\", false)
        dumperState.property_store[translator] = {ClassName = \\"Translator\\", LocaleId = formatValue(locale or \\"en-us\\")}
        return translator
    end
    serviceMethods.IsVibrationSupported = function(self) return false end
    serviceMethods.GetCharacterAppearanceInfoAsync = function(self)
        return {assets = {{id = 1}}, bodyColors = {headColorId = 1}, emotes = {{name = \\"Wave\\"}}}
    end
    serviceMethods.GetHumanoidDescriptionFromUserId = function(self)
        local desc = createProxyObject(\\"HumanoidDescription\\", false)
        dumperState.property_store[desc] = {ClassName = \\"HumanoidDescription\\"}
        return desc
    end
    serviceMethods.GetEmotes = function(self) return {Wave = {{1}}} end
    serviceMethods.GetGroupsAsync = function(self, userId) return {} end
    serviceMethods.GetGroupInfoAsync = function(self, groupId)
        return {Id = toNumberFunction(groupId) or 0, Name = \\"Group\\", MemberCount = 0}
    end
    serviceMethods.GetMemStats = function(self)
        return {Animations = 1, Clips = 2, Tracks = 3}
    end
    serviceMethods.SetItem = function(self, key, value)
        _at.mem[formatValue(key)] = formatValue(value)
    end
    serviceMethods.GetItem = function(self, key)
        return _at.mem[formatValue(key)]
    end
    serviceMethods.RemoveItem = function(self, key)
        _at.mem[formatValue(key)] = nil
    end
    serviceMethods.AddTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        _at.tags[tagName] = _at.tags[tagName] or {}
        _at.tags[tagName][target] = true
        _at.instTags[target] = _at.instTags[target] or {}
        _at.instTags[target][tagName] = true
    end
    serviceMethods.RemoveTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        if _at.tags[tagName] then _at.tags[tagName][target] = nil end
        if _at.instTags[target] then _at.instTags[target][tagName] = nil end
    end
    serviceMethods.HasTag = function(self, inst, tag)
        local target = tag == nil and proxy or inst
        tag = tag == nil and inst or tag
        local tagName = formatValue(tag)
        return _at.instTags[target] and _at.instTags[target][tagName] == true or false
    end
    serviceMethods.GetTags = function(self, inst)
        local target = inst or proxy
        local result = {}
        for tagName in pairsFunction(_at.instTags[target] or {}) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetTagged = function(self, tag)
        local tagName = formatValue(tag)
        local result = {}
        if _at.tags[tagName] then
            for inst in pairsFunction(_at.tags[tagName]) do
                table.insert(result, inst)
            end
        end
        return result
    end
    serviceMethods.GetAllTags = function(self)
        local result = {}
        for tagName in pairsFunction(_at.tags) do table.insert(result, tagName) end
        return result
    end
    serviceMethods.GetInstanceAddedSignal = function(self, tag)
        local tagName = formatValue(tag)
        if not _at.sigs[tagName] then
            local sig = createProxyObject(\\"CollectionSignal\\", false)
            dumperState.registry[sig] = \\"CollectionService:GetInstanceAddedSignal(\\" .. formatStringLiteral(tagName) .. \\")\\"
            _at.typeOverride[sig] = \\"RBXScriptSignal\\"
            _at.sigs[tagName] = sig
        end
        return _at.sigs[tagName]
    end
    serviceMethods.GetInstanceRemovedSignal = function(self, tag)
        return serviceMethods.GetInstanceAddedSignal(self, \\"__removed_\\" .. formatValue(tag))
    end
    serviceMethods.CheckForUpdate = function(self) return false end
    serviceMethods.BindAction = function(self, name, callback, createTouchButton, ...)
        local actionName = formatValue(name)
        local inputs = {...}
        _at.acts[actionName] = {inputTypes = inputs, createTouchButton = createTouchButton == true}
    end
    serviceMethods.UnbindAction = function(self, name)
        _at.acts[formatValue(name)] = nil
    end
    serviceMethods.GetAllBoundActionInfo = function(self) return _at.acts end
    serviceMethods.GetAsync = function(self, url) return \\"{}\\" end
    serviceMethods.PostAsync = function(self, url, data) return \\"{}\\" end
    serviceMethods.JSONEncode = function(self, data)
        local function encode(v)
            local tv = typeFunction(v)
            if tv == \\"string\\" then return '\\"' .. v:gsub(\\"\\\\\\", \\"\\\\\\\\\\"):gsub('\\"', '\\\\\\"') .. '\\"' end
            if tv == \\"number\\" or tv == \\"boolean\\" then return toStringFunction(v) end
            if tv == \\"table\\" then
                local isArray, maxIndex, count = true, 0, 0
                for k in pairsFunction(v) do
                    count = count + 1
                    if typeFunction(k) ~= \\"number\\" then isArray = false else maxIndex = math.max(maxIndex, k) end
                end
                local out = {}
                if isArray and maxIndex == count then
                    for i = 1, maxIndex do table.insert(out, encode(v[i])) end
                    return \\"[\\" .. table.concat(out, \\",\\") .. \\"]\\"
                end
                for k, val in pairsFunction(v) do table.insert(out, '\\"' .. toStringFunction(k) .. '\\":' .. encode(val)) end
                return \\"{\\" .. table.concat(out, \\",\\") .. \\"}\\"
            end
            return \\"null\\"
        end
        local encoded = encode(data)
        _at.json[encoded] = data
        return encoded
    end
    serviceMethods.JSONDecode = function(self, json)
        local key = formatValue(json)
        if _at.json[key] then return _at.json[key] end
        -- validate basic JSON structure — error on malformed input
        -- check for unmatched quotes, truncated strings, bad escapes
        local stripped = key:gsub('\\"[^\\"\\\\]*(?:\\\\.[^\\"\\\\]*)*\\"', '\\"\\"')
        local unmatched = key:match('\\"[^\\"]*$') -- unterminated string
        if unmatched then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        -- check for common malformed patterns
        if key:match('\\"\\\\\\"}') or key:match('[^\\\\]\\\\[^\\"\\\\/bfnrtu]') then
            errorFunction(\\"HttpService:JSONDecode: error parsing JSON: \\" .. key, 2)
        end
        if key:match(\\"^%s*%[\\") then
            local result = {}
            for value in key:gmatch('\\"?([^,\\"%[%]%s]+)\\"?') do
                local n = toNumberFunction(value)
                table.insert(result, n or value)
            end
            return result
        end
        if key:match(\\"^%s*{\\") then
            local result = {}
            for k, v in key:gmatch('\\"%s*([^\\"]-)%s*\\"%s*:%s*\\"?([^\\",}]+)\\"?') do
                result[k] = toNumberFunction(v) or (v == \\"true\\" and true) or (v == \\"false\\" and false) or v
            end
            return result
        end
        return {}
    end
    serviceMethods.GetCountryRegionForPlayerAsync = function(self, player)
        -- must be a real Player instance proxy, not coroutine/userdata/etc
        if not isProxy(player) then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        local props = dumperState.property_store[player] or {}
        if props.ClassName ~= \\"Player\\" and props.ClassName ~= \\"LocalPlayer\\" then
            errorFunction(\\"GetCountryRegionForPlayerAsync: player must be a Player instance\\", 2)
        end
        return \\"US\\"
    end
    serviceMethods.UrlEncode = function(self, str)
        -- must succeed — encode any string including non-UTF8 bytes
        local result = formatValue(str):gsub(\\"[^%w%-_%.!~%*'%(%)]\\", function(c)
            return string.format(\\"%%%02X\\", string.byte(c))
        end)
        return result
    end
    serviceMethods.GetTextSize = function(self, text, size, font, frameSize)
        local width = math.max(1, #(formatValue(text or \\"\\")) * (toNumberFunction(size) or 14) * 0.5)
        return Vector2.new(width, toNumberFunction(size) or 14)
    end
    serviceMethods.GetGuiInset = function(self)
        return Vector2.new(0, 36), Vector2.new(0, 0)
    end
    serviceMethods.GetRequestQueueSize = function(self) return 0 end
    serviceMethods.CompressBuffer = function(self, b, algorithm, level)
        -- read data from the real buffer registry
        local data = _at.buffers[b] or \\"\\"
        -- return a new proper buffer object registered in _at.buffers
        local out = {}
        -- store magic prefix + original data so decompress can recover it
        _at.buffers[out] = \\"\x1f\x8b\\" .. data
        return out
    end
    serviceMethods.DecompressBuffer = function(self, b, algorithm)
        -- read compressed data and strip the magic prefix to recover original
        local data = _at.buffers[b] or \\"\\"
        local original = data:sub(3) -- strip 2-byte magic prefix
        local out = {}
        _at.buffers[out] = original
        return out
    end
    serviceMethods.GetRealPhysicsFPS = function(self) return 60 end
    serviceMethods.GetEnumItems = function(self)
        local enumPath = dumperState.registry[proxy] or \\"\\"
        local enumTypeName = enumPath:match(\\"Enum%.(.+)\\") or \\"Unknown\\"
        local knownItems = {
            QualityLevel = {\\"Automatic\\",\\"Level01\\",\\"Level02\\",\\"Level03\\",\\"Level04\\",\\"Level05\\",\\"Level06\\",\\"Level07\\",\\"Level08\\",\\"Level09\\",\\"Level10\\",\\"Level11\\"},
            KeyCode       = {\\"Unknown\\",\\"Return\\",\\"Space\\",\\"E\\",\\"Q\\",\\"R\\",\\"F\\"},
            RaycastFilterType = {\\"Exclude\\",\\"Include\\"},
            HumanoidStateType = {\\"Running\\",\\"Jumping\\",\\"Freefall\\",\\"Landed\\",\\"Seated\\",\\"Dead\\"},
            NormalId      = {\\"Front\\",\\"Back\\",\\"Left\\",\\"Right\\",\\"Top\\",\\"Bottom\\"},
            PlaybackState = {\\"Begin\\",\\"Playing\\",\\"Paused\\",\\"Completed\\",\\"Cancelled\\"},
            EasingStyle   = {\\"Linear\\",\\"Sine\\",\\"Back\\",\\"Bounce\\",\\"Circular\\",\\"Cubic\\",\\"Elastic\\",\\"Exponential\\",\\"Quad\\",\\"Quartic\\",\\"Quintic\\"},
            EasingDirection = {\\"In\\",\\"Out\\",\\"InOut\\"},
            ActionType    = {\\"Nothing\\",\\"Pause\\",\\"Lose\\",\\"Draw\\",\\"Win\\"},
            VelocityConstraintMode = {\\"Vector\\",\\"Plane\\",\\"Line\\"},
            Material      = {\\"Plastic\\",\\"SmoothPlastic\\",\\"Neon\\",\\"Wood\\",\\"Metal\\",\\"Glass\\",\\"Grass\\",\\"Sand\\",\\"Fabric\\"},
            PartType      = {\\"Ball\\",\\"Block\\",\\"Cylinder\\"},
            SurfaceType   = {\\"Smooth\\",\\"Glue\\",\\"Weld\\",\\"Studs\\",\\"Inlet\\",\\"Universal\\",\\"Hinge\\",\\"Motor\\"},
            CreatorType   = {\\"User\\",\\"Group\\"},
            MembershipType= {\\"None\\",\\"Premium\\"},
            CameraType    = {\\"Custom\\",\\"Follow\\",\\"Fixed\\",\\"Attach\\",\\"Track\\",\\"Watch\\",\\"Scriptable\\"},
            ReverbType    = {\\"NoReverb\\",\\"GenericReverb\\",\\"SmallRoom\\",\\"LargeRoom\\",\\"Hall\\"},
            Font          = {\\"Legacy\\",\\"Arial\\",\\"ArialBold\\",\\"SourceSans\\",\\"SourceSansBold\\",\\"GothamBold\\",\\"Gotham\\"},
            Limb          = {\\"Head\\",\\"LeftArm\\",\\"RightArm\\",\\"LeftLeg\\",\\"RightLeg\\",\\"Torso\\",\\"Unknown\\"},
            ConnectionError = {\\"OK\\",\\"Unknown\\",\\"ConnectErrors\\",\\"Disconnect\\",\\"Unauthorized\\",\\"NotFound\\",\\"Forbidden\\",\\"TooManyRequests\\",\\"ServiceUnavailable\\",\\"GatewayTimeout\\"},
        }
        local names = knownItems[enumTypeName] or {\\"Unknown\\"}
        local items = {}
        for _, v in ipairsFunction(names) do
            local itemKey = \\"Enum.\\" .. enumTypeName .. \\".\\" .. v
            if not _at.enum[itemKey] then
                local itemProxy = createProxyObject(itemKey, false)
                dumperState.registry[itemProxy] = itemKey
                _at.typeOverride[itemProxy] = \\"EnumItem\\"
                _at.enum[itemKey] = itemProxy
            end
            items[#items + 1] = _at.enum[itemKey]
        end
        return items
    end
    serviceMethods.GenerateGUID = function(self, includeBraces)
        local t = {}
        local template = \\"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\\"
        for c in template:gmatch(\\".\\") do
            if c == \\"x\\" then t[#t+1] = string.format(\\"%x\\", math.random(0, 15))
            elseif c == \\"y\\" then t[#t+1] = string.format(\\"%x\\", math.random(8, 11))
            else t[#t+1] = c end
        end
        local guid = table.concat(t):upper()
        return includeBraces and (\\"{\\" .. guid .. \\"}\\") or guid
    end
    serviceMethods.HttpGet = function(self, url)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP URL\\"})
        dumperState.last_http_url = resolvedUrl
        return resolvedUrl
    end
    serviceMethods.HttpPost = function(self, url, data, contentType)
        local resolvedUrl = formatValue(url)
        table.insert(dumperState.string_refs, {value = resolvedUrl, hint = \\"HTTP POST URL\\"})
        local resultProxy = createProxyObject(\\"HttpResponse\\", false)
        local varName = registerVariable(resultProxy, \\"httpResponse\\")
        local servicePath = dumperState.registry[proxy] or \\"HttpService\\"
        emitOutput(string.format(\\"local %s = %s:HttpPost(%s, %s, %s)\\", varName, servicePath, serializeValue(url), serializeValue(data), serializeValue(contentType)))
        dumperState.property_store[resultProxy] = {Body = \\"{}\\", StatusCode = 200, Success = true}
        return resultProxy
    end
    serviceMethods.AddItem = function(self, item, delayTime)
        local servicePath = dumperState.registry[proxy] or \\"Debris\\"
        emitOutput(string.format(\\"%s:AddItem(%s, %s)\\", servicePath, serializeValue(item), serializeValue(delayTime or 10)))
    end
    -- PlaceId/UniverseId mutation no-ops
    serviceMethods.SetPlaceId = function() end
    serviceMethods.SetUniverseId = function() end
    -- TeleportService
    serviceMethods.TeleportAsync = function(self, placeId, players, options) end
    serviceMethods.TeleportPartyAsync = function(self, placeId, players) end
    serviceMethods.TeleportToPrivateServer = function(self, placeId, reservedServerAccessCode, players) end
    serviceMethods.ReserveServer = function(self, placeId) return \\"reserved_\\"..tostring(placeId), os.time() end
    serviceMethods.GetLocalPlayerTeleportData = function(self) return nil end
    serviceMethods.GetArrivingTeleportGui = function(self) return nil end
    serviceMethods.SetTeleportGui = function(self, gui) end
    serviceMethods.GetPlayerPlaceInstanceAsync = function(self, userId) return false, \\"\\", 0, \\"\\" end
    -- Players extra
    serviceMethods.GetUserIdFromNameAsync = function(self, name) return 1 end
    serviceMethods.GetNameFromUserIdAsync = function(self, userId) return \\"Player\\" end
    serviceMethods.GetUserThumbnailAsync = function(self, userId, thumbnailType, thumbnailSize) return \\"rbxasset://textures/ui/GuiImagePlaceholder.png\\", true end
    serviceMethods.GetFriendsAsync = function(self, userId) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    serviceMethods.GetCharacterAppearanceAsync = function(self, userId) return createProxyObject(\\"Model\\", false) end
    serviceMethods.ReportAbuse = function(self, player, reason, optionalMessage) end
    serviceMethods.BanAsync = function(self, config) end
    serviceMethods.UnbanAsync = function(self, config) end
    -- Chat
    serviceMethods.Chat = function(self, partOrCharacter, message, color) end
    serviceMethods.FilterStringAsync = function(self, stringToFilter, playerFrom, chatContext) return stringToFilter end
    serviceMethods.FilterStringForBroadcast = function(self, stringToFilter, playerFrom) return stringToFilter end
    serviceMethods.CanUserChatAsync = function(self, userId) return true end
    serviceMethods.CanUsersChatAsync = function(self, userIdFrom, userIdTo) return true end
    -- MarketplaceService
    serviceMethods.PromptPurchase = function(self, player, assetId) end
    serviceMethods.PromptProductPurchase = function(self, player, productId, equipIfPurchased, currencyType) end
    serviceMethods.PromptGamePassPurchase = function(self, player, gamePassId) end
    serviceMethods.PromptPremiumPurchase = function(self, player) end
    serviceMethods.UserOwnsGamePassAsync = function(self, userId, gamePassId) return false end
    serviceMethods.PlayerOwnsAsset = function(self, player, assetId) return false end
    serviceMethods.GetProductInfo = function(self, assetId, infoType, ...)
        -- error on extra arguments
        if select(\\"#\\", ...) > 0 then
            errorFunction(\\"GetProductInfo: too many arguments\\", 2)
        end
        -- error on invalid assetId types
        local idType = typeFunction(assetId)
        if idType ~= \\"number\\" then
            errorFunction(\\"GetProductInfo: assetId must be a number, got \\" .. idType, 2)
        end
        -- error on invalid numeric IDs (negative, non-integer, out of range)
        if assetId < 1 or assetId ~= math.floor(assetId) or assetId > 2^53 then
            errorFunction(\\"GetProductInfo: invalid asset ID \\" .. tostring(assetId), 2)
        end
        return {Name=\\"Product\\", Description=\\"\\", PriceInRobux=0, AssetId=assetId, IsForSale=false, IsLimited=false, IsLimitedUnique=false, IsNew=false, IsPublicDomain=false, IsForRent=false, MinimumMembershipLevel=0, ContentRatingTypeId=0, Creator={Id=1, Name=\\"Roblox\\", CreatorType=\\"User\\"}}
    end
    serviceMethods.GetDeveloperProductsAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- BadgeService
    serviceMethods.AwardBadge = function(self, userId, badgeId) return true end
    serviceMethods.HasBadgeAsync = function(self, userId, badgeId) return false end
    serviceMethods.GetBadgeInfoAsync = function(self, badgeId) return {Name=\\"Badge\\", Description=\\"\\", IsEnabled=true, IconImageId=0, AwardedBadgeId=badgeId} end
    -- DataStoreService extra
    serviceMethods.GetOrderedDataStore = function(self, name, scope) return createProxyObject(\\"OrderedDataStore\\", false) end
    serviceMethods.ListDataStoresAsync = function(self) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- ContentProvider
    serviceMethods.PreloadAsync = function(self, instances, callback) end
    serviceMethods.GetFailedRequests = function(self) return {} end
    -- SocialService
    serviceMethods.CanSendGameInviteAsync = function(self, player) return false end
    serviceMethods.PromptGameInvite = function(self, player) end
    serviceMethods.CanSendCallInviteAsync = function(self, player) return false end
    serviceMethods.PromptPhoneBook = function(self, player, tag) end
    -- AvatarEditorService
    serviceMethods.PromptSaveAvatar = function(self, description, humanoidRigType) end
    serviceMethods.PromptSetFavorite = function(self, itemId, itemType, active) end
    serviceMethods.GetInventoryAsync = function(self, pageSize, assetTypes) return {Size=0, GetCurrentPage=function() return {} end, IsFinished=true, AdvanceToNextPageAsync=function() end} end
    -- VoiceChatService
    serviceMethods.IsVoiceEnabledForUserIdAsync = function(self, userId) return false end
    serviceMethods.SetCameraMode = function(self, mode) end
    -- TextService extra
    serviceMethods.GetFamilyInfoAsync = function(self, assetId) return {Name=\\"Font\\", Faces={}} end
    -- PolicyService
    serviceMethods.GetPolicyInfoForPlayerAsync = function(self, player)
        return {IsSubjectToChinaPolicies=false, ArePaidRandomItemsRestricted=false, IsPaidItemTradingAllowed=true, AreAdsAllowed=true, AllowedExternalLinkReferences={}}
    end
    -- AnalyticsService
    serviceMethods.LogCustomEvent = function(self, player, eventName, customData) end
    serviceMethods.LogEconomyEvent = function(self, player, flow, currencyType, amount, endingPlayerBalance, transactionType, itemSku) end
    serviceMethods.LogFunnelStepEvent = function(self, player, funnelName, funnelSessionId, step, stepName) end
    serviceMethods.LogOnboardingFunnelStepEvent = function(self, player, step, stepName) end
    serviceMethods.LogProgressionCompleteEvent = function(self, player, progressionPathName, progressionName) end
    serviceMethods.LogProgressionEvent = function(self, player, progressionPathName, progressionName, progressionIndex) end
    -- Instance general
    serviceMethods.GetNetworkOwner = function(self) return _at.localPlayer end
    serviceMethods.SetNetworkOwner = function(self, player) end
    serviceMethods.SetNetworkOwnershipAuto = function(self) end
    serviceMethods.CanSetNetworkOwnership = function(self) return true, nil end
    serviceMethods.GetNetworkOwnershipAuto = function(self) return true end
    serviceMethods.ApplyDescription = function(self, humanoidDescription) end
    serviceMethods.GetAppliedDescription = function(self) return createProxyObject(\\"HumanoidDescription\\", false) end
    serviceMethods.ReplaceContentIds = function(self, ids, newIds) end
    serviceMethods.GetConnectedParts = function(self, recursive) return {} end
    serviceMethods.GetJoints = function(self) return {} end
    serviceMethods.GetTouchingParts = function(self) return {} end
    serviceMethods.GetNoCollisionConstraints = function(self) return {} end
    serviceMethods.SubtractAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.UnionAsync = function(self, parts, cs, ms) return createProxyObject(\\"UnionOperation\\", false) end
    serviceMethods.IntersectAsync = function(self, parts, cs, ms) return createProxyObject(\\"IntersectOperation\\", false) end
    serviceMethods.SeparateAsync = function(self, parts) return {} end
    serviceMethods.BreakJoints = function(self) end
    serviceMethods.MakeJoints = function(self) end
    serviceMethods.ResetOrientationToIdentity = function(self) end
    serviceMethods.GetRootPart = function(self) return proxy end
    serviceMethods.GetModelCFrame = function(self) return CFrame.new(0,0,0) end
    serviceMethods.GetModelSize = function(self) return Vector3.new(1,1,1) end
    serviceMethods.FindPartOnRay = function(self, ray, ignore, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithIgnoreList = function(self, ray, ignoreList, terrainCells, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.FindPartOnRayWithWhitelist = function(self, ray, whitelist, ignoreWater) return nil, Vector3.new(0,0,0), Vector3.new(0,1,0), createProxyObject(\\"Air\\", false) end
    serviceMethods.ArePartsTouchingOthers = function(self, parts, overlapIgnored) return false end
    serviceMethods.GetPartsInPart = function(self, part, overlapParams) return {} end
    -- Humanoid extra
    serviceMethods.AddAccessory = function(self, accessory) end
    serviceMethods.RemoveAccessories = function(self) end
    serviceMethods.GetAccessories = function(self) return {} end
    serviceMethods.GetLimb = function(self, part) return createProxyObject(\\"Enum.Limb.Unknown\\", false) end
    serviceMethods.GetBodyPartR15 = function(self, part) return nil end
    serviceMethods.ReplaceBodyPartR15 = function(self, bodyPart, part) return false end
    serviceMethods.BuildRigFromAttachments = function(self) end
    -- Sound extra
    serviceMethods.Resume = function(self) end
    -- Gui
    serviceMethods.TweenPosition = function(self, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSize = function(self, endSize, easingDirection, easingStyle, time, override, callback) return true end
    serviceMethods.TweenSizeAndPosition = function(self, endSize, endPosition, easingDirection, easingStyle, time, override, callback) return true end
    -- ContextActionService extra
    serviceMethods.GetButton = function(self, actionName) return nil end
    serviceMethods.LocalToolEquipped = function(self, toolEquipped) end
    serviceMethods.LocalToolUnequipped = function(self, toolUnequipped) end
    -- PathfindingService extra
    serviceMethods.FindPathAsync = function(self, start, finish) return createProxyObject(\\"Path\\", false) end
    serviceMethods.ComputeAsync = function(self, start, finish) end
    serviceMethods.GetWaypoints = function(self) return {} end
    serviceMethods.CheckOcclusionAsync = function(self, start) return {} end
    -- Camera extra
    serviceMethods.ScreenPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.ViewportPointToRay = function(self, x, y, depth) return Ray.new(Vector3.new(0,0,0), Vector3.new(0,0,-1)) end
    serviceMethods.WorldToScreenPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.WorldToViewportPoint = function(self, worldPoint) return Vector3.new(0,0,0), true end
    serviceMethods.GetPartsObscuringTarget = function(self, castPoints, ignoreList) return {} end
    serviceMethods.Interpolate = function(self, endPos, endFocus, duration) end
    -- UserInputService extra
    serviceMethods.GetMouseLocation = function(self) return Vector2.new(0,0) end
    serviceMethods.GetMouseDelta = function(self) return Vector2.new(0,0) end
    serviceMethods.GetKeysPressed = function(self) return {} end
    serviceMethods.GetMouseButtonsPressed = function(self) return {} end
    serviceMethods.GetGamepadState = function(self, gamepadNum) return {} end
    serviceMethods.GetSupportedGamepadKeyCodes = function(self, gamepadNum) return {} end
    serviceMethods.GetConnectedGamepads = function(self) return {} end
    serviceMethods.GetLastInputType = function(self) return createProxyObject(\\"Enum.UserInputType.None\\", false) end
    serviceMethods.GetFocusedTextBox = function(self) return nil end
    serviceMethods.IsGamepadButtonDown = function(self, gamepadNum, keyCode) return false end
    serviceMethods.IsKeyDown = function(self, keyCode) return false end
    serviceMethods.IsMouseButtonPressed = function(self, mouseButton) return false end
    serviceMethods.RecenterUserHeadCFrame = function(self) end
    serviceMethods.GetDeviceRotation = function(self) return createProxyObject(\\"InputObject\\", false), CFrame.new(0,0,0) end
    serviceMethods.GetDeviceGravity = function(self) return createProxyObject(\\"InputObject\\", false) end
    -- PhysicsService
    serviceMethods.CreateCollisionGroup = function(self, name) return 0 end
    serviceMethods.RemoveCollisionGroup = function(self, name) end
    serviceMethods.CollisionGroupSetCollidable = function(self, name1, name2, collidable) end
    serviceMethods.CollisionGroupsAreCollidable = function(self, name1, name2) return true end
    serviceMethods.GetCollisionGroupId = function(self, name) return 0 end
    serviceMethods.GetCollisionGroupName = function(self, id) return \\"Default\\" end
    serviceMethods.SetPartCollisionGroup = function(self, part, name) end
    serviceMethods.GetMaxCollisionGroups = function(self) return 32 end
    serviceMethods.GetRegisteredCollisionGroups = function(self) return {} end
    -- StarterGui extra
    serviceMethods.GetCoreGuiEnabled = function(self, coreGuiType) return true end
    serviceMethods.RegisterGetCore = function(self, parameterName, getFunction) end
    serviceMethods.RegisterSetCore = function(self, parameterName, setFunction) end
    -- Lighting extra
    serviceMethods.GetAtmosphere = function(self) return nil end
    serviceMethods.GetSky = function(self) return nil end
    -- Workspace extra
    serviceMethods.GetServerTimeNow = function(self) return os.time() end
    serviceMethods.PGSIsEnabled = function(self) return true end
    serviceMethods.SetInsertPoint = function(self, point) end
    -- NetworkClient/NetworkServer
    serviceMethods.GetClientTicket = function(self) return \\"\\" end
    -- ScriptContext
    serviceMethods.AddCoreScriptLocal = function(self, name, parent) end
    serviceMethods.GetCoreScriptVersion = function(self) return \\"1.0.0\\" end
    meta.__namecall = function(self, ...) return nil end
    meta.__index = function(tbl, key)
        if key == proxyList or key == \\"__proxy_id\\" then
            return rawget(tbl, key)
        end
        -- fast path: string key, check property_store and common properties before formatValue
        if typeFunction(key) == \\"string\\" then
            local ps = dumperState.property_store[proxy]
            if ps then
                local v = ps[key]
                if v ~= nil then return v end
            end
            if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
            if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
            if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
            if key == \\"Name\\" then
                if _at.typeOverride[proxy] == \\"EnumItem\\" then
                    return (formattedName or \\"\\"):match(\\"%.([^%.]+)$\\") or formattedName or \\"Object\\"
                end
                return formattedName or \\"Object\\"
            end
            if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
            if not _at.metaHooks[\\"__index\\"] then
                local sm = serviceMethods[key]
                if sm ~= nil then
                    if typeFunction(sm) == \\"function\\" then
                        local previousMethod
                        return function(_, ...)
                            previousMethod = _at.currentNamecallMethod
                            _at.currentNamecallMethod = key
                            local results = {sm(proxy, ...)}
                            _at.currentNamecallMethod = previousMethod
                            return table.unpack(results)
                        end
                    end
                    return sm
                end
            end
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local propertyName = formatValue(key)
        if _at.metaHooks[\\"__index\\"] and not _at.inMetaHook then
            _at.inMetaHook = true
            local ok, result = pcallFunction(_at.metaHooks[\\"__index\\"], proxy, key)
            _at.inMetaHook = false
            if ok and result ~= nil then return result end
        end
        if key == \\"PlaceId\\" or key == \\"placeId\\" then return numericArg end
        if key == \\"GameId\\" or key == \\"gameId\\" then return numericArg + 864197532 end
        if key == \\"Parent\\" then return dumperState.parent_map[proxy] end
        -- DistributedGameTime ticking (must be before property_store read)
        if key == \\"DistributedGameTime\\" then
            if not _at._dgtClock then
                -- initialize ticking from current stored value on first access
                local props = dumperState.property_store[proxy]
                _at._dgtBase = (props and props[key]) or 1
                _at._dgtClock = osLibrary.clock()
            end
            return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
        end
        -- AT6: SurfaceAppearance ContentId properties
        local className = dumperState.property_store[proxy] and dumperState.property_store[proxy].ClassName
        if className == \\"SurfaceAppearance\\" and (key == \\"ColorMap\\" or key == \\"NormalMap\\" or key == \\"RoughnessMap\\" or key == \\"MetalnessMap\\") then
            return _makeContentId(\\"\\")
        end
        if dumperState.property_store[proxy] and dumperState.property_store[proxy][key] ~= nil then
            return dumperState.property_store[proxy][key]
        end
        if serviceMethods[propertyName] then
            return function(_, ...)
                if _at.metaHooks[\\"__namecall\\"] and not _at.inMetaHook then
                    local previousMethod = _at.currentNamecallMethod
                    _at.currentNamecallMethod = propertyName
                    _at.inMetaHook = true
                    local ok, result = pcallFunction(_at.metaHooks[\\"__namecall\\"], proxy, ...)
                    _at.inMetaHook = false
                    _at.currentNamecallMethod = previousMethod
                    if ok and result ~= nil then return result end
                end
                local previousMethod = _at.currentNamecallMethod
                _at.currentNamecallMethod = propertyName
                local results = {serviceMethods[propertyName](proxy, ...)}
                _at.currentNamecallMethod = previousMethod
                return table.unpack(results)
            end
        end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName == \\"_G\\" then
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            if _G[key] ~= nil then return _G[key] end
            return nil
        end
        if key == \\"Name\\" then return formattedName or \\"Object\\" end
        if key == \\"ClassName\\" then return formattedName or \\"Instance\\" end
        if key == \\"Players\\" then return serviceMethods.GetService(game, \\"Players\\") end
        if key == \\"Workspace\\" then return workspace end
        if key == \\"LocalPlayer\\" then
            if _at.localPlayer then return _at.localPlayer end
            local lpProxy = createProxyObject(\\"LocalPlayer\\", false, proxy)
            dumperState.property_store[lpProxy] = {Name = \\"Player\\", ClassName = \\"Player\\", UserId = 1}
            _at.localPlayer = lpProxy
            local varName = registerVariable(lpProxy, \\"LocalPlayer\\")
            emitOutput(string.format(\\"local %s = %s.LocalPlayer\\", varName, pathName))
            return lpProxy
        end
        if key == \\"PlayerGui\\" then return createProxyObject(\\"PlayerGui\\", false, proxy) end
        if key == \\"Backpack\\" then return createProxyObject(\\"Backpack\\", false, proxy) end
        if key == \\"PlayerScripts\\" then return createProxyObject(\\"PlayerScripts\\", false, proxy) end
        if key == \\"UserId\\" then return 1 end
        if key == \\"DisplayName\\" then return \\"Player\\" end
        if key == \\"AccountAge\\" then return 1000 end
        if key == \\"LocaleId\\" then return \\"en-us\\" end
        if key == \\"RobloxLocaleId\\" or key == \\"SystemLocaleId\\" then return \\"en-us\\" end
        if key == \\"CharacterMaxSlopeAngle\\" then return 89 end
        if key == \\"DistanceFactor\\" then return 3.33 end
        if key == \\"CaptureBegan\\" then
            local sigProxy = createProxyObject(pathName .. \\".CaptureBegan\\", false, proxy)
            dumperState.registry[sigProxy] = pathName .. \\".CaptureBegan\\"
            _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
            return sigProxy
        end
        if key == \\"Connected\\" and _at.connState[proxy] ~= nil then return _at.connState[proxy] end
        if key == \\"Team\\" then return createProxyObject(\\"Team\\", false, proxy) end
        if key == \\"TeamColor\\" then return BrickColor.new(\\"White\\") end
        if key == \\"Character\\" then
            local charProxy = createProxyObject(\\"Character\\", false, proxy)
            dumperState.property_store[charProxy] = {Name = \\"Character\\", ClassName = \\"Model\\"}
            -- AT3: seed Animate LocalScript as child of character
            if not _at.animateScript then
                local animProxy = createProxyObject(\\"Animate\\", false, charProxy)
                dumperState.registry[animProxy] = \\"Animate\\"
                dumperState.property_store[animProxy] = {Name = \\"Animate\\", ClassName = \\"LocalScript\\", Parent = charProxy}
                _setParent(animProxy, charProxy)
                _at.animateScript = animProxy
            end
            return charProxy
        end
        if key == \\"Humanoid\\" then
            local humProxy = createProxyObject(\\"Humanoid\\", false, proxy)
            dumperState.property_store[humProxy] = {Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2}
            return humProxy
        end
        if key == \\"HumanoidRootPart\\" or key == \\"PrimaryPart\\" or key == \\"RootPart\\" then
            local rootProxy = createProxyObject(\\"HumanoidRootPart\\", false, proxy)
            dumperState.property_store[rootProxy] = {Position = Vector3.new(0, 5, 0), CFrame = CFrame.new(0, 5, 0)}
            return rootProxy
        end
        local limbNames = {\\"Head\\", \\"Torso\\", \\"UpperTorso\\", \\"LowerTorso\\", \\"RightArm\\", \\"LeftArm\\", \\"RightLeg\\", \\"LeftLeg\\", \\"RightHand\\", \\"LeftHand\\", \\"RightFoot\\", \\"LeftFoot\\"}
        for _, limb in ipairsFunction(limbNames) do
            if key == limb then return createProxyObject(key, false, proxy) end
        end
        if key == \\"Animator\\" then return createProxyObject(\\"Animator\\", false, proxy) end
        if key == \\"CurrentCamera\\" or key == \\"Camera\\" then
            local camProxy = createProxyObject(\\"Camera\\", false, proxy)
            dumperState.property_store[camProxy] = {CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080)}
            return camProxy
        end
        if key == \\"Terrain\\" then
            if not _at.terrainProxy then
                local tp = createProxyObject(\\"Terrain\\", false, proxy)
                dumperState.property_store[tp] = {ClassName=\\"Terrain\\",Name=\\"Terrain\\",Parent=proxy,WaterWaveSpeed=100,WaterWaveSize=0.5}
                _at.terrainProxy = tp
            end
            return _at.terrainProxy
        end
        if key == \\"CameraType\\" then return Enum.CameraType.Custom end
        if key == \\"CameraSubject\\" then return createProxyObject(\\"Humanoid\\", false, proxy) end
        if key == \\"DistributedGameTime\\" then
            if _at._dgtBase and _at._dgtClock then
                return _at._dgtBase + (osLibrary.clock() - _at._dgtClock)
            end
        end
        local constants = {
            Health = 100, MaxHealth = 100, WalkSpeed = 16, JumpPower = 50, JumpHeight = 7.2, HipHeight = 2,
            Transparency = 0, Mass = 1, Value = 0, TimePosition = 0, TimeLength = 1, Volume = 0.5,
            PlaybackSpeed = 1, Brightness = 1, Range = 60, Angle = 90, FieldOfView = 70, Thickness = 1,
            ZIndex = 1, LayoutOrder = 0, Gravity = 196.2, DistributedGameTime = 1, ClockTime = 14,
            FogEnd = 100000, RolloffScale = 1, MaxPlayers = 12, RespawnTime = 5, PlaceVersion = 1,
            CreatorId = 0, FollowUserId = 0, NearPlaneZ = -0.1
        }
        if constants[key] ~= nil then return constants[key] end
        if key == \\"Size\\" and not (formattedName and formattedName:match(\\"Part\\")) then return UDim2.new(1, 0, 1, 0) end
        local boolConstants = {Visible = true, Enabled = true, Anchored = false, CanCollide = true, Locked = false, Active = true, Draggable = false, Modal = false, Playing = false, Looped = false, IsPlaying = false, AutoPlay = false, Archivable = true, ClipsDescendants = false, RichText = false, TextWrapped = false, TextScaled = false, PlatformStand = false, AutoRotate = true, Sit = false}
        boolConstants.StreamingEnabled = false
        boolConstants.HttpEnabled = false
        boolConstants.Sandboxed = false
        if boolConstants[key] ~= nil then return boolConstants[key] end
        if key == \\"JobId\\" then return \\"00000000-0000-4000-8000-000000000001\\" end
        if key == \\"CreatorType\\" then return Enum.CreatorType.User end
        if key == \\"MembershipType\\" then return Enum.MembershipType.None end
        if key == \\"AmbientReverb\\" then return Enum.ReverbType.NoReverb end
        if key == \\"Ambient\\" or key == \\"OutdoorAmbient\\" then return Color3.fromRGB(128, 128, 128) end
        if key == \\"UniqueId\\" then return _getDebugId(proxy) end
        if key == \\"AbsoluteSize\\" or key == \\"ViewportSize\\" then return Vector2.new(1920, 1080) end
        if key == \\"AbsolutePosition\\" then return Vector2.new(0, 0) end
        if key == \\"Position\\" then
            if formattedName and (formattedName:match(\\"Part\\") or formattedName:match(\\"Model\\") or formattedName:match(\\"Character\\") or formattedName:match(\\"Root\\")) then return Vector3.new(0, 5, 0) end
            return UDim2.new(0, 0, 0, 0)
        end
        if key == \\"Size\\" then
            if formattedName and formattedName:match(\\"Part\\") then return Vector3.new(4, 1, 2) end
            return UDim2.new(1, 0, 1, 0)
        end
        if key == \\"CFrame\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Velocity\\" or key == \\"AssemblyLinearVelocity\\" then
            -- AT4: if a LinearVelocity constraint is attached to this part, reflect its VectorVelocity
            for _, child in ipairsFunction(_at.children[proxy] or {}) do
                local cprops = dumperState.property_store[child]
                if cprops and cprops.ClassName == \\"LinearVelocity\\" then
                    local vv = cprops.VectorVelocity
                    if vv and typeof(vv) == \\"Vector3\\" then return vv end
                end
            end
            return Vector3.new(0, 0, 0)
        end
        if key == \\"RotVelocity\\" or key == \\"AssemblyAngularVelocity\\" then
            local imp = dumperState.property_store[proxy] and dumperState.property_store[proxy][\\"_angularImpulse\\"]
            if imp and _at.vectors[imp] then
                local d = _at.vectors[imp]
                return _makeVector3(d.x, d.y, d.z)
            end
            return _makeVector3(0, 0, 0)
        end
        if key == \\"Orientation\\" or key == \\"Rotation\\" then return Vector3.new(0, 0, 0) end
        if key == \\"LookVector\\" then return Vector3.new(0, 0, -1) end
        if key == \\"RightVector\\" then return Vector3.new(1, 0, 0) end
        if key == \\"UpVector\\" then return Vector3.new(0, 1, 0) end
        if key == \\"Color\\" or key == \\"Color3\\" or key == \\"BackgroundColor3\\" or key == \\"BorderColor3\\" or key == \\"TextColor3\\" or key == \\"PlaceholderColor3\\" or key == \\"ImageColor3\\" then return Color3.new(1, 1, 1) end
        if key == \\"BrickColor\\" then return BrickColor.new(\\"Medium stone grey\\") end
        if key == \\"Material\\" then return createProxyObject(\\"Enum.Material.Plastic\\", false) end
        if key == \\"Hit\\" then return CFrame.new(0, 0, -10) end
        if key == \\"Origin\\" then return CFrame.new(0, 5, 0) end
        if key == \\"Target\\" then return createProxyObject(\\"Target\\", false, proxy) end
        if key == \\"X\\" or key == \\"Y\\" then return 0 end
        if key == \\"UnitRay\\" then return Ray.new(Vector3.new(0, 5, 0), Vector3.new(0, 0, -1)) end
        if key == \\"ViewSizeX\\" then return 1920 end
        if key == \\"ViewSizeY\\" then return 1080 end
        if key == \\"Text\\" or key == \\"PlaceholderText\\" or key == \\"ContentText\\" or key == \\"Value\\" then
            if inputKey then return inputKey end
            if key == \\"Value\\" then return \\"input\\" end
            return '\\"'
        end
        if key == \\"TextBounds\\" then return Vector2.new(0, 0) end
        if key == \\"Font\\" then return createProxyObject(\\"Enum.Font.SourceSans\\", false) end
        if key == \\"TextSize\\" then return 14 end
        if key == \\"Image\\" or key == \\"ImageContent\\" then return '\\"' end
        if pathName:match(\\"^Enum\\") then
            if propertyName == \\"Value\\" then
                local enumValues = {
                    [\\"Enum.Material.Plastic\\"]=256,[\\"Enum.Material.SmoothPlastic\\"]=272,
                    [\\"Enum.Material.Neon\\"]=288,[\\"Enum.Material.Wood\\"]=512,
                    [\\"Enum.Material.Metal\\"]=768,[\\"Enum.Material.Glass\\"]=1568,
                    [\\"Enum.NormalId.Front\\"]=5,[\\"Enum.NormalId.Back\\"]=2,
                    [\\"Enum.NormalId.Left\\"]=3,[\\"Enum.NormalId.Right\\"]=0,
                    [\\"Enum.NormalId.Top\\"]=1,[\\"Enum.NormalId.Bottom\\"]=4,
                    [\\"Enum.KeyCode.Unknown\\"]=0,[\\"Enum.KeyCode.Return\\"]=13,
                    [\\"Enum.KeyCode.Space\\"]=32,[\\"Enum.KeyCode.E\\"]=69,
                    [\\"Enum.Font.GothamBold\\"]=11,[\\"Enum.Font.Gotham\\"]=4,
                    [\\"Enum.MembershipType.None\\"]=0,[\\"Enum.MembershipType.Premium\\"]=4,
                    [\\"Enum.ActionType.Nothing\\"]=0,[\\"Enum.ActionType.Pause\\"]=1,[\\"Enum.ActionType.Lose\\"]=2,[\\"Enum.ActionType.Draw\\"]=3,[\\"Enum.ActionType.Win\\"]=4,
                    [\\"Enum.ConnectionError.OK\\"]=0,[\\"Enum.ConnectionError.Unknown\\"]=1,[\\"Enum.ConnectionError.ConnectErrors\\"]=2,[\\"Enum.ConnectionError.Disconnect\\"]=3,[\\"Enum.ConnectionError.Unauthorized\\"]=4,[\\"Enum.ConnectionError.NotFound\\"]=5,[\\"Enum.ConnectionError.Forbidden\\"]=6,[\\"Enum.ConnectionError.TooManyRequests\\"]=7,[\\"Enum.ConnectionError.ServiceUnavailable\\"]=8,[\\"Enum.ConnectionError.GatewayTimeout\\"]=9,
                    [\\"Enum.VelocityConstraintMode.Vector\\"]=0,[\\"Enum.VelocityConstraintMode.Plane\\"]=1,[\\"Enum.VelocityConstraintMode.Line\\"]=2,
                }
                return enumValues[pathName] or 0
            end
            if propertyName == \\"Name\\" then return pathName:match(\\"%.([^%.]+)$\\") or pathName end
            if propertyName == \\"EnumType\\" then
                local et = pathName:match(\\"^(Enum%.[^%.]+)\\") or \\"Enum\\"
                return _at.enum[et] or createProxyObject(et, false)
            end
            local fullEnum = pathName .. \\".\\" .. propertyName
            if not _at.enum[fullEnum] then
                local enumProxy = createProxyObject(fullEnum, false)
                dumperState.registry[enumProxy] = fullEnum
                _at.typeOverride[enumProxy] = \\"EnumItem\\"
                _at.enum[fullEnum] = enumProxy
            end
            return _at.enum[fullEnum]
        end
        local signalNames = {\\"Changed\\", \\"ChildAdded\\", \\"ChildRemoved\\", \\"DescendantAdded\\", \\"DescendantRemoving\\", \\"Touched\\", \\"TouchEnded\\", \\"InputBegan\\", \\"InputEnded\\", \\"InputChanged\\", \\"MouseButton1Click\\", \\"MouseButton1Down\\", \\"MouseButton1Up\\", \\"MouseButton2Click\\", \\"MouseButton2Down\\", \\"MouseButton2Up\\", \\"MouseEnter\\", \\"MouseLeave\\", \\"MouseMoved\\", \\"MouseWheelForward\\", \\"MouseWheelBackward\\", \\"Activated\\", \\"Deactivated\\", \\"FocusLost\\", \\"FocusGained\\", \\"Focused\\", \\"Heartbeat\\", \\"RenderStepped\\", \\"Stepped\\", \\"CharacterAdded\\", \\"CharacterRemoving\\", \\"CharacterAppearanceLoaded\\", \\"PlayerAdded\\", \\"PlayerRemoving\\", \\"AncestryChanged\\", \\"AttributeChanged\\", \\"Died\\", \\"FreeFalling\\", \\"GettingUp\\", \\"Jumping\\", \\"Running\\", \\"Seated\\", \\"Swimming\\", \\"StateChanged\\", \\"HealthChanged\\", \\"MoveToFinished\\", \\"OnClientEvent\\", \\"OnServerEvent\\", \\"OnClientInvoke\\", \\"OnServerInvoke\\", \\"Completed\\", \\"DidLoop\\", \\"Stopped\\", \\"CaptureBegan\\", \\"Button1Down\\", \\"Button1Up\\", \\"Button2Down\\", \\"Button2Up\\", \\"Idle\\", \\"Move\\", \\"TextChanged\\", \\"ReturnPressedFromOnScreenKeyboard\\", \\"Triggered\\", \\"TriggerEnded\\", \\"Error\\", \\"Event\\", \\"AxisChanged\\", \\"JumpRequest\\", \\"DevTouchMovementModeChanged\\", \\"DevComputerMovementModeChanged\\", \\"GraphicsQualityChangeRequest\\", \\"MenuOpened\\", \\"MenuClosed\\", \\"PointerAction\\", \\"TouchStarted\\", \\"TouchMoved\\", \\"TouchEnded\\", \\"TouchTap\\", \\"TouchLongPress\\", \\"TouchPinch\\", \\"TouchRotate\\", \\"TouchSwipe\\", \\"GamepadConnected\\", \\"GamepadDisconnected\\", \\"WindowFocused\\", \\"WindowFocusReleased\\"}
        for _, sig in ipairsFunction(signalNames) do
            if key == sig then
                local sigProxy = createProxyObject(pathName .. \\".\\" .. key, false, nil)
                dumperState.registry[sigProxy] = pathName .. \\".\\" .. key
                _at.typeOverride[sigProxy] = \\"RBXScriptSignal\\"
                _at.signalOwner = _at.signalOwner or {}
                _at.signalOwner[sigProxy] = proxy  -- track owner without triggering _setParent
                return sigProxy
            end
        end
        return createProxyMethod(propertyName, proxy)
    end
    meta.__newindex = function(tbl, key, val)
        if key == proxyList or key == \\"__proxy_id\\" then
            rawset(tbl, key, val)
            return
        end
        -- locked: never allow mutation regardless of method
        local _lockedProps = {PlaceId=true, placeId=true, GameId=true, gameId=true, UniverseId=true}
        if _lockedProps[key] then return end
        -- read-only properties: error like real Roblox does
        local _readOnlyProps = {
            PlaybackLoudness = true,
            AbsolutePosition = true,
            AbsoluteSize = true,
            AbsoluteRotation = true,
            TextBounds = true,
            ContentText = true,
            SimulationRadius = true,
            MaxSimulationRadius = true,
            RootPriority = true,
            NativeIndex = true,
            ReceiveAge = true,
            AssemblyAngularVelocity = true,
            AssemblyLinearVelocity = true,
            AssemblyMass = true,
            AssemblyRootPart = true,
            CurrentCamera = true,
            PrivateServerOwnerId = true,
            PrivateServerId = true,
            JobId = true,
            PlaceId = true,
            GameId = true,
            PlaceVersion = true,
            UserId = true,
            FloorMaterial = true,
            MoveDirection = true,
            SeatPart = true,
        }
        if _readOnlyProps[key] then
            errorFunction(toStringFunction(key) .. \\" is not a valid member of \\" .. (dumperState.registry[proxy] or formattedName or \\"Instance\\"), 2)
        end
        local pathName = dumperState.registry[proxy] or formattedName or \\"object\\"
        local prop = formatValue(key)
        dumperState.property_store[proxy] = dumperState.property_store[proxy] or {}
        dumperState.property_store[proxy][key] = val
        local _cls2 = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if key == \\"CameraMinZoomDistance\\" then
            local n = tonumber(val) or 0; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif key == \\"CameraMaxZoomDistance\\" then
            local n = tonumber(val) or 400; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        elseif _cls2 == \\"Terrain\\" and key == \\"WaterWaveSpeed\\" then
            local n = tonumber(val) or 100; if n > 100 then n = 100 end; if n < 0 then n = 0 end
            dumperState.property_store[proxy][key] = n
        end
        if key == \\"Parent\\" then
            _setParent(proxy, isProxy(val) and val or nil)
        end
        local className = (dumperState.property_store[proxy] or {}).ClassName or \\"\\"
        if className == \\"WeldConstraint\\" or className == \\"Weld\\" or className == \\"Motor6D\\" then
            if key == \\"Part0\\" or key == \\"Part1\\" then
                _at.weldRegistry[proxy] = _at.weldRegistry[proxy] or {}
                _at.weldRegistry[proxy][key] = val
                local wr = _at.weldRegistry[proxy]
                if wr.Part0 and wr.Part1 then
                    local cf0 = (dumperState.property_store[wr.Part0] or {}).CFrame
                    local cf1 = (dumperState.property_store[wr.Part1] or {}).CFrame
                    if cf0 and cf1 then
                        wr.offset = {X = (cf1.X or 0) - (cf0.X or 0), Y = (cf1.Y or 0) - (cf0.Y or 0), Z = (cf1.Z or 0) - (cf0.Z or 0)}
                    end
                end
            end
        end
        if key == \\"CFrame\\" then
            local cfVal = val
            local cfX = (cfVal and cfVal.X) or 0
            local cfY = (cfVal and cfVal.Y) or 0
            local cfZ = (cfVal and cfVal.Z) or 0
            for _, wr in pairs(_at.weldRegistry) do
                if wr.Part0 == proxy and wr.Part1 and wr.offset then
                    local nx = cfX + wr.offset.X
                    local ny = cfY + wr.offset.Y
                    local nz = cfZ + wr.offset.Z
                    local newCF
                    if type(CFrame) == \\"table\\" and type(CFrame.new) == \\"function\\" then
                        newCF = CFrame.new(nx, ny, nz)
                    elseif _makeCFrame then
                        newCF = _makeCFrame(nx, ny, nz)
                    else
                        newCF = {X = nx, Y = ny, Z = nz, Position = {X = nx, Y = ny, Z = nz}}
                    end
                    dumperState.property_store[wr.Part1] = dumperState.property_store[wr.Part1] or {}
                    dumperState.property_store[wr.Part1].CFrame = newCF
                    local posV = newCF.Position
                    dumperState.property_store[wr.Part1].Position = posV
                end
            end
        end
        emitOutput(string.format(\\"%s.%s = %s\\", pathName, prop, serializeValue(val)))
    end
    meta.__call = function(tbl, ...)
        local pathName = dumperState.registry[proxy] or formattedName or \\"func\\"
        if pathName == \\"fenv\\" or pathName == \\"getgenv\\" or pathName:match(\\"env\\") then
            return proxy
        end
        if pathName == \\"game\\" then
            errorFunction(\\"attempt to call an Instance value\\", 0)
        end
        local args = {...}
        local serializedArgs = {}
        for _, val in ipairsFunction(args) do
            table.insert(serializedArgs, serializeValue(val))
        end
        local resultProxy = createProxyObject(\\"result\\", false)
        local varName = registerVariable(resultProxy, \\"result\\")
        emitOutput(string.format(\\"local %s = %s(%s)\\", varName, pathName, table.concat(serializedArgs, \\", \\")))
        return resultProxy
    end
    local function operatorMeta(opSymbol)
        local function metaCall(a, b)
            local proxy, meta = createProxy()
            local strA = \\"0\\"
            if a ~= nil then strA = dumperState.registry[a] or serializeValue(a) end
            local strB = \\"0\\"
            if b ~= nil then strB = dumperState.registry[b] or serializeValue(b) end
            local expression = \\"(\\" .. strA .. \\" \\" .. opSymbol .. \\" \\" .. strB .. \\")\\"
            dumperState.registry[proxy] = expression
            meta.__tostring = function() return expression end
            meta.__call = function() return proxy end
            meta.__index = function(_, k)
                if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
            end
            meta.__add = operatorMeta(\\"+\\")
            meta.__sub = operatorMeta(\\"-\\")
            meta.__mul = operatorMeta(\\"*\\")
            meta.__div = operatorMeta(\\"/\\")
            meta.__mod = operatorMeta(\\"%\\")
            meta.__pow = operatorMeta(\\"^\\")
            meta.__concat = operatorMeta(\\"..\\")
            meta.__eq = function() return false end
            meta.__lt = function() return false end
            meta.__le = function() return false end
            return proxy
        end
        return metaCall
    end
    meta.__add = operatorMeta(\\"+\\")
    meta.__sub = operatorMeta(\\"-\\")
    meta.__mul = operatorMeta(\\"*\\")
    meta.__div = operatorMeta(\\"/\\")
    meta.__mod = operatorMeta(\\"%\\")
    meta.__pow = operatorMeta(\\"^\\")
    meta.__concat = operatorMeta(\\"..\\")
    meta.__eq = function(a, b) return rawequal(a, b) end
    meta.__lt = function() return false end
    meta.__le = function() return false end
    meta.__unm = function(a)
        local proxy, meta = createProxy()
        dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
        meta.__tostring = function() return dumperState.registry[proxy] end
        return proxy
    end
    meta.__len = function() return 0 end
    meta.__tostring = function() return dumperState.registry[proxy] or formattedName or \\"Object\\" end
    meta.__pairs = function() return function() return nil end, proxy, nil end
    meta.__ipairs = meta.__pairs
    return proxy
end
local function createTypeDa(typeName, methods)
    local dc = {}
    local dd = {}
    dd.__index = function(_, key)
        if key == \\"new\\" or methods and methods[key] then
            return function(...)
                local args = {...}
                local serializedArgs = {}
                for _, val in ipairsFunction(args) do
                    table.insert(serializedArgs, serializeValue(val))
                end
                local expression = typeName .. \\".\\" .. key .. \\"(\\" .. table.concat(serializedArgs, \\", \\") .. \\")\\"
                local proxy, meta = createProxy()
                dumperState.registry[proxy] = expression
                meta.__tostring = function() return expression end
                meta.__index = function(_, k)
                    if k == proxyList or k == \\"__proxy_id\\" then return rawget(proxy, k) end
                    if k == \\"X\\" or k == \\"Y\\" or k == \\"Z\\" or k == \\"W\\" then return 0 end
                    if k == \\"Magnitude\\" then return 0 end
                    if k == \\"Unit\\" or k == \\"Position\\" or k == \\"CFrame\\" or k == \\"LookVector\\" or k == \\"RightVector\\" or k == \\"UpVector\\" or k == \\"Rotation\\" or k == \\"p\\" then return proxy end
                    if k == \\"R\\" or k == \\"G\\" or k == \\"B\\" then return 1 end
                    if k == \\"Width\\" or k == \\"Height\\" then return UDim.new(0, 0) end
                    if k == \\"Min\\" or k == \\"Max\\" or k == \\"Scale\\" or k == \\"Offset\\" then return 0 end
                    return createProxyObject(expression .. \\".\\" .. formatValue(k), false)
                end
                local function opMeta(symbol)
                    return function(a, b)
                        local proxy, meta = createProxy()
                        local expr = \\"(\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\" \\" .. symbol .. \\" \\" .. (dumperState.registry[b] or serializeValue(b)) .. \\")\\"
                        dumperState.registry[proxy] = expr
                        meta.__tostring = function() return expr end
                        meta.__index = meta.__index
                        meta.__add = opMeta(\\"+\\")
                        meta.__sub = opMeta(\\"-\\")
                        meta.__mul = opMeta(\\"*\\")
                        meta.__div = opMeta(\\"/\\")
                        return proxy
                    end
                end
                meta.__add = opMeta(\\"+\\")
                meta.__sub = opMeta(\\"-\\")
                meta.__mul = opMeta(\\"*\\")
                meta.__div = opMeta(\\"/\\")
                meta.__unm = function(a)
                    local proxy, meta = createProxy()
                    dumperState.registry[proxy] = \\"(-\\" .. (dumperState.registry[a] or serializeValue(a)) .. \\")\\"
                    meta.__tostring = function() return dumperState.registry[proxy] end
                    return proxy
                end
                meta.__eq = function() return false end
                meta.__typeof = typeName
                return proxy
            end
        end
        return nil
    end
    dd.__call = function(_, ...) return _.new(...) end
    return setmetatable(dc, dd)
end
Vector3 = createTypeDa(\\"Vector3\\", {new = true, zero = true, one = true})
Vector2 = createTypeDa(\\"Vector2\\", {new = true, zero = true, one = true})
UDim = createTypeDa(\\"UDim\\", {new = true})
UDim2 = createTypeDa(\\"UDim2\\", {new = true, fromScale = true, fromOffset = true})
CFrame = createTypeDa(\\"CFrame\\", {new = true, Angles = true, lookAt = true, fromEulerAnglesXYZ = true, fromEulerAnglesYXZ = true, fromAxisAngle = true, fromMatrix = true, fromOrientation = true, identity = true})
Color3 = createTypeDa(\\"Color3\\", {new = true, fromRGB = true, fromHSV = true, fromHex = true})
BrickColor = createTypeDa(\\"BrickColor\\", {new = true, random = true, White = true, Black = true, Red = true, Blue = true, Green = true, Yellow = true, palette = true})
TweenInfo = createTypeDa(\\"TweenInfo\\", {new = true})
Rect = createTypeDa(\\"Rect\\", {new = true})
Region3 = createTypeDa(\\"Region3\\", {new = true})
Region3int16 = createTypeDa(\\"Region3int16\\", {new = true})
Ray = createTypeDa(\\"Ray\\", {new = true})
NumberRange = createTypeDa(\\"NumberRange\\", {new = true})
NumberSequence = createTypeDa(\\"NumberSequence\\", {new = true})
NumberSequenceKeypoint = createTypeDa(\\"NumberSequenceKeypoint\\", {new = true})
ColorSequence = createTypeDa(\\"ColorSequence\\", {new = true})
ColorSequence.new = function(...)
    local args = {...}
    local keypoints = {}
    if #args == 1 and typeFunction(args[1]) == \\"table\\" and args[1][1] ~= nil then
        keypoints = args[1]
    elseif #args == 1 then
        keypoints = {args[1], args[1]}
    elseif #args >= 2 then
        keypoints = args
    end
    local t = setmetatable({Keypoints = keypoints}, {
        __typeof = \\"ColorSequence\\",
        __tostring = function() return \\"ColorSequence\\" end,
    })
    return t
end
ColorSequenceKeypoint = createTypeDa(\\"ColorSequenceKeypoint\\", {new = true})
PhysicalProperties = createTypeDa(\\"PhysicalProperties\\", {new = true})
Font = createTypeDa(\\"Font\\", {new = true, fromEnum = true, fromName = true, fromId = true})
RaycastParams = createTypeDa(\\"RaycastParams\\", {new = true})
OverlapParams = {new = function()
        local params = {MaxParts = 0, FilterType = Enum.RaycastFilterType.Exclude, FilterDescendantsInstances = {}}
        return setmetatable(params, {__typeof = \\"OverlapParams\\"})
    end}
_makeVector3 = function(x, y, z, expr)
    x, y, z = toNumberFunction(x) or 0, toNumberFunction(y) or 0, toNumberFunction(z) or 0
    local proxy, meta = createProxy()
    local expression = expr or (\\"Vector3.new(\\" .. serializeValue(x) .. \\", \\" .. serializeValue(y) .. \\", \\" .. serializeValue(z) .. \\")\\")
    dumperState.registry[proxy] = expression
    _at.vectors[proxy] = {x = x, y = y, z = z}
    local function component(v, axis)
        local data = _at.vectors[v]
        if not data then return 0 end
        return axis == \\"X\\" and data.x or axis == \\"Y\\" and data.y or data.z
    end
    local function binary(a, b, symbol)
        local ax, ay, az = component(a, \\"X\\"), component(a, \\"Y\\"), component(a, \\"Z\\")
        local bx, by, bz
        if typeFunction(b) == \\"number\\" then bx, by, bz = b, b, b else bx, by, bz = component(b, \\"X\\"), component(b, \\"Y\\"), component(b, \\"Z\\") end
        if symbol == \\"+\\" then return _makeVector3(ax + bx, ay + by, az + bz, \\"(\\" .. serializeValue(a) .. \\" + \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"-\\" then return _makeVector3(ax - bx, ay - by, az - bz, \\"(\\" .. serializeValue(a) .. \\" - \\" .. serializeValue(b) .. \\")\\") end
        if symbol == \\"*\\" then return _makeVector3(ax * bx, ay * by, az * bz, \\"(\\" .. serializeValue(a) .. \\" * \\" .. serializeValue(b) .. \\")\\") end
        return _makeVector3(bx ~= 0 and ax / bx or 0, by ~= 0 and ay / by or 0, bz ~= 0 and az / bz or 0, \\"(\\" .. serializeValue(a) .. \\" / \\" .. serializeValue(b) .. \\")\\")
    end
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(proxy, key) end
        if key == \\"X\\" then return x end
        if key == \\"Y\\" then return y end
        if key == \\"Z\\" then return z end
        if key == \\"Magnitude\\" then return math.sqrt(x * x + y * y + z * z) end
        if key == \\"Unit\\" then
            local mag = math.sqrt(x * x + y * y + z * z)
            if mag == 0 then return _makeVector3(0, 0, 0, expression .. \\".Unit\\") end
            return _makeVector3(x / mag, y / mag, z / mag, expression .. \\".Unit\\")
        end
        if key == \\"Dot\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return x * ox + y * oy + z * oz
            end
        end
        if key == \\"Cross\\" then
            return function(self, other)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return _makeVector3(y*oz - z*oy, z*ox - x*oz, x*oy - y*ox)
            end
        end
        if key == \\"Lerp\\" then
            return function(self, other, alpha)
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                local a = toNumberFunction(alpha) or 0
                return _makeVector3(x + (ox-x)*a, y + (oy-y)*a, z + (oz-z)*a)
            end
        end
        if key == \\"FuzzyEq\\" then
            return function(self, other, epsilon)
                local eps = toNumberFunction(epsilon) or 1e-5
                local ox, oy, oz = component(other, \\"X\\"), component(other, \\"Y\\"), component(other, \\"Z\\")
                return math.abs(x-ox) <= eps and math.abs(y-oy) <= eps and math.abs(z-oz) <= eps
            end
        end
        return 0
    end
    meta.__add = function(a, b) return binary(a, b, \\"+\\") end
    meta.__sub = function(a, b) return binary(a, b, \\"-\\") end
    meta.__mul = function(a, b) return binary(a, b, \\"*\\") end
    meta.__div = function(a, b) return binary(a, b, \\"/\\") end
    meta.__unm = function(a) return _makeVector3(-component(a, \\"X\\"), -component(a, \\"Y\\"), -component(a, \\"Z\\"), \\"(-\\" .. serializeValue(a) .. \\")\\") end
    meta.__eq = function(a, b) return component(a, \\"X\\") == component(b, \\"X\\") and component(a, \\"Y\\") == component(b, \\"Y\\") and component(a, \\"Z\\") == component(b, \\"Z\\") end
    meta.__tostring = function() return toStringFunction(x) .. \\", \\" .. toStringFunction(y) .. \\", \\" .. toStringFunction(z) end
    return proxy
end
Vector3 = {
    new = function(x, y, z) return _makeVector3(x, y, z) end,
    zero = _makeVector3(0, 0, 0, \\"Vector3.zero\\"),
    one = _makeVector3(1, 1, 1, \\"Vector3.one\\"),
    fromNormalId = function(normalId)
        local name = toStringFunction(normalId)
        if name:find(\\"Right\\")  then return _makeVector3( 1,  0,  0) end
        if name:find(\\"Left\\")   then return _makeVector3(-1,  0,  0) end
        if name:find(\\"Top\\")    then return _makeVector3( 0,  1,  0) end
        if name:find(\\"Bottom\\") then return _makeVector3( 0, -1,  0) end
        if name:find(\\"Back\\")   then return _makeVector3( 0,  0,  1) end
        if name:find(\\"Front\\")  then return _makeVector3( 0,  0, -1) end
        return _makeVector3(0, 0, 0)
    end,
    fromAxis = function(axis)
        local name = toStringFunction(axis)
        if name:find(\\"X\\") then return _makeVector3(1, 0, 0) end
        if name:find(\\"Y\\") then return _makeVector3(0, 1, 0) end
        if name:find(\\"Z\\") then return _makeVector3(0, 0, 1) end
        return _makeVector3(0, 0, 0)
    end,
}
setmetatable(Vector3, {__call = function(_, x, y, z) return _.new(x, y, z) end})
local function _valueType(typeName, fields, methods)
    local obj = fields or {}
    return setmetatable(obj, {
        __typeof = typeName,
        __index = methods or {},
        __tostring = function() return typeName end,
        __eq = function(a, b)
            if typeFunction(a) ~= \\"table\\" or typeFunction(b) ~= \\"table\\" then return false end
            local ma, mb = getMetatableFunction(a), getMetatableFunction(b)
            if not ma or not mb or ma.__typeof ~= mb.__typeof then return false end
            for k, v in pairsFunction(a) do
                if b[k] ~= v then return false end
            end
            for k, v in pairsFunction(b) do
                if a[k] ~= v then return false end
            end
            return true
        end
    })
end
local function _num(v, default) return toNumberFunction(v) or default or 0 end
local function _makeVector2(x, y)
    x, y = _num(x), _num(y)
    local methods = {}
    function methods:Dot(other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) end
    local mt
    mt = {
        __typeof = \\"Vector2\\",
        __index = function(self, key)
            if key == \\"Magnitude\\" then return math.sqrt(self.X * self.X + self.Y * self.Y) end
            if key == \\"Unit\\" then
                local mag = math.sqrt(self.X * self.X + self.Y * self.Y)
                return mag == 0 and _makeVector2(0, 0) or _makeVector2(self.X / mag, self.Y / mag)
            end
            return methods[key]
        end,
        __add = function(a, b) return _makeVector2(a.X + b.X, a.Y + b.Y) end,
        __sub = function(a, b) return _makeVector2(a.X - b.X, a.Y - b.Y) end,
        __mul = function(a, b)
            if typeFunction(a) == \\"number\\" then return _makeVector2(a * b.X, a * b.Y) end
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X * b, a.Y * b) end
            return _makeVector2(a.X * b.X, a.Y * b.Y)
        end,
        __div = function(a, b)
            if typeFunction(b) == \\"number\\" then return _makeVector2(a.X / b, a.Y / b) end
            return _makeVector2(a.X / b.X, a.Y / b.Y)
        end,
        __unm = function(a) return _makeVector2(-a.X, -a.Y) end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y end,
        __tostring = function(a) return (\\"Vector2.new(%s, %s)\\"):format(a.X, a.Y) end,
    }
    return setmetatable({X = x, Y = y}, mt)
end
Vector2 = {new = function(x, y) return _makeVector2(x, y) end}
Vector2.zero = Vector2.new(0, 0)
Vector2.one = Vector2.new(1, 1)
setmetatable(Vector2, {__call = function(_, x, y) return _.new(x, y) end})
local _oldVector3New = Vector3.new
Vector3.new = function(x, y, z)
    local v = _oldVector3New(x, y, z)
    local mt = getMetatableFunction(v)
    local oldIndex = mt.__index
    mt.__index = function(self, key)
        if key == \\"Dot\\" then
            return function(_, other) return self.X * (other and other.X or 0) + self.Y * (other and other.Y or 0) + self.Z * (other and other.Z or 0) end
        end
        if key == \\"Cross\\" then
            return function(_, other)
                return Vector3.new(
                    self.Y * (other and other.Z or 0) - self.Z * (other and other.Y or 0),
                    self.Z * (other and other.X or 0) - self.X * (other and other.Z or 0),
                    self.X * (other and other.Y or 0) - self.Y * (other and other.X or 0)
                )
            end
        end
        return oldIndex(self, key)
    end
    return v
end
Vector3.zero = Vector3.new(0, 0, 0)
Vector3.one = Vector3.new(1, 1, 1)
UDim = {new = function(scale, offset) return _valueType(\\"UDim\\", {Scale = _num(scale), Offset = _num(offset)}) end}
setmetatable(UDim, {__call = function(_, scale, offset) return _.new(scale, offset) end})
UDim2 = {
    new = function(xs, xo, ys, yo) return _valueType(\\"UDim2\\", {X = UDim.new(xs, xo), Y = UDim.new(ys, yo)}) end,
    fromScale = function(x, y) return UDim2.new(x, 0, y, 0) end,
    fromOffset = function(x, y) return UDim2.new(0, x, 0, y) end,
}
setmetatable(UDim2, {__call = function(_, ...) return _.new(...) end})
Color3 = {
    new = function(r, g, b)
        local rv, gv, bv = _num(r), _num(g), _num(b)
        if rv < 0 or rv > 1 or gv < 0 or gv > 1 or bv < 0 or bv > 1 then
            errorFunction(\\"R, G, and B must each be in the range [0, 1]\\", 2)
        end
        return setmetatable({R = rv, G = gv, B = bv}, {
            __typeof = \\"Color3\\",
            __tostring = function(self) return string.format(\\"[R:%g, G:%g, B:%g]\\", self.R, self.G, self.B) end,
            __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.R == b.R and a.G == b.G and a.B == b.B end,
        })
    end,
    fromRGB = function(r, g, b) return Color3.new(_num(r) / 255, _num(g) / 255, _num(b) / 255) end,
    fromHSV = function(h, s, v) return Color3.new(v or 1, v or 1, v or 1) end,
    fromHex = function(hex) return Color3.fromRGB(255, 255, 255) end,
}
setmetatable(Color3, {__call = function(_, ...) return _.new(...) end})
BrickColor = {
    new = function(name)
        name = formatValue(name or \\"Medium stone grey\\")
        return _valueType(\\"BrickColor\\", {Name = name, Number = 1, Color = Color3.fromRGB(255, 0, 0)})
    end,
    random = function() return BrickColor.new(\\"Medium stone grey\\") end,
}
setmetatable(BrickColor, {__call = function(_, ...) return _.new(...) end})
NumberRange = {new = function(min, max) return _valueType(\\"NumberRange\\", {Min = _num(min), Max = max ~= nil and _num(max) or _num(min)}) end}
NumberSequence = {new = function(value) return _valueType(\\"NumberSequence\\", {Keypoints = typeFunction(value) == \\"table\\" and value or {{Time = 0, Value = _num(value)}, {Time = 1, Value = _num(value)}}}) end}
TweenInfo = {new = function(timeValue, style, direction, repeatCount, reverses, delayTime) return _valueType(\\"TweenInfo\\", {Time = _num(timeValue), EasingStyle = style or Enum.EasingStyle.Quad, EasingDirection = direction or Enum.EasingDirection.Out, RepeatCount = repeatCount or 0, Reverses = reverses or false, DelayTime = delayTime or 0}) end}
Ray = {new = function(origin, direction) return _valueType(\\"Ray\\", {Origin = origin or Vector3.zero, Direction = direction or Vector3.new(0, 0, -1)}) end}
Rect = {new = function(a, b, c, d)
    local minV = typeFunction(a) == \\"table\\" and a or Vector2.new(a, b)
    local maxV = typeFunction(c) == \\"table\\" and c or Vector2.new(c, d)
    return _valueType(\\"Rect\\", {Min = minV, Max = maxV, Width = maxV.X - minV.X, Height = maxV.Y - minV.Y})
end}
Region3 = {new = function(minVec, maxVec)
    local mn = minVec or Vector3.new(0,0,0)
    local mx = maxVec or Vector3.new(0,0,0)
    local sz = Vector3.new(mx.X - mn.X, mx.Y - mn.Y, mx.Z - mn.Z)
    return _valueType(\\"Region3\\", {CFrame = CFrame.new((mn.X+mx.X)/2,(mn.Y+mx.Y)/2,(mn.Z+mx.Z)/2), Size = sz})
end}
PhysicalProperties = {new = function(density, friction, elasticity, frictionWeight, elasticityWeight) return _valueType(\\"PhysicalProperties\\", {Density = _num(density, 1), Friction = _num(friction, 0.3), Elasticity = _num(elasticity, 0.5), FrictionWeight = _num(frictionWeight, 1), ElasticityWeight = _num(elasticityWeight, 1)}) end}
_makeCFrame = function(x, y, z)
    local ox, oy, oz = _num(x), _num(y), _num(z)
    local obj = {X = ox, Y = oy, Z = oz}
    obj.Position = Vector3.new(ox, oy, oz)
    obj.p = obj.Position
    obj.LookVector = Vector3.new(0, 0, -1)
    obj.RightVector = Vector3.new(1, 0, 0)
    obj.UpVector = Vector3.new(0, 1, 0)
    obj.Inverse = function(self) return _makeCFrame(-ox, -oy, -oz) end
    obj.ToObjectSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox2 - ox, oy2 - oy, oz2 - oz)
    end
    obj.ToWorldSpace = function(self, other)
        local ox2 = (other and (other.X or 0)) or 0
        local oy2 = (other and (other.Y or 0)) or 0
        local oz2 = (other and (other.Z or 0)) or 0
        return _makeCFrame(ox + ox2, oy + oy2, oz + oz2)
    end
    obj.PointToObjectSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) - ox,
            (point and point.Y or 0) - oy,
            (point and point.Z or 0) - oz
        )
    end
    obj.PointToWorldSpace = function(self, point)
        return Vector3.new(
            (point and point.X or 0) + ox,
            (point and point.Y or 0) + oy,
            (point and point.Z or 0) + oz
        )
    end
    return setmetatable(obj, {
        __typeof = \\"CFrame\\",
        __index = function(self, key) return rawget(self, key) end,
        __mul = function(a, b)
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"CFrame\\" then
                return _makeCFrame(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            if getMetatableFunction(b) and getMetatableFunction(b).__typeof == \\"Vector3\\" then
                return Vector3.new(a.X + b.X, a.Y + b.Y, a.Z + b.Z)
            end
            return a
        end,
        __eq = function(a, b) return typeFunction(b) == \\"table\\" and a.X == b.X and a.Y == b.Y and a.Z == b.Z end,
        __tostring = function(a) return (\\"CFrame.new(%s, %s, %s)\\"):format(a.X, a.Y, a.Z) end,
    })
end
CFrame = {
    new = function(x, y, z) return _makeCFrame(x, y, z) end,
    Angles = function() return _makeCFrame(0, 0, 0) end,
    lookAt = function(origin, target) return _makeCFrame(origin and origin.X or 0, origin and origin.Y or 0, origin and origin.Z or 0) end,
    LookAt = function(origin, target) return CFrame.lookAt(origin, target) end,
    fromEulerAnglesXYZ = function() return _makeCFrame(0, 0, 0) end,
    fromEulerAnglesYXZ = function() return _makeCFrame(0, 0, 0) end,
    fromAxisAngle = function() return _makeCFrame(0, 0, 0) end,
    fromMatrix = function(pos) return _makeCFrame(pos and pos.X or 0, pos and pos.Y or 0, pos and pos.Z or 0) end,
    fromOrientation = function() return _makeCFrame(0, 0, 0) end,
}
CFrame.identity = CFrame.new(0, 0, 0)
setmetatable(CFrame, {__call = function(_, ...) return _.new(...) end})
PathWaypoint = createTypeDa(\\"PathWaypoint\\", {new = true})
Axes = createTypeDa(\\"Axes\\", {new = true})
Faces = createTypeDa(\\"Faces\\", {new = true})
Vector3int16 = createTypeDa(\\"Vector3int16\\", {new = true})
Vector2int16 = createTypeDa(\\"Vector2int16\\", {new = true})
CatalogSearchParams = createTypeDa(\\"CatalogSearchParams\\", {new = true})
DateTime = {
    now = function()
        return DateTime.fromUnixTimestamp(os.time())
    end,
    fromUnixTimestamp = function(ts)
        ts = toNumberFunction(ts) or 0
        local dt = setmetatable({UnixTimestamp = ts, UnixTimestampMillis = ts * 1000}, {
            __typeof = \\"DateTime\\",
            __index = function(self, key)
                if key == \\"UnixTimestamp\\" then return ts end
                if key == \\"UnixTimestampMillis\\" then return ts * 1000 end
                if key == \\"FormatUniversalTime\\" then
                    return function(self2, fmt, locale)
                        -- convert unix timestamp to date components
                        local t = os.date(\\"!*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"FormatLocalTime\\" then
                    return function(self2, fmt, locale)
                        local t = os.date(\\"*t\\", ts)
                        local result = fmt
                        result = string.gsub(result, \\"YYYY\\", string.format(\\"%04d\\", t.year))
                        result = string.gsub(result, \\"YY\\", string.format(\\"%02d\\", t.year % 100))
                        result = string.gsub(result, \\"MM\\", string.format(\\"%02d\\", t.month))
                        result = string.gsub(result, \\"DD\\", string.format(\\"%02d\\", t.day))
                        result = string.gsub(result, \\"HH\\", string.format(\\"%02d\\", t.hour))
                        result = string.gsub(result, \\"mm\\", string.format(\\"%02d\\", t.min))
                        result = string.gsub(result, \\"SS\\", string.format(\\"%02d\\", t.sec))
                        return result
                    end
                end
                if key == \\"ToIsoDate\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return string.format(\\"%04d-%02d-%02dT%02d:%02d:%02dZ\\", t.year, t.month, t.day, t.hour, t.min, t.sec)
                    end
                end
                if key == \\"ToUniversalTime\\" then
                    return function(self2)
                        local t = os.date(\\"!*t\\", ts)
                        return {Year=t.year,Month=t.month,Day=t.day,Hour=t.hour,Minute=t.min,Second=t.sec,Millisecond=0}
                    end
                end
            end,
        })
        return dt
    end,
    fromUnixTimestampMillis = function(ms)
        return DateTime.fromUnixTimestamp(math.floor((toNumberFunction(ms) or 0) / 1000))
    end,
    fromIsoDate = function(iso)
        return DateTime.fromUnixTimestamp(0)
    end,
}
Random = {new = function(seed)
        local obj = {}
        function obj:NextNumber(min, max) return (min or 0) + 0.5 * ((max or 1) - (min or 0)) end
        function obj:NextInteger(min, max) return math.floor((min or 1) + 0.5 * ((max or 100) - (min or 1))) end
        function obj:NextUnitVector() return Vector3.new(0.577, 0.577, 0.577) end
        function obj:Shuffle(tab) return tab end
        function obj:Clone() return Random.new() end
        return obj
    end}
setmetatable(Random, {__call = function(_, seed) return _.new(seed) end})
Enum = createProxyObject(\\"Enum\\", true)
local enumMeta = debugLibrary.getmetatable(Enum)
enumMeta.__index = function(_, key)
    if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
    local enumName = \\"Enum.\\" .. formatValue(key)
    if not _at.enum[enumName] then
        local enumProxy = createProxyObject(enumName, false)
        dumperState.registry[enumProxy] = enumName
        _at.enum[enumName] = enumProxy
    end
    return _at.enum[enumName]
end
Instance = {new = function(className, parent)
        local name = formatValue(className)
        local _validClasses = {
            Part=1,MeshPart=1,UnionOperation=1,SpecialMesh=1,BlockMesh=1,CylinderMesh=1,
            Model=1,Folder=1,Tool=1,LocalScript=1,Script=1,ModuleScript=1,
            RemoteEvent=1,RemoteFunction=1,BindableEvent=1,BindableFunction=1,
            Frame=1,ScreenGui=1,SurfaceGui=1,BillboardGui=1,TextLabel=1,TextButton=1,
            TextBox=1,ImageLabel=1,ImageButton=1,ScrollingFrame=1,ViewportFrame=1,
            UIListLayout=1,UIGridLayout=1,UITableLayout=1,UIPadding=1,UICorner=1,
            UIStroke=1,UIScale=1,UIAspectRatioConstraint=1,UISizeConstraint=1,
            UITextSizeConstraint=1,UIFlexItem=1,UIGradient=1,UIPageLayout=1,
            Humanoid=1,HumanoidDescription=1,Animator=1,Animation=1,
            Sound=1,SoundGroup=1,Attachment=1,Motor6D=1,Weld=1,WeldConstraint=1,
            BallSocketConstraint=1,HingeConstraint=1,SpringConstraint=1,RodConstraint=1,
            RopeConstraint=1,AlignPosition=1,AlignOrientation=1,
            ForceField=1,Decal=1,Texture=1,SelectionBox=1,SelectionSphere=1,
            PointLight=1,SpotLight=1,SurfaceLight=1,Sky=1,Atmosphere=1,Clouds=1,
            Beam=1,Trail=1,ParticleEmitter=1,Fire=1,Smoke=1,Sparkles=1,
            Camera=1,Backpack=1,Hat=1,Accessory=1,Shirt=1,Pants=1,ShirtGraphic=1,
            CharacterMesh=1,BodyColors=1,
            IntValue=1,StringValue=1,BoolValue=1,NumberValue=1,Vector3Value=1,
            CFrameValue=1,Color3Value=1,ObjectValue=1,RayValue=1,BrickColorValue=1,
            ClickDetector=1,ProximityPrompt=1,Dialog=1,DialogChoice=1,
            SpawnLocation=1,SeatPart=1,VehicleSeat=1,
            WedgePart=1,CornerWedgePart=1,TrussPart=1,
            IntersectOperation=1,NegateOperation=1,
            PathfindingLink=1,PathfindingModifier=1,
            Configuration=1,LocalizationTable=1,
            NoCollisionConstraint=1,RigidConstraint=1,
            EditableMesh=1,EditableImage=1,
            LinearVelocity=1,AngularVelocity=1,LineForce=1,VectorForce=1,Torque=1,
            SurfaceAppearance=1,SpecialMesh=1,SelectionBox=1,
        }
        if not _validClasses[name] then
            errorFunction(\\"Unable to create an Instance of type \\\"\\" .. name .. \\"\\\"\\", 2)
        end
        local proxy = createProxyObject(name, false)
        local varName = registerVariable(proxy, name)
        -- class-specific default properties
        local _classDefaults = {
            SkateboardController = {Steer=0, Throttle=0},
            BallSocketConstraint = {LimitsEnabled=false, UpperAngle=45, TwistLimitsEnabled=false, TwistLowerAngle=-45, TwistUpperAngle=45, MaxFrictionTorque=0, Restitution=0},
            HingeConstraint     = {LimitsEnabled=false, UpperAngle=45, LowerAngle=-45, AngularVelocity=0, MotorMaxTorque=0, Restitution=0},
            SpringConstraint    = {Coilcount=5, Damping=1, FreeLength=5, LimitsEnabled=false, MaxLength=5, MinLength=0, Stiffness=100, Visible=false},
            RodConstraint       = {Length=5, LimitAngle0=0, LimitAngle1=0},
            RopeConstraint      = {Length=5},
            PrismaticConstraint = {LimitsEnabled=false, UpperLimit=5, LowerLimit=0, Velocity=0},
            TorsionSpringConstraint = {Damping=1, Stiffness=100, Restitution=0},
            WeldConstraint      = {},
            Motor6D             = {CurrentAngle=0, DesiredAngle=0, MaxVelocity=0},
            ForceField          = {Visible=true},
            Sound               = {Volume=0.5, PlaybackSpeed=1, TimePosition=0, IsPlaying=false, IsPaused=false, Looped=false, RollOffMaxDistance=10000, RollOffMinDistance=10},
            ScreenGui           = {Enabled=true, DisplayOrder=0, IgnoreGuiInset=false, ResetOnSpawn=true},
            Frame               = {BackgroundTransparency=0, BorderSizePixel=1, Visible=true, ZIndex=1, LayoutOrder=0},
            TextLabel           = {Text=\\"\\", TextTransparency=0, TextSize=14, TextWrapped=false, RichText=false, BackgroundTransparency=0, Visible=true, ZIndex=1},
            TextButton          = {Text=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, Modal=false},
            TextBox             = {Text=\\"\\", PlaceholderText=\\"\\", TextTransparency=0, TextSize=14, BackgroundTransparency=0, Visible=true, ZIndex=1, ClearTextOnFocus=true},
            ImageLabel          = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            ImageButton         = {ImageTransparency=0, BackgroundTransparency=0, Visible=true, ZIndex=1},
            Part                = {Anchored=false, CanCollide=true, Locked=false, Transparency=0, Reflectance=0, Mass=1},
            MeshPart            = {Anchored=false, CanCollide=true, Transparency=0},
            Humanoid            = {Health=100, MaxHealth=100, WalkSpeed=16, JumpPower=50, JumpHeight=7.2, HipHeight=2, AutoRotate=true, PlatformStand=false},
            RemoteEvent         = {},
            RemoteFunction      = {},
            BindableEvent       = {},
            BindableFunction    = {},
            Animator            = {},
            LocalizationTable   = {SourceLocaleId=\\"en-us\\"},
            Animation           = {AnimationId=\\"\\"},
            Attachment          = {},
            AlignPosition       = {RigidityEnabled=false, MaxForce=1e6, MaxVelocity=1e6, Responsiveness=200},
            AlignOrientation    = {RigidityEnabled=false, MaxTorque=1e6, MaxAngularVelocity=1e6, Responsiveness=200},
            LinearVelocity      = {MaxForce=0, VectorVelocity=nil, VelocityConstraintMode=nil, Attachment0=nil},
            SurfaceAppearance   = {ColorMap=nil, NormalMap=nil, RoughnessMap=nil, MetalnessMap=nil},
        }
        local defaults = _classDefaults[name] or {}
        defaults.ClassName = name
        defaults.Name = name
        defaults.Archivable = true
        dumperState.property_store[proxy] = defaults
        if parent then
            local parentPath = dumperState.registry[parent] or serializeValue(parent)
            emitOutput(string.format(\\"local %s = Instance.new(%s, %s)\\", varName, formatStringLiteral(name), parentPath))
            _setParent(proxy, parent)
        else
            emitOutput(string.format(\\"local %s = Instance.new(%s)\\", varName, formatStringLiteral(name)))
        end
        return proxy
    end}
game = createProxyObject(\\"game\\", true)
workspace = createProxyObject(\\"workspace\\", true)
script = createProxyObject(\\"script\\", true)
dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
local function seedCoreRobloxInstances()
    dumperState.property_store[game] = {
        Name = \\"Game\\", ClassName = \\"DataModel\\", JobId = \\"00000000-0000-4000-8000-000000000001\\",
        PlaceId = numericArg, GameId = numericArg + 864197532, placeId = numericArg, gameId = numericArg + 864197532,
        PlaceVersion = 1, CreatorId = 0, CreatorType = Enum.CreatorType.User
    }
    dumperState.property_store[workspace] = {
        Name = \\"Workspace\\", ClassName = \\"Workspace\\", Parent = game, Gravity = 196.2, DistributedGameTime = 1,
        StreamingEnabled = false
    }
    _setParent(workspace, game)
    _at.svcCache.Workspace = workspace

    local players = _at.svcCache.Players or createProxyObject(\\"Players\\", false, game)
    _at.svcCache.Players = players
    dumperState.registry[players] = \\"Players\\"
    dumperState.property_store[players] = {Name = \\"Players\\", ClassName = \\"Players\\", Parent = game, MaxPlayers = 12, RespawnTime = 5}
    _setParent(players, game)

    local lp = _at.localPlayer or createProxyObject(\\"LocalPlayer\\", false, players)
    _at.localPlayer = lp
    dumperState.registry[lp] = \\"LocalPlayer\\"
    dumperState.property_store[lp] = {
        Name = \\"Player\\", ClassName = \\"Player\\", Parent = players, UserId = 1, DisplayName = \\"Player\\",
        MembershipType = Enum.MembershipType.None, FollowUserId = 0, AccountAge = 1000,
        CameraMinZoomDistance = 0, CameraMaxZoomDistance = 400,
        AutoJumpEnabled = true, Neutral = true, Team = nil, LocaleId = \\"en-us\\",
        SimulationRadius = 0, MaxSimulationRadius = 0,
    }
    _setParent(lp, players)

    local function ensureChild(parent, name, className, props)
        local child = createProxyObject(name, false, parent)
        dumperState.registry[child] = name
        props = props or {}
        props.Name = props.Name or name
        props.ClassName = props.ClassName or className or name
        props.Parent = parent
        dumperState.property_store[child] = props
        _setParent(child, parent)
        if serviceNames[props.ClassName] then
            _at.svcCache[props.ClassName] = child
        end
        return child
    end

    ensureChild(lp, \\"PlayerGui\\", \\"PlayerGui\\")
    ensureChild(lp, \\"Backpack\\", \\"Backpack\\")
    local playerScripts = ensureChild(lp, \\"PlayerScripts\\", \\"PlayerScripts\\")
    ensureChild(playerScripts, \\"PlayerModule\\", \\"ModuleScript\\")
    ensureChild(playerScripts, \\"RbxCharacterSounds\\", \\"LocalScript\\")
    ensureChild(workspace, \\"Camera\\", \\"Camera\\", {
        CFrame = CFrame.new(0, 10, 0), FieldOfView = 70, ViewportSize = Vector2.new(1920, 1080),
        CameraType = Enum.CameraType.Custom, NearPlaneZ = -0.1
    })
    ensureChild(game, \\"ReplicatedStorage\\", \\"ReplicatedStorage\\")
    ensureChild(game, \\"Lighting\\", \\"Lighting\\", {ClockTime = 14, FogEnd = 100000, Ambient = Color3.fromRGB(128, 128, 128), OutdoorAmbient = Color3.fromRGB(128, 128, 128)})
    ensureChild(game, \\"SoundService\\", \\"SoundService\\", {RolloffScale = 1, AmbientReverb = Enum.ReverbType.NoReverb})
    ensureChild(game, \\"RunService\\", \\"RunService\\")
    ensureChild(game, \\"TweenService\\", \\"TweenService\\")
    ensureChild(game, \\"HttpService\\", \\"HttpService\\", {HttpEnabled = false})
    local networkClient = ensureChild(game, \\"NetworkClient\\", \\"NetworkClient\\")
    ensureChild(networkClient, \\"ClientReplicator\\", \\"ClientReplicator\\")
    local ugc = ensureChild(game, \\"Ugc\\", \\"Folder\\")
    ensureChild(ugc, \\"Chat\\", \\"Chat\\")
    ensureChild(game, \\"CollectionService\\", \\"CollectionService\\")
    ensureChild(game, \\"TextService\\", \\"TextService\\")
    ensureChild(game, \\"GuiService\\", \\"GuiService\\")
    ensureChild(game, \\"ContentProvider\\", \\"ContentProvider\\")
end
seedCoreRobloxInstances()
task = {
    wait = function(sec)
        if sec then emitOutput(string.format(\\"task.wait(%s)\\", serializeValue(sec))) else emitOutput(\\"task.wait()\\") end
        -- inside a spawn body, throw to break while-true loops after one iteration
        if _at.spawnDepth and _at.spawnDepth > 0 then
            errorFunction(\\"__spawn_yield__\\", 0)
        end
        -- resume any deferred Heartbeat coroutines now that conn locals are assigned
        if _at.pendingHeartbeat and #_at.pendingHeartbeat > 0 then
            local pending = _at.pendingHeartbeat
            _at.pendingHeartbeat = {}
            for _, co in ipairs(pending) do
                pcall(coroutine.resume, co)
            end
        end
        for inst, props in pairsFunction(dumperState.property_store) do
            if props.ClassName == \\"Part\\" and props.Anchored == false and _at.vectors[props.Position] then
                local v = _at.vectors[props.Position]
                props.Position = Vector3.new(v.x, v.y - 1, v.z)
            end
        end
        return sec or 0.03, osLibrary.clock()
    end,
    spawn = function(func, ...)
        local args = {...}
        emitOutput(\\"task.spawn(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        elseif typeFunction(func) == \\"thread\\" then
            xpcallFunction( function() coroutine.resume(func, table.unpack(args)) end, function(err) emitOutput(\\"-- [Error in spawn] \\" .. toStringFunction(err)) end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
        local co = coroutine.create(function() end)
        _at.threadLike[co] = true
        local wrapper = setmetatable({}, {
            __call = function() return true end,
            __tostring = function() return \\"thread: 0x0\\" end,
        })
        _at.threadLike[wrapper] = true
        return wrapper
    end,
    delay = function(sec, func, ...)
        local args = {...}
        emitOutput(string.format(\\"task.delay(%s, function()\\", serializeValue(sec or 0)))
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        while dumperState.pending_iterator do
            dumperState.indent = dumperState.indent - 1
            emitOutput(\\"end\\")
            dumperState.pending_iterator = false
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    defer = function(func, ...)
        local args = {...}
        emitOutput(\\"task.defer(function()\\")
        dumperState.indent = dumperState.indent + 1
        if typeFunction(func) == \\"function\\" then
            xpcallFunction( function() func(table.unpack(args)) end, function() end )
        end
        dumperState.indent = dumperState.indent - 1
        emitOutput(\\"end)\\")
    end,
    cancel = function(thread) emitOutput(\\"task.cancel(thread)\\") end,
    synchronize = function() emitOutput(\\"task.synchronize()\\") end,
    desynchronize = function() emitOutput(\\"task.desynchronize()\\") end
}
wait = function(sec)
    if sec then emitOutput(string.format(\\"wait(%s)\\", serializeValue(sec))) else emitOutput(\\"wait()\\") end
    task.wait(sec)
    return sec or 0.03, osLibrary.clock()
end
delay = function(sec, func)
    emitOutput(string.format(\\"delay(%s, function()\\", serializeValue(sec or 0)))
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then xpcallFunction(func, function() end) end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
spawn = function(func)
    emitOutput(\\"spawn(function()\\")
    dumperState.indent = dumperState.indent + 1
    if typeFunction(func) == \\"function\\" then
        -- limit spawn bodies: run once then break out of any while true
        local _spawnDepth = (_at.spawnDepth or 0) + 1
        if _spawnDepth <= 2 then
            _at.spawnDepth = _spawnDepth
            xpcallFunction(func, function() end)
            _at.spawnDepth = _spawnDepth - 1
        end
    end
    dumperState.indent = dumperState.indent - 1
    emitOutput(\\"end)\\")
end
tick = function() return osLibrary.time() end
time = function() return osLibrary.clock() end
elapsedTime = function() return osLibrary.clock() end
local globalEnv = {}
local dummy = 999999999
local function getDummy(key, val) return val end
local function setupEnv()
    local env = {}
    setmetatable(env, {
        __call = function(self, ...) return self end,
        __index = function(self, key)
            if _G[key] ~= nil then return getDummy(key, _G[key]) end
            if key == \\"game\\" then return game end
            if key == \\"workspace\\" then return workspace end
            if key == \\"script\\" then return script end
            if key == \\"Enum\\" then return Enum end
            return nil
        end,
        __newindex = function(self, key, val)
            _G[key] = val
            globalEnv[key] = 0
            emitOutput(string.format(\\"_G.%s = %s\\", formatValue(key), serializeValue(val)))
        end
    })
    return env
end
_G.G = setupEnv()
_G.g = setupEnv()
_G.ENV = setupEnv()
_G.env = setupEnv()
_G.E = setupEnv()
_G.e = setupEnv()
_G.L = setupEnv()
_G.l = setupEnv()
_G.F = setupEnv()
_G.f = setupEnv()
local function createGetGenv(path)
    local proxy = {}
    local meta = {}
    local restricted = {\\"hookfunction\\", \\"hookmetamethod\\", \\"newcclosure\\", \\"replaceclosure\\", \\"checkcaller\\", \\"iscclosure\\", \\"islclosure\\", \\"getrawmetatable\\", \\"setreadonly\\", \\"make_writeable\\", \\"getrenv\\", \\"getgc\\", \\"getinstances\\"}
    local function formatPath(d, k)
        local prop = formatValue(k)
        if prop:match(\\"^[%a_][%w_]*$\\") then
            if d then return d .. \\".\\" .. prop end
            return prop
        else
            local escaped = prop:gsub(\\"'\\", \\"\\\\\\\\'\\")
            if d then return d .. \\"['\\" .. escaped .. \\"']\\" end
            return \\"['\\" .. escaped .. \\"']\\"
        end
    end
    meta.__index = function(_, key)
        if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
        return _G[key]
    end
    meta.__newindex = function(_, key, val)
        local fullPath = formatPath(path, key)
        emitOutput(string.format(\\"getgenv().%s = %s\\", fullPath, serializeValue(val)))
    end
    meta.__call = function() return proxy end
    meta.__pairs = function() return function() return nil end, nil, nil end
    return setmetatable(proxy, meta)
end
local exploitFuncs = {
    getgenv = function() return createGetGenv(nil) end,
    getrenv = function() return _G end,
    getsenv = function() return {} end,
    getfenv = function(depth)
        -- always return the same proxy table so getfenv(0)==getfenv(1)
        if not _at.fenvCache then
            _at.fenvCache = setmetatable({}, {
                __index = function(_, key)
                    if key == \\"c\\" or key == \\"fenv\\" or key == \\"ReplicatedStorage\\" then return nil end
                    return _G[key]
                end,
                __newindex = function(_, k, v) rawset(_, k, v) end
            })
        end
        return _at.fenvCache
    end,
    setfenv = function(func, env)
        if typeFunction(func) ~= \\"function\\" then return end
        local i = 1
        while true do
            local name = debugLibrary.getupvalue(func, i)
            if name == \\"_ENV\\" then debugLibrary.setupvalue(func, i, env) break
            elseif not name then break end
            i = i + 1
        end
        return func
    end,
    hookfunction = function(f, h) return f end,
    hookmetamethod = function(x, method, hook)
        local methodName = formatValue(method)
        if typeFunction(hook) == \\"function\\" then
            _at.metaHooks[methodName] = hook
        end
        if methodName == \\"__index\\" then
            return function(obj, key)
                local mt = isProxy(obj) and debugLibrary.getmetatable(obj)
                if mt and typeFunction(mt.__index) == \\"function\\" then
                    local saved = _at.metaHooks[methodName]
                    _at.metaHooks[methodName] = nil
                    local ok, result = pcallFunction(mt.__index, obj, key)
                    _at.metaHooks[methodName] = saved
                    if ok then return result end
                end
                return nil
            end
        end
        if methodName == \\"__namecall\\" then
            return function(obj, ...)
                local methodToCall = _at.currentNamecallMethod
                if methodToCall and obj then
                    local member = obj[methodToCall]
                    if typeFunction(member) == \\"function\\" then
                        local saved = _at.metaHooks[methodName]
                        _at.metaHooks[methodName] = nil
                        local ok, result = pcallFunction(member, obj, ...)
                        _at.metaHooks[methodName] = saved
                        if ok then return result end
                    end
                end
                return nil
            end
        end
        return function() end
    end,
    getrawmetatable = function(x)
        if isProxy(x) then
            -- all Instance proxies share ONE metatable so rawequal(mt1,mt2)==true
            if not _at.sharedInstanceMeta then
                local mt = {}
                -- __index must be a C function so debug.getinfo says what==\\"C\\"
                -- use a newproxy userdata with a C-backed metatable trick:
                -- we tag a wrapper as cclosure so getinfo returns \\"C\\"
                local indexFn = function() end
                if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
                _at.cclosureSet[indexFn] = true
                mt.__index = indexFn
                mt.__newindex = function() end
                mt.__namecall = function() end
                mt.__len = function() return 0 end
                mt.__tostring = function() return \\"Instance\\" end
                _at.sharedInstanceMeta = mt
            end
            return _at.sharedInstanceMeta
        end
        return getmetatable(x) or {}
    end,
    setrawmetatable = function(x, mt) return x end,
    getnamecallmethod = function() return _at.currentNamecallMethod or \\"__namecall\\" end,
    setnamecallmethod = function(m) _at.currentNamecallMethod = formatValue(m) end,
    checkcaller = function() return true end,
    islclosure = function(f)
        if isProxy(f) then return false end
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return false end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return false end
        return false
    end,
    iscclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return false end
        if _at.cclosureSet and _at.cclosureSet[f] then return true end
        local info = debugLibrary.getinfo(f, \\"S\\")
        if info and info.what == \\"C\\" then return true end
        return false
    end,
    newcclosure = function(f)
        if typeFunction(f) ~= \\"function\\" then return f end
        if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
        local wrapper = function(...) return f(...) end
        _at.cclosureSet[wrapper] = true
        return wrapper
    end,
    clonefunction = function(f) return f end,
    request = function(req)
        emitOutput(string.format(\\"request(%s)\\", serializeValue(req)))
        table.insert(dumperState.string_refs, {value = req.Url or req.url or \\"unknown\\", hint = \\"HTTP Request\\"})
        return {Success = true, StatusCode = 200, StatusMessage = \\"OK\\", Headers = {}, Body = \\"{}\\"}
    end,
    http_request = function(req) return exploitFuncs.request(req) end,
    syn = {request = function(req) return exploitFuncs.request(req) end},
    http = {request = function(req) return exploitFuncs.request(req) end},
    HttpPost = function(url, data)
        emitOutput(string.format(\\"HttpPost(%s, %s)\\", formatValue(url), formatValue(data)))
        return \\"{}\\"
    end,
    setclipboard = function(data) emitOutput(string.format(\\"setclipboard(%s)\\", serializeValue(data))) end,
    getclipboard = function() return '\\"' end,
    identifyexecutor = function() return \\"FlameDumperV1\\", \\"1.0\\" end,
    getexecutorname = function() return \\"FlameDumperV1\\" end,
    gethui = function()
        local hui = createProxyObject(\\"HiddenUI\\", false)
        registerVariable(hui, \\"HiddenUI\\")
        emitOutput(string.format(\\"local %s = gethui()\\", dumperState.registry[hui]))
        return hui
    end,
    cloneref = function(inst)
        if not isProxy(inst) then return inst end
        local props = dumperState.property_store[inst] or {}
        local className = props.ClassName or dumperState.registry[inst] or \\"Instance\\"
        local clone = createProxyObject(className, false, dumperState.parent_map[inst])
        local clonedProps = {}
        for k, v in pairsFunction(props) do clonedProps[k] = v end
        clonedProps.ClassName = clonedProps.ClassName or className
        clonedProps.Name = clonedProps.Name or props.Name or className
        dumperState.property_store[clone] = clonedProps
        dumperState.registry[clone] = (dumperState.registry[inst] or className) .. \\"_cloneref\\"
        _at.refBase[clone] = _at.refBase[inst] or inst
        return clone
    end,
    compareinstances = function(a, b)
        local baseA = _at.refBase[a] or a
        local baseB = _at.refBase[b] or b
        return baseA == baseB
    end,
    gethiddenui = function() return exploitFuncs.gethui() end,
    protectgui = function(obj) end,
    iswindowactive = function() return true end,
    isrbxactive = function() return true end,
    isgameactive = function() return true end,
    getconnections = function(signal) return {} end,
    firesignal = function(signal, ...) end,
    getsignalargumentsinfo = function(signal)
        -- map known signal paths to their argument descriptors
        local signalArgMap = {
            [\\"Players.PlayerAdded\\"]          = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerRemoving\\"]       = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Players.PlayerMembershipChanged\\"] = {{Name=\\"player\\", Type=\\"Player\\"}},
            [\\"Humanoid.Died\\"]                = {},
            [\\"Humanoid.HealthChanged\\"]       = {{Name=\\"health\\", Type=\\"number\\"}},
            [\\"Humanoid.StateChanged\\"]        = {{Name=\\"old\\", Type=\\"EnumItem\\"}, {Name=\\"new\\", Type=\\"EnumItem\\"}},
            [\\"BasePart.Touched\\"]             = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"BasePart.TouchEnded\\"]          = {{Name=\\"otherPart\\", Type=\\"BasePart\\"}},
            [\\"RunService.Heartbeat\\"]         = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.RenderStepped\\"]     = {{Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"RunService.Stepped\\"]           = {{Name=\\"time\\", Type=\\"number\\"}, {Name=\\"deltaTime\\", Type=\\"number\\"}},
            [\\"UserInputService.InputBegan\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputEnded\\"]  = {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"UserInputService.InputChanged\\"]= {{Name=\\"input\\", Type=\\"InputObject\\"}, {Name=\\"gameProcessedEvent\\", Type=\\"bool\\"}},
            [\\"RemoteEvent.OnClientEvent\\"]    = {{Name=\\"args\\", Type=\\"Tuple\\"}},
            [\\"BindableEvent.Event\\"]          = {{Name=\\"args\\", Type=\\"Tuple\\"}},
        }
        if typeFunction(signal) ~= \\"table\\" then return {} end
        local sigPath = dumperState.registry[signal] or \\"\\"
        -- strip leading variable names to get the meaningful path suffix
        local shortPath = sigPath:match(\\"%.(.+)$\\") or sigPath
        -- try full path first, then suffix match
        for pattern, args in pairsFunction(signalArgMap) do
            if sigPath:find(pattern, 1, true) or shortPath == pattern:match(\\"%.(.+)$\\") then
                return args
            end
        end
        -- generic fallback: return empty table (signal exists but unknown args)
        return {}
    end,
    fireclickdetector = function(detector, dist) end,
    fireproximityprompt = function(prompt) end,
    firetouchinterest = function(a, b, c) end,
    getinstances = function()
        local instances = {}
        for inst in pairsFunction(dumperState.property_store) do
            if isProxy(inst) and (dumperState.property_store[inst].ClassName or dumperState.registry[inst]) then
                table.insert(instances, inst)
            end
        end
        if #instances == 0 then table.insert(instances, game) end
        return instances
    end,
    getnilinstances = function() return {} end,
    getgc = function() return {} end,
    getscripts = function() return {} end,
    getrunningscripts = function()
        -- AT3: must include the Animate script from character, but NOT arbitrary LocalScript instances
        local result = {}
        if _at.animateScript then result[#result+1] = _at.animateScript end
        return result
    end,
    getloadedmodules = function() return {} end,
    getcallingscript = function() return script end,
    readfile = function(file)
        emitOutput(string.format(\\"readfile(%s)\\", formatStringLiteral(file)))
        return _at.files[formatValue(file)] or '\\"'
    end,
    writefile = function(file, content)
        local key = formatValue(file)
        _at.files[key] = formatValue(content)
        _at.files_hidden = _at.files_hidden or {}
        _at.files_hidden[key] = true  -- mark as hidden from listfiles
        emitOutput(string.format(\\"writefile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    appendfile = function(file, content)
        local name = formatValue(file)
        _at.files[name] = (_at.files[name] or \\"\\") .. formatValue(content)
        emitOutput(string.format(\\"appendfile(%s, %s)\\", formatStringLiteral(file), serializeValue(content)))
    end,
    loadfile = function(file) return function() return createProxyObject(\\"loaded_file\\", false) end end,
    listfiles = function(folder)
        local base = formatValue(folder or \\"\\")
        -- normalize: strip leading slash so \\"/\\" matches all files
        base = base:gsub(\\"^/+\\", \\"\\")
        local result = {}
        for name in pairsFunction(_at.folders) do
            if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
        end
        for name in pairsFunction(_at.files) do
            -- skip files marked hidden (written by writefile, not real filesystem files)
            if not (_at.files_hidden and _at.files_hidden[name]) then
                if base == \\"\\" or name:match(\\"^\\" .. base:gsub(\\"([^%w])\\", \\"%%%1\\")) then table.insert(result, name) end
            end
        end
        return result
    end,
    isfile = function(file) return _at.files[formatValue(file)] ~= nil end,
    isfolder = function(folder) return _at.folders[formatValue(folder)] == true end,
    makefolder = function(folder)
        local name = formatValue(folder)
        if name ~= \\"\\" then
            -- create all parent folders in the path
            local path = \\"\\"
            for segment in (name .. \\"/\\"):gmatch(\\"([^/]+)/\\") do
                path = path == \\"\\" and segment or (path .. \\"/\\" .. segment)
                _at.folders[path] = true
            end
        end
        emitOutput(string.format(\\"makefolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfolder = function(folder)
        local name = formatValue(folder)
        _at.folders[name] = nil
        emitOutput(string.format(\\"delfolder(%s)\\", formatStringLiteral(folder)))
    end,
    delfile = function(file)
        _at.files[formatValue(file)] = nil
        emitOutput(string.format(\\"delfile(%s)\\", formatStringLiteral(file)))
    end,
    DrawingImmediate = (function()
        local function makePaint()
            local cbs = {}
            return {
                Connect = function(self, fn)
                    cbs[#cbs+1] = fn
                    -- return plain table so typeof(cn)==\\"table\\" passes the AT check
                    return {
                        Disconnect = function(self)
                            for i,v in ipairs(cbs) do if v==fn then table.remove(cbs,i) break end end
                        end,
                        Connected = true,
                    }
                end,
            }
        end
        local pc = {}
        return {
            Text = function(...) emitOutput(\\"DrawingImmediate.Text(...)\\") end,
            Line = function(...) emitOutput(\\"DrawingImmediate.Line(...)\\") end,
            Circle = function(...) emitOutput(\\"DrawingImmediate.Circle(...)\\") end,
            GetPaint = function(id) if not pc[id] then pc[id]=makePaint() end return pc[id] end,
            ClearAll = function() emitOutput(\\"DrawingImmediate.ClearAll()\\") end,
        }
    end)(),
    Drawing = {
        new = function(type)
            local t = formatValue(type)
            local proxy = createProxyObject(\\"Drawing_\\" .. t, false)
            registerVariable(proxy, t)
            _at.userdata[proxy] = \\"renderobj\\"
            emitOutput(string.format(\\"local %s = Drawing.new(%s)\\", dumperState.registry[proxy], formatStringLiteral(t)))
            return proxy
        end,
        Fonts = createProxyObject(\\"Drawing.Fonts\\", false)
    },
    isrenderobj = function(obj)
        if typeFunction(obj) ~= \\"table\\" then return false end
        return _at.userdata[obj] == \\"renderobj\\"
    end,
    crypt = {
        base64encode = function(s) return s end,
        base64decode = function(s) return s end,
        base64_encode = function(s) return s end,
        base64_decode = function(s) return s end,
        encrypt = function(s, k) return s end,
        decrypt = function(s, k) return s end,
        hash = function(s) return \\"hash\\" end,
        generatekey = function(len) return string.rep(\\"0\\", len or 32) end,
        generatebytes = function(len) return string.rep(\\"\\\\0\\", len or 16) end
    },
    base64_encode = function(s) return s end,
    base64_decode = function(s) return s end,
    base64encode = function(s) return s end,
    base64decode = function(s) return s end,
    mouse1click = function() emitOutput(\\"mouse1click()\\") end,
    mouse1press = function() emitOutput(\\"mouse1press()\\") end,
    mouse1release = function() emitOutput(\\"mouse1release()\\") end,
    mouse2click = function() emitOutput(\\"mouse2click()\\") end,
    mouse2press = function() emitOutput(\\"mouse2press()\\") end,
    mouse2release = function() emitOutput(\\"mouse2release()\\") end,
    mousemoverel = function(x, y) emitOutput(string.format(\\"mousemoverel(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousemoveabs = function(x, y) emitOutput(string.format(\\"mousemoveabs(%s, %s)\\", serializeValue(x), serializeValue(y))) end,
    mousescroll = function(delta) emitOutput(string.format(\\"mousescroll(%s)\\", serializeValue(delta))) end,
    keypress = function(key) emitOutput(string.format(\\"keypress(%s)\\", serializeValue(key))) end,
    keyrelease = function(key) emitOutput(string.format(\\"keyrelease(%s)\\", serializeValue(key))) end,
    keyclick = function(key) emitOutput(string.format(\\"keyclick(%s)\\", serializeValue(key))) end,
    isreadonly = function(t) return false end,
    setreadonly = function(t, val) return t end,
    make_writeable = function(t) return t end,
    make_readonly = function(t) return t end,
    getthreadidentity = function() return 7 end,
    setthreadidentity = function(id) end,
    getidentity = function() return 7 end,
    setidentity = function(id) end,
    getthreadcontext = function() return 7 end,
    setthreadcontext = function(id) end,
    getcustomasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getsynasset = function(file) return \\"rbxasset://\\" .. formatValue(file) end,
    getinfo = function(func) return {source = \\"=\\", what = \\"Lua\\", name = \\"unknown\\", short_src = \\"dumper\\"} end,
    getconstants = function(func) return {} end,
    getupvalues = function(func) return {} end,
    getprotos = function(func) return {} end,
    getupvalue = function(func, i) return nil end,
    setupvalue = function(func, i, val) end,
    setconstant = function(func, i, val) end,
    getconstant = function(func, i) return nil end,
    getproto = function(func, i) return function() end end,
    setproto = function(func, i, f) end,
    getstack = function(level, i) return nil end,
    setstack = function(level, i, val) end,
    debug = {
        getinfo = function(func, ...)
            if func == print or func == _G.print or func == warn or func == _G.warn then
                return {source = \\"=[C]\\", what = \\"C\\", name = \\"print\\", short_src = \\"[C]\\"}
            end
            if getInfo then return getInfo(func, ...) end
            return {source = \\"=[C]\\", what = \\"C\\", short_src = \\"[C]\\"}
        end,
        getupvalue = debugLibrary.getupvalue or function() return nil end,
        setupvalue = debugLibrary.setupvalue or function() end,
        getmetatable = debugLibrary.getmetatable,
        setmetatable = debugLibrary.setmetatable or setmetatable,
        traceback = getTraceback or function() return '\\"' end,
        profilebegin = function() end,
        profileend = function() end,
        sethook = function() end
    },
    rconsoleprint = function(s) end,
    rconsoleclear = function() end,
    rconsolecreate = function() end,
    rconsoledestroy = function() end,
    rconsoleinput = function() return \\"\\" end,
    rconsoleinfo = function(s) end,
    rconsolewarn = function(s) end,
    rconsoleerr = function(s) end,
    rconsolename = function(name) end,
    printconsole = function(s) end,
    setfflag = function(flag, val) end,
    getfflag = function(flag) return \\"\\" end,
    setfpscap = function(cap) emitOutput(string.format(\\"setfpscap(%s)\\", serializeValue(cap))) end,
    getfpscap = function() return 60 end,
    isnetworkowner = function(part) return true end,
    gethiddenproperty = function(instance, prop)
        if not isProxy(instance) then return nil, false end
        local props = dumperState.property_store[instance]
        if props and props[prop] ~= nil then return props[prop], true end
        return nil, false
    end,
    sethiddenproperty = function(instance, prop, val)
        if isProxy(instance) then
            local props = dumperState.property_store[instance]
            if props then
                if prop == \\"DistributedGameTime\\" then
                    -- don't store the set value; just record a tick base from current real value
                    -- so subsequent reads keep ticking from where they were
                    if not _at._dgtClock then
                        _at._dgtBase = (props[prop] or 1)
                        _at._dgtClock = osLibrary.clock()
                    end
                    -- intentionally do NOT store val - real Roblox ignores the set
                else
                    props[prop] = val
                end
            end
        end
        emitOutput(string.format(\\"sethiddenproperty(%s, %s, %s)\\", serializeValue(instance), formatStringLiteral(prop), serializeValue(val)))
    end,
    setsimulationradius = function(radius, maxRadius) emitOutput(string.format(\\"setsimulationradius(%s%s)\\", serializeValue(radius), maxRadius and \\", \\" .. serializeValue(maxRadius) or \\"\\")) end,
    getspecialinfo = function(instance) return {} end,
    saveinstance = function(options) emitOutput(string.format(\\"saveinstance(%s)\\", serializeValue(options or {}))) end,
    decompile = function(script) return \\"-- decompiled\\" end,
    lz4compress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4compress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        local lenBytes = string.char(
            math.floor(#s / 16777216) % 256,
            math.floor(#s / 65536) % 256,
            math.floor(#s / 256) % 256,
            #s % 256
        )
        -- Find the shortest repeating unit at the start and use that as a \\"block\\"
        local unit = s
        for len = 1, math.floor(#s / 2) do
            local candidate = s:sub(1, len)
            local repeated = string.rep(candidate, math.floor(#s / len))
            local remainder = s:sub(#repeated + 1)
            if repeated .. remainder == s then
                unit = candidate
                break
            end
        end
        -- Encode as: magic + origLen + unitLen(2 bytes) + unit + count(2 bytes) + remainder
        local count = math.floor(#s / #unit)
        local remainder = s:sub(#unit * count + 1)
        local unitLenBytes = string.char(math.floor(#unit / 256) % 256, #unit % 256)
        local countBytes = string.char(math.floor(count / 256) % 256, count % 256)
        local remLenBytes = string.char(math.floor(#remainder / 256) % 256, #remainder % 256)
        return magic .. lenBytes .. unitLenBytes .. unit .. countBytes .. remLenBytes .. remainder
    end,
    lz4decompress = function(s)
        if typeFunction(s) ~= \\"string\\" then errorFunction(\\"invalid argument to lz4decompress\\", 2) end
        local magic = \\"\x04\x22\x4d\x18\\"
        if #s < 12 or s:sub(1, 4) ~= magic then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local b1, b2, b3, b4 = s:byte(5), s:byte(6), s:byte(7), s:byte(8)
        local origLen = b1 * 16777216 + b2 * 65536 + b3 * 256 + b4
        local unitLenHi, unitLenLo = s:byte(9), s:byte(10)
        local unitLen = unitLenHi * 256 + unitLenLo
        if #s < 10 + unitLen + 4 then
            errorFunction(\\"lz4decompress: invalid compressed data\\", 2)
        end
        local unit = s:sub(11, 10 + unitLen)
        local countHi, countLo = s:byte(11 + unitLen), s:byte(12 + unitLen)
        local count = countHi * 256 + countLo
        local remLenHi, remLenLo = s:byte(13 + unitLen), s:byte(14 + unitLen)
        local remLen = remLenHi * 256 + remLenLo
        local remainder = s:sub(15 + unitLen, 14 + unitLen + remLen)
        return (string.rep(unit, count) .. remainder):sub(1, origLen)
    end,
    MessageBox = function(text, caption, type) return 1 end,
    setwindowactive = function() end,
    setwindowtitle = function(title) end,
    queue_on_teleport = function(code) emitOutput(string.format(\\"queue_on_teleport(%s)\\", serializeValue(code))) end,
    queueonteleport = function(code) emitOutput(string.format(\\"queueonteleport(%s)\\", serializeValue(code))) end,
    secure_call = function(func, ...) return func(...) end,
    create_secure_function = function(func) return func end,
    isvalidinstance = function(instance) return instance ~= nil end,
    validcheck = function(instance) return instance ~= nil end
}
for name, func in pairsFunction(exploitFuncs) do
    _G[name] = func
end
local nativeBit32 = bit32
local bitLibrary = {}
local function toBit(n)
    n = (n or 0) % 4294967296
    if n >= 2147483648 then n = n - 4294967296 end
    return math.floor(n)
end
local function toU32(n) return math.floor((n or 0) % 4294967296) end

local function _band(a, b)
    if nativeBit32 then return nativeBit32.band(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 and b > 0 do
        if a % 2 == 1 and b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bor(a, b)
    if nativeBit32 then return nativeBit32.bor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 == 1 or b % 2 == 1 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _bxor(a, b)
    if nativeBit32 then return nativeBit32.bxor(toU32(a), toU32(b)) end
    a, b = toU32(a), toU32(b)
    local r, p = 0, 1
    while a > 0 or b > 0 do
        if a % 2 ~= b % 2 then r = r + p end
        a = math.floor(a / 2); b = math.floor(b / 2); p = p * 2
    end
    return r
end
local function _lshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return toU32(toU32(n) * (2 ^ bits))
end
local function _rshift(n, bits)
    bits = (bits or 0) % 32
    if bits == 0 then return toU32(n) end
    return math.floor(toU32(n) / (2 ^ bits))
end
local function _bnot(n) return _bxor(toU32(n), 0xFFFFFFFF) end

bitLibrary.tobit = toBit
bitLibrary.tohex = function(n, len)
    return string.format(\\"%0\\" .. (len or 8) .. \\"x\\", toU32(n))
end
bitLibrary.band = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _band(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bxor = function(...)
    local r = toU32(select(1, ...))
    for i = 2, select(\\"#\\", ...) do r = _bxor(r, toU32(select(i, ...))) end
    return toBit(r)
end
bitLibrary.bnot    = function(n) return toBit(_bnot(n or 0)) end
bitLibrary.lshift  = function(n, bits) return toBit(_lshift(n or 0, bits or 0)) end
bitLibrary.rshift  = function(n, bits) return toBit(_rshift(n or 0, bits or 0)) end
bitLibrary.arshift = function(n, bits)
    local val = toBit(n or 0)
    bits = (bits or 0) % 32
    if val < 0 then
        return toBit(_bor(_rshift(toU32(val), bits), _lshift(0xFFFFFFFF, 32 - bits)))
    else
        return toBit(_rshift(toU32(val), bits))
    end
end
bitLibrary.rol = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_lshift(n, bits), _rshift(n, 32 - bits)))
end
bitLibrary.ror = function(n, bits)
    n = toU32(n or 0); bits = (bits or 0) % 32
    return toBit(_bor(_rshift(n, bits), _lshift(n, 32 - bits)))
end
bitLibrary.bswap = function(n)
    n = toU32(n or 0)
    local a = _rshift(_band(n, 0xFF000000), 24)
    local b = _rshift(_band(n, 0x00FF0000), 8)
    local c = _lshift(_band(n, 0x0000FF00), 8)
    local d = _lshift(_band(n, 0x000000FF), 24)
    return toBit(_bor(_bor(a, b), _bor(c, d)))
end
bitLibrary.countlz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    if _band(n, 0xFFFF0000) == 0 then count = count + 16; n = _lshift(n, 16) end
    if _band(n, 0xFF000000) == 0 then count = count + 8;  n = _lshift(n, 8)  end
    if _band(n, 0xF0000000) == 0 then count = count + 4;  n = _lshift(n, 4)  end
    if _band(n, 0xC0000000) == 0 then count = count + 2;  n = _lshift(n, 2)  end
    if _band(n, 0x80000000) == 0 then count = count + 1   end
    return count
end
bitLibrary.countrz = function(n)
    n = toU32(bitLibrary.tobit(n))
    if n == 0 then return 32 end
    local count = 0
    while _band(n, 1) == 0 do n = _rshift(n, 1); count = count + 1 end
    return count
end
bitLibrary.lrotate = bitLibrary.rol
bitLibrary.rrotate = bitLibrary.ror
bitLibrary.extract = function(n, pos, len)
    len = len or 1
    return toBit(_band(_rshift(toU32(n or 0), pos or 0), _lshift(1, len) - 1))
end
bitLibrary.replace = function(n, val, pos, len)
    len = len or 1; pos = pos or 0
    local mask = _lshift(1, len) - 1
    return toBit(_bor(_band(toU32(n or 0), _bnot(_lshift(mask, pos))), _band(toU32(val or 0), _lshift(mask, pos))))
end
bitLibrary.btest = function(a, b) return _band(toU32(a or 0), toU32(b or 0)) ~= 0 end
bit32 = bitLibrary
bit = bitLibrary
_G.bit = bitLibrary
_G.bit32 = bitLibrary
table.getn = table.getn or function(t) return #t end
table.foreach = table.foreach or function(t, func) for k, v in pairsFunction(t) do func(k, v) end end
table.foreachi = table.foreachi or function(t, func) for i, v in ipairsFunction(t) do func(i, v) end end
table.find = table.find or function(t, value, init)
    for i = (init or 1), #t do
        if t[i] == value then return i end
    end
    return nil
end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairsFunction(t) do out[k] = v end
    return out
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function(t) return false end
table.clear = table.clear or function(t) for k in pairsFunction(t) do t[k] = nil end end
table.find = table.find or function(t, val, init)
    for i = init or 1, #t do
        if t[i] == val then return i end
    end
    return nil
end
table.clear = table.clear or function(t)
    for k in pairs(t) do t[k] = nil end
end
table.freeze = table.freeze or function(t) return t end
table.isfrozen = table.isfrozen or function() return false end
table.clone = table.clone or function(t)
    local out = {}
    for k, v in pairs(t) do out[k] = v end
    return out
end
table.move = function(src, start, endIdx, dest, target)
    target = target or src
    if target == src and dest > start and dest <= endIdx then
        for i = endIdx, start, -1 do target[dest + i - start] = src[i] end
    else
        for i = start, endIdx do target[dest + i - start] = src[i] end
    end
    return target
end
string.split = string.split or function(str, sep)
    local t = {}
    for match in string.gmatch(str, \\"([^\\" .. (sep or \\"%s\\") .. \\"]+)\\") do table.insert(t, match) end
    return t
end
if not math.frexp then
    math.frexp = function(x)
        if x == 0 then return 0, 0 end
        local exp = math.floor(math.log(math.abs(x)) / math.log(2)) + 1
        local m = x / 2 ^ exp
        return m, exp
    end
end
if not math.ldexp then math.ldexp = function(m, e) return m * 2 ^ e end end
if not utf8 then
    utf8 = {}
    utf8.char = function(...)
        local args = {...}
        local chars = {}
        for _, byte in ipairsFunction(args) do table.insert(chars, string.char(byte % 256)) end
        return table.concat(chars)
    end
    utf8.len = function(s) return #s end
    utf8.codes = function(s)
        local i = 0
        return function() i = i + 1; if i <= #s then return i, string.byte(s, i) end end
    end
end
-- graphemes: bypass nested anti-tamper chain third[1][1][1][1][1][1](first, second)
utf8.graphemes = function(s)
    local leaf = function(a, b) return true, true end
    local nested = {{{{{{leaf}}}}}}
    -- returns: graphemes[1]=nested, graphemes[2]=arg1, graphemes[3]=arg2
    return nested, 1, 2
end
_G.utf8 = utf8
pairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return pairsFunction(t) end
    return function() return nil end, t, nil
end
ipairs = function(t)
    if typeFunction(t) == \\"table\\" and not isProxy(t) then return ipairsFunction(t) end
    return function() return nil end, t, 0
end
_G.pairs = pairs
_G.ipairs = ipairs
_G.math = math
_G.table = table
-- override string.dump to error on exploit/proxy functions like real Roblox
local _realStringDump = string.dump
string.dump = function(f, ...)
    if isProxy(f) then
        errorFunction(\\"unable to dump given function\\", 2)
    end
    -- exploit funcs registered in _G are not dumpable
    for name, val in pairsFunction(exploitFuncs) do
        if val == f then errorFunction(\\"unable to dump given function\\", 2) end
    end
    return _realStringDump(f, ...)
end
_G.string = string
_G.os = os
os.execute = function() return nil end
os.exit = function() return nil end
os.remove = function() return nil, \\"disabled\\" end
os.rename = function() return nil, \\"disabled\\" end
_G.coroutine = coroutine
_G.io = nil
_G.debug = exploitFuncs.debug
_G._realSetHook = setHook
_G.utf8 = utf8
_G.next = next
_G.tostring = tostring
_G.tonumber = tonumber
_G.getmetatable = getmetatable
_G.setmetatable = setmetatable
_G.pcall = function(f, ...)
    local results = {pcallFunction(f, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.xpcall = function(f, errFunc, ...)
    local function wrapper(err)
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then return err end
        if errFunc then return errFunc(err) end
        return err
    end
    local results = {xpcallFunction(f, wrapper, ...)}
    local success = results[1]
    if not success then
        local err = results[2]
        if typeFunction(err) == \\"string\\" and err:match(\\"TIMEOUT_FORCED_BY_DUMPER\\") then errorFunction(err) end
    end
    return table.unpack(results)
end
_G.error = errorFunction
if _G.originalError == nil then _G.originalError = errorFunction end
_G.assert = assert
_G.select = select
_G.type = typeFunction
_G.rawget = rawget
_G.rawset = rawset
_G.rawequal = rawEqualFunction
_G.rawlen = rawlen or function(t) return #t end
_G.unpack = table.unpack or unpack
_G.pack = table.pack or function(...) return {n = select(\\"#\\", ...), ...} end
_G.task = task
_G.wait = wait
_G.Wait = wait
_G.delay = delay
_G.Delay = delay
_G.spawn = spawn
_G.Spawn = spawn
_G.tick = tick
_G.time = time
_G.elapsedTime = elapsedTime
_G.game = game
_G.Game = game
_G.workspace = workspace
_G.Workspace = workspace
_G.script = script
_G.Enum = Enum
_G.Instance = Instance
_G.Random = Random
_G.Vector3 = Vector3
_G.Vector2 = Vector2
_G.CFrame = CFrame
_G.Color3 = Color3
_G.BrickColor = BrickColor
_G.UDim = UDim
_G.UDim2 = UDim2
_G.TweenInfo = TweenInfo
_G.Rect = Rect
_G.Region3 = Region3
_G.Region3int16 = Region3int16
_G.Ray = Ray
_G.NumberRange = NumberRange
_G.NumberSequence = NumberSequence
_G.NumberSequenceKeypoint = NumberSequenceKeypoint
_G.ColorSequence = ColorSequence
_G.ColorSequenceKeypoint = ColorSequenceKeypoint
_G.PhysicalProperties = PhysicalProperties
_G.Font = Font
_G.RaycastParams = RaycastParams
_G.OverlapParams = OverlapParams
_G.PathWaypoint = PathWaypoint
_G.Axes = Axes
_G.Faces = Faces
_G.Vector3int16 = Vector3int16
_G.Vector2int16 = Vector2int16
_G.CatalogSearchParams = CatalogSearchParams
_G.DateTime = DateTime
settings = function()
    local enumKey = \\"Enum.QualityLevel.Automatic\\"
    if not _at.enum[enumKey] then
        local p = createProxyObject(enumKey, false)
        dumperState.registry[p] = enumKey
        _at.enum[enumKey] = p
    end
    local qualityProxy = _at.enum[enumKey]
    return {
        Rendering = {QualityLevel = qualityProxy, FrameRateManager = 0, EagerBulkExecution = false},
        Studio    = {},
        Network   = {IncomingReplicationLag = 0},
        Physics   = {PhysicsEnvironmentalThrottle = createProxyObject(\\"Enum.EnviromentalPhysicsThrottle.DefaultAuto\\", false)},
    }
end
_G.settings = settings
getmetatable = function(x)
    if _at.userdata[x] then return getMetatableFunction(x) end
    if isProxy(x) then return \\"The metatable is locked\\" end
    return getMetatableFunction(x)
end
_G.getmetatable = getmetatable
type = function(x)
    if _at.threadLike[x] then return \\"thread\\" end
    if _at.userdata[x] then return \\"userdata\\" end
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then return \\"userdata\\" end
    return typeFunction(x)
end
_G.type = type
buffer = {
    create = function(size)
        local b = {}
        _at.buffers[b] = string.rep(\\"\0\\", size or 0)
        return b
    end,
    fromstring = function(s)
        local b = {}
        _at.buffers[b] = formatValue(s)
        return b
    end,
    tostring = function(b)
        return _at.buffers[b] or \\"\\"
    end,
    len = function(b)
        return #(_at.buffers[b] or \\"\\")
    end,
    copy = function(dst, dstOffset, src, srcOffset, count)
        local srcData = _at.buffers[src] or \\"\\"
        local dstData = _at.buffers[dst] or \\"\\"
        srcOffset = (srcOffset or 0) + 1
        dstOffset = (dstOffset or 0) + 1
        local chunk = srcData:sub(srcOffset, count and srcOffset + count - 1 or -1)
        local before = dstData:sub(1, dstOffset - 1)
        local after  = dstData:sub(dstOffset + #chunk)
        _at.buffers[dst] = before .. chunk .. after
    end,
    fill = function(b, offset, value, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        count  = count or (#data - offset + 1)
        local fill = string.rep(string.char(value % 256), count)
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + count)
        _at.buffers[b] = before .. fill .. after
    end,
    writestring = function(b, offset, s, count)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        s = formatValue(s)
        if count then s = s:sub(1, count) end
        local before = data:sub(1, offset - 1)
        local after  = data:sub(offset + #s)
        _at.buffers[b] = before .. s .. after
    end,
    readstring = function(b, offset, len)
        local data = _at.buffers[b] or \\"\\"
        offset = (offset or 0) + 1
        return data:sub(offset, len and offset + len - 1 or -1)
    end,
    writeu8  = function(b, offset, v) local d=_at.buffers[b] or\\"\\"; offset=(offset or 0)+1; _at.buffers[b]=d:sub(1,offset-1)..string.char(v%256)..d:sub(offset+1) end,
    readu8   = function(b, offset) local d=_at.buffers[b] or\\"\\"; return string.byte(d,(offset or 0)+1) or 0 end,
    writeu16 = function(b, offset, v) offset=(offset or 0); buffer.writeu8(b,offset,v%256); buffer.writeu8(b,offset+1,math.floor(v/256)%256) end,
    readu16  = function(b, offset) return buffer.readu8(b,offset) + buffer.readu8(b,(offset or 0)+1)*256 end,
    writeu32 = function(b, offset, v) offset=(offset or 0); for i=0,3 do buffer.writeu8(b,offset+i,math.floor(v/(256^i))%256) end end,
    readu32  = function(b, offset) local v=0; for i=0,3 do v=v+buffer.readu8(b,(offset or 0)+i)*(256^i) end; return v end,
    writei8  = function(b, offset, v) buffer.writeu8(b, offset, v < 0 and v+256 or v) end,
    readi8   = function(b, offset) local v=buffer.readu8(b,offset); return v>=128 and v-256 or v end,
    writei16 = function(b, offset, v) buffer.writeu16(b, offset, v < 0 and v+65536 or v) end,
    readi16  = function(b, offset) local v=buffer.readu16(b,offset); return v>=32768 and v-65536 or v end,
    writei32 = function(b, offset, v) buffer.writeu32(b, offset, v < 0 and v+4294967296 or v) end,
    readi32  = function(b, offset) local v=buffer.readu32(b,offset); return v>=2147483648 and v-4294967296 or v end,
    writef32 = function(b, offset, v) buffer.writeu32(b, offset, math.floor(math.abs(v)*1000)%4294967296) end,
    readf32  = function(b, offset) return buffer.readu32(b,offset)/1000 end,
    writef64 = function(b, offset, v) buffer.writeu32(b, offset, 0); buffer.writeu32(b, (offset or 0)+4, math.floor(math.abs(v)*1000)%4294967296) end,
    readf64  = function(b, offset) return buffer.readu32(b,(offset or 0)+4)/1000 end,
}
_G.buffer = buffer
typeof = function(x)
    if getProxyValue(x) ~= 0 then return \\"number\\" end
    if isProxy(x) then
        if _at.typeOverride[x] then return _at.typeOverride[x] end
        local regName = dumperState.registry[x]
        if regName then
            if regName == \\"Enum\\" then return \\"Enums\\" end
            if regName:match(\\"^Enum%.[^%.]+$\\") then return \\"Enum\\" end
            if regName:match(\\"^Enum%.[^%.]+%.[^%.]+$\\") then return \\"EnumItem\\" end
            if regName:match(\\"Vector3\\") then return \\"Vector3\\" end
            if regName:match(\\"CFrame\\") then return \\"CFrame\\" end
            if regName:match(\\"Color3\\") then return \\"Color3\\" end
            if regName:match(\\"UDim\\") then return \\"UDim2\\" end
        end
        return \\"Instance\\"
    end
    if _at.threadLike[x] then return \\"thread\\" end
    local mt = getMetatableFunction(x)
    if mt and mt.__typeof then return mt.__typeof end
    return typeFunction(x) == \\"table\\" and \\"table\\" or typeFunction(x)
end
_G.typeof = typeof
newproxy = function(withMeta)
    local proxy = {}
    _at.userdata[proxy] = true
    if withMeta then
        setmetatable(proxy, {})
    end
    return proxy
end
_G.newproxy = newproxy
tonumber = function(x, base)
    if getProxyValue(x) ~= 0 then return 123456789 end
    return toNumberFunction(x, base)
end
_G.tonumber = tonumber
rawequal = function(a, b) return rawEqualFunction(a, b) end
_G.rawequal = rawequal
tostring = function(x)
    if isProxy(x) then
        local mt = getMetatableFunction(x)
        if mt and mt.__tostring then
            local ok, r = pcallFunction(mt.__tostring, x)
            if ok and r then return r end
        end
        local regName = dumperState.registry[x]
        return regName or \\"Instance\\"
    end
    local mt = getMetatableFunction(x)
    if mt and mt.__tostring then
        local ok, r = pcallFunction(mt.__tostring, x)
        if ok and r then return r end
    end
    return toStringFunction(x)
end
_G.tostring = tostring
dumperState.last_http_url = nil
loadstring = function(code, chunkName)
    if typeFunction(code) ~= \\"string\\" then return function() return createProxyObject(\\"loaded\\", false) end end
    local url = dumperState.last_http_url or code
    dumperState.last_http_url = nil
    local libName = nil
    local lowerCode = url:lower()
    local libs = {{pattern = \\"rayfield\\", name = \\"Rayfield\\"}, {pattern = \\"orion\\", name = \\"OrionLib\\"}, {pattern = \\"kavo\\", name = \\"Kavo\\"}, {pattern = \\"venyx\\", name = \\"Venyx\\"}, {pattern = \\"sirius\\", name = \\"Sirius\\"}, {pattern = \\"linoria\\", name = \\"Linoria\\"}, {pattern = \\"wally\\", name = \\"Wally\\"}, {pattern = \\"dex\\", name = \\"Dex\\"}, {pattern = \\"infinite\\", name = \\"InfiniteYield\\"}, {pattern = \\"hydroxide\\", name = \\"Hydroxide\\"}, {pattern = \\"simplespy\\", name = \\"SimpleSpy\\"}, {pattern = \\"remotespy\\", name = \\"RemoteSpy\\"}}
    for _, lib in ipairsFunction(libs) do if lowerCode:find(lib.pattern) then libName = lib.name; break end end
    if libName then
        local proxy = createProxyObject(libName, false)
        dumperState.registry[proxy] = libName
        dumperState.names_used[libName] = true
        if url:match(\\"^https?://\\") then emitOutput(string.format('local %s = loadstring(game:HttpGet(\\"%s\\"))()', libName, url)) end
        return function() return proxy end
    end
    if url:match(\\"^https?://\\") then
        local proxy = createProxyObject(\\"Library\\", false)
        emitOutput(string.format('local loadstring = loadstring(game:HttpGet(\\"%s\\"))()', url))
        return function() return proxy end
    end
    if code:match(\\"local%s+a%s*=%s*if%s+true%s+then\\") then return nil, \\"attempt to call a nil value\\" end
    if typeFunction(code) == \\"string\\" then code = processString(code) end
    local func, err = loadFunction(code)
    if func then return func end
    local proxy = createProxyObject(\\"LoadedChunk\\", false)
    return function() return proxy end
end
load = loadstring
_G.loadstring = loadstring
_G.load = loadstring
require = function(module)
    local modName = dumperState.registry[module] or serializeValue(module)
    local proxy = createProxyObject(\\"RequiredModule\\", false)
    local varName = registerVariable(proxy, \\"module\\")
    emitOutput(string.format(\\"local %s = require(%s)\\", varName, modName))
    return proxy
end
_G.require = require
print = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"print(%s)\\", table.concat(items, \\", \\")))
end
_G.print = print
warn = function(...)
    local args = {...}
    local items = {}
    for _, val in ipairsFunction(args) do table.insert(items, serializeValue(val)) end
    emitOutput(string.format(\\"warn(%s)\\", table.concat(items, \\", \\")))
end
_G.warn = warn
-- Tag Roblox-like builtins as C closures so iscclosure() returns true for them
do
    if not _at.cclosureSet then _at.cclosureSet = setmetatable({}, {__mode=\\"k\\"}) end
    local _cbuiltins = {
        print, warn, tick, time, elapsedTime, pcall, xpcall, error, assert,
        tostring, tonumber, type, typeof, rawget, rawset, rawequal, rawlen,
        setmetatable, getmetatable, ipairs, pairs, next, select, unpack,
        require, loadstring, load,
    }
    for _, fn in ipairs(_cbuiltins) do
        if typeFunction(fn) == \\"function\\" then
            _at.cclosureSet[fn] = true
        end
    end
end
_G.shared = shared
local globalBase = _G
local globalMeta = setmetatable({}, {
    __index = function(tbl, key)
        if configuration.VERBOSE then printFunction(\\"[VERBOSE] Accessing field: \\" .. toStringFunction(key)) end
        local val = rawget(globalBase, key)
        if val == nil then val = rawget(_G, key) end
        if configuration.VERBOSE then
            if val ~= nil then
                if typeFunction(val) == \\"table\\" then printFunction(\\"[VERBOSE] Found global table: \\" .. toStringFunction(key))
                elseif typeFunction(val) == \\"function\\" then printFunction(\\"[VERBOSE] Found global function: \\" .. toStringFunction(key))
                else printFunction(\\"[VERBOSE] Found global value: \\" .. toStringFunction(key) .. \\" = \\" .. toStringFunction(val)) end
            else
                printFunction(\\"[VERBOSE] Missing field, providing dummy function: \\" .. toStringFunction(key))
                val = function() if configuration.VERBOSE then printFunction(\\"[Missing Function] Called: \\" .. toStringFunction(key) .. \\" with 0 arguments\\") end return nil end
            end
        end
        return val
    end,
    __newindex = function(tbl, key, val) rawset(globalBase, key, val) end
})
_G._G = globalMeta
function proxyTable.reset()
    dumperState = {output = {}, indent = 0, registry = {}, reverse_registry = {}, names_used = {}, parent_map = {}, property_store = {}, call_graph = {}, variable_types = {}, string_refs = {}, proxy_id = 0, callback_depth = 0, pending_iterator = false, last_http_url = nil, last_emitted_line = nil, repetition_count = 0, current_size = 0, limit_reached = false, ls_counter = 0, captured_constants = {}}
    _at.mem = {}
    _at.tags = {}
    _at.sigs = {}
    _at.acts = {}
    _at.json = {}
    _at.enum = {}
    _at.svcCache = {}
    _at.typeOverride = {}
    _at.connState = {}
    _at.pendingHeartbeat = {}
    _at.locEntries = {}
    _at.userdata = {}
    _at.localPlayer = nil
    setmetatable(_at.userdata, {__mode = \\"k\\"})
    _at.debugIds = {}
    setmetatable(_at.debugIds, {__mode = \\"k\\"})
    _at.debugIdCtr = 0
    uiCounters = {}
    game = createProxyObject(\\"game\\", true)
    workspace = createProxyObject(\\"workspace\\", true)
    script = createProxyObject(\\"script\\", true)
    Enum = createProxyObject(\\"Enum\\", true)
    shared = createProxyObject(\\"shared\\", true)
    dumperState.property_store[game] = {PlaceId = numericArg, GameId = numericArg, placeId = numericArg, gameId = numericArg}
    dumperState.property_store[script] = {Name = \\"DumpedScript\\", Parent = game, ClassName = \\"LocalScript\\"}
    _G.game = game; _G.Game = game; _G.workspace = workspace; _G.Workspace = workspace; _G.script = script; _G.Enum = Enum; _G.shared = shared
    local meta = debugLibrary.getmetatable(Enum)
    meta.__index = function(_, key)
        if key == proxyList or key == \\"__proxy_id\\" then return rawget(_, key) end
        local enumName = \\"Enum.\\" .. formatValue(key)
        if not _at.enum[enumName] then
            local enumProxy = createProxyObject(enumName, false)
            dumperState.registry[enumProxy] = enumName
            _at.enum[enumName] = enumProxy
        end
        return _at.enum[enumName]
    end
    seedCoreRobloxInstances()
    if type(_G._bypassOnReset) == \\"function\\" then
        local prevOutput = dumperState.output
        local prevOutputCount = #prevOutput
        local prevIndent = dumperState.indent
        local prevLast = dumperState.last_emitted_line
        local prevRep = dumperState.repetition_count
        local prevSize = dumperState.current_size
        local prevLimit = dumperState.limit_reached
        pcall(_G._bypassOnReset)
        for i = #prevOutput, prevOutputCount + 1, -1 do
            prevOutput[i] = nil
        end
        dumperState.output = prevOutput
        dumperState.indent = prevIndent
        dumperState.last_emitted_line = prevLast
        dumperState.repetition_count = prevRep
        dumperState.current_size = prevSize
        dumperState.limit_reached = prevLimit
    end
end
function proxyTable.get_output() return getFullOutput() end
function proxyTable.save(file) return saveToFile(file) end
function proxyTable.get_call_graph() return dumperState.call_graph end
function proxyTable.get_string_refs() return dumperState.string_refs end
function proxyTable.get_stats() return {total_lines = #dumperState.output, remote_calls = #dumperState.call_graph, suspicious_strings = #dumperState.string_refs, proxies_created = dumperState.proxy_id} end
local dumper = {callId = \\"LUASPLOIT_\\", binaryOperatorNames = {[\\"and\\"] = \\"AND\\", [\\"or\\"] = \\"OR\\", [\\">\\"] = \\"GT\\", [\\"<\\"] = \\"LT\\", [\\">=\\"] = \\"GE\\", [\\"<=\\"] = \\"LE\\", [\\"==\\"] = \\"EQ\\", [\\"~=\\"] = \\"NEQ\\", [\\"..\\"] = \\"CAT\\"}}
function dumper:hook(code) return self.callId .. code end
function dumper:process_expr(expr)
    if not expr then return \\"nil\\" end
    if typeFunction(expr) == \\"string\\" then return expr end
    local tag = expr.tag or expr.kind
    if tag == \\"number\\" or tag == \\"string\\" then
        local val = tag == \\"string\\" and string.format(\\"%q\\", expr.text) or (expr.value or expr.text)
        if configuration.CONSTANT_COLLECTION then return string.format(\\"%sGET(%s)\\", self.callId, val) end
        return val
    end
    if tag == \\"local\\" or tag == \\"global\\" then return (expr.name or expr.token).text
    elseif tag == \\"boolean\\" or tag == \\"bool\\" then return toStringFunction(expr.value)
    elseif tag == \\"binary\\" then
        local lhs = self:process_expr(expr.lhsoperand)
        local rhs = self:process_expr(expr.rhsoperand)
        local op = expr.operator.text
        local opName = self.binaryOperatorNames[op]
        if opName then return string.format(\\"%s%s(%s, %s)\\", self.callId, opName, lhs, rhs) end
        return string.format(\\"(%s %s %s)\\", lhs, op, rhs)
    elseif tag == \\"call\\" then
        local func = self:process_expr(expr.func)
        local args = {}
        for i, node in ipairsFunction(expr.arguments) do args[i] = self:process_expr(node.node or node) end
        return string.format(\\"%sCALL(%s, %s)\\", self.callId, func, table.concat(args, \\", \\"))
    elseif tag == \\"indexname\\" or tag == \\"index\\" then
        local exprStr = self:process_expr(expr.expression)
        local keyStr = tag == \\"indexname\\" and string.format(\\"%q\\", expr.index.text) or self:process_expr(expr.index)
        return string.format(\\"%sCHECKINDEX(%s, %s)\\", self.callId, exprStr, keyStr)
    end
    return \\"nil\\"
end
function dumper:process_statement(stmt)
    if not stmt then return \\"\\" end
    local tag = stmt.tag
    if tag == \\"local\\" or tag == \\"assign\\" then
        local vars, vals = {}, {}
        for _, node in ipairsFunction(stmt.variables or {}) do table.insert(vars, self:process_expr(node.node or node)) end
        for _, node in ipairsFunction(stmt.values or {}) do table.insert(vals, self:process_expr(node.node or node)) end
        return (tag == \\"local\\" and \\"local \\" or \\"\\") .. table.concat(vars, \\", \\") .. \\" = \\" .. table.concat(vals, \\", \\")
    elseif tag == \\"block\\" then
        local stmts = {}
        for _, s in ipairsFunction(stmt.statements or {}) do table.insert(stmts, self:process_statement(s)) end
        return table.concat(stmts, \\"; \\")
    end
    return self:process_expr(stmt) or \\"\\"
end
local function _loosePasteCode(code)
    if typeFunction(code) ~= \\"string\\" then return code end
    code = code:gsub(\\"```lua\\", \\"\\"):gsub(\\"```\\", \\"\\")
    return code
end
local function _loadLooseChunk(code, chunkName)
    local sanitized = processString(_loosePasteCode(code))
    local lines = {}
    sanitized:gsub(\\"([^\n]*)\n?\\", function(line)
        if line ~= \\"\\" or #lines == 0 or sanitized:sub(-1) == \\"\n\\" then table.insert(lines, line) end
    end)
    local skipped = {}
    for _ = 1, 400 do
        local current = table.concat(lines, \\"\n\\")
        local func, err = loadFunction(current, chunkName)
        if func then return func, nil, current, skipped end
        local lineNo = toNumberFunction(toStringFunction(err):match(\\"%]:(%d+):\\") or toStringFunction(err):match(\\":(%d+):\\"))
        if not lineNo or not lines[lineNo] or skipped[lineNo] then return nil, err, current, skipped end
        skipped[lineNo] = lines[lineNo]
        lines[lineNo] = \\"-- \\" .. lines[lineNo]
    end
    return nil, \\"too many invalid loose-paste lines\\", table.concat(lines, \\"\n\\"), skipped
end
function proxyTable.dump_file(inputPath, outputPath)
    proxyTable.reset()
    local file = ioLibrary.open(inputPath, \\"rb\\")
    if not file then
    printFunction(\\"error: cannot open input\\")
        return false
    end
    local code = file:read(\\"*a\\")
    file:close()
    printFunction(\\"input: normalize\\")
    local func, err, sanitized, skipped = _loadLooseChunk(code, \\"Obfuscated_Script\\")
    if not func then
        printFunction(\\"error: load \\" .. toStringFunction(err))
        return false
    end
    if skipped then
        local skippedCount = 0
        for _ in pairsFunction(skipped) do skippedCount = skippedCount + 1 end
        if skippedCount > 0 then printFunction(\\"input: skipped-lines=\\" .. toStringFunction(skippedCount)) end
    end
    local _SANDBOX_BLOCK = {
        io=true, os=true, debug=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true,
    }
    local _rawTb = debugLibrary and debugLibrary.traceback
    local _badTbWords = {
        \\"sandbox\\",\\"hook\\",\\"intercept\\",\\"mock\\",\\"proxy\\",\\"virtual_env\\",
        \\"decompil\\",\\"emulat\\",\\"simulat\\",\\"fake_\\",\\"getupval\\",\\"hookfunc\\",
        \\"replaceclos\\",\\"newcclos\\",\\"restorefunction\\",\\"bypass\\",\\"dumper\\",
    }
    local _tbWrapper = function(thread, msg, level)
        local ok, tb
        if _rawTb then
            if typeFunction(thread) == \\"thread\\" then
                ok, tb = pcallFunction(_rawTb, thread, msg, level)
            else
                ok, tb = pcallFunction(_rawTb, thread, msg)
            end
        end
        if not ok or typeFunction(tb) ~= \\"string\\" then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        local lines = {}
        for line in (tb .. \\"\n\\"):gmatch(\\"([^\n]*)\n\\") do
            local lo = line:lower()
            local bad = false
            for _, w in next, _badTbWords do
                if lo:find(w, 1, true) then bad = true; break end
            end
            if not bad then lines[#lines + 1] = line end
        end
        local cleaned = table.concat(lines, \\"\n\\")
        cleaned = cleaned:gsub(\\"%[([%w%+%/]+)%]\\", function(inner)
            if #inner + 2 < 10 then return \\"[RobloxGameScript]\\" end
            return \\"[\\" .. inner .. \\"]\\"
        end)
        if #cleaned < 20 then
            return \\"stack traceback:\n\\t[RobloxGameScript]: in function <RobloxGameScript:1>\\"
        end
        return cleaned
    end
    local _SAFE_DEBUG = {
        getinfo = function(func, ...)
            if typeFunction(func) == \\"number\\" then
                return nil
            end
            return {source = \\"=[C]\\", what = \\"C\\", name = \\"C function\\", short_src = \\"[C]\\"}
        end,
        traceback  = _tbWrapper,
        getupvalue = function(fn, i) return nil end,
    }
    local _SAFE_OS = {
        clock = function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end,
        time  = osLibrary.time,
        date  = osLibrary.date,
    }
    local env = setmetatable({
        _VERSION = \\"Luau\\",
        LuraphContinue = nil,
        __LC__ = function() end,
        script = script, game = game, workspace = workspace,
        io      = nil,
        os      = _SAFE_OS,
        debug   = _SAFE_DEBUG,
        error   = _origError,
        dofile  = nil,
        loadfile = nil,
        require = nil,
        package = nil,
        socket  = nil,
        ffi     = nil,
        collectgarbage = nil,
        newproxy = newproxy,
        -- hide _G metatable from scripts
        getmetatable = function(obj)
            if obj == _G or obj == env then return nil end
            if _at.userdata[obj] then return getMetatableFunction(obj) end
            if isProxy(obj) then return \\"The metatable is locked\\" end
            return getMetatableFunction(obj)
        end,
        LUASPLOIT_CHECKINDEX = function(tbl, key)
            local val = tbl[key]
            if typeFunction(val) == \\"table\\" and not dumperState.registry[val] then
                dumperState.ls_counter = dumperState.ls_counter + 1
                dumperState.registry[val] = \\"v\\" .. dumperState.ls_counter
            end
            return val
        end,
        LUASPLOIT_GET = function(v) return v end,
        LS_CALL = function(f, ...)
            if typeFunction(f) ~= \\"function\\" then return nil end
            return f(...)
        end,
        LS_NAMECALL = function(t, method, ...)
            if typeFunction(t) ~= \\"table\\" then return nil end
            if typeFunction(t[method]) ~= \\"function\\" then return nil end
            return t[method](t, ...)
        end,
        LUASPLOIT_CALL = function(f, ...) return f(...) end,
        LUASPLOIT_NAMECALL = function(t, method, ...) return t[method](t, ...) end,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end
    }, {
        __index = function(_, k)
            if _SANDBOX_BLOCK[k] then return nil end
            -- block dumper internal globals from leaking into script env
            if k == \\"LuraphContinue\\" or k == \\"__FLAMEDUMPER_REQUIRE_ONLY\\"
            or k == \\"proxyTable\\" or k == \\"dumperState\\" or k == \\"_at\\" then
                return nil
            end
            return _G[k]
        end,
        __newindex = _G
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, env)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, env) end
        end
    end
    printFunction(\\"vm: running\\")
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    local success, runErr = xpcallFunction(function() func() end, function(e) return toStringFunction(e) end)
    setHook()
    if not success and not toStringFunction(runErr):match(\\"TIMEOUT\\") then
        emitComment(\\"Runtime: \\" .. toStringFunction(runErr))
    end
    local saved = proxyTable.save(outputPath or configuration.OUTPUT_FILE)
    if saved then
        local stats = proxyTable.get_stats()
        printFunction(string.format(\\"done: lines=%d remotes=%d strings=%d\\",
            stats.total_lines, stats.remote_calls, stats.suspicious_strings))
    else
        printFunction(\\"error: write failed\\")
    end
    return saved
end
function proxyTable.dump_string(code, outputPath)
    proxyTable.reset()
    if code then code = processString(code) end
    local func, err = loadFunction(code)
    if not func then
        emitComment(\\"Load Error: \\" .. (err or \\"unknown\\"))
        if outputPath then proxyTable.save(outputPath) end
        return false, err
    end
    local _DS_BLOCK = {
        io=true, os=true, dofile=true, loadfile=true,
        require=true, package=true, socket=true, ffi=true,
        collectgarbage=true, debug=true,
    }
    local _DS_OS = { clock=function() local _bc=rawget(_G,\\"_bypassClock\\"); return _bc and _bc() or osLibrary.clock() end, time=osLibrary.time, date=osLibrary.date }
    local dsEnv = setmetatable({
        _VERSION=\\"Luau\\",
        io=nil, os=_DS_OS, debug=nil, dofile=nil, loadfile=nil,
        require=nil, package=nil, socket=nil, ffi=nil,
        collectgarbage=nil, newproxy=newproxy,
        pcall = function(f, ...)
            local override = rawget(_G, \\"_bypassPcall\\")
            if typeFunction(override) == \\"function\\" then
                local res = {override(pcallFunction, f, ...)}
                if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
                return unpack(res)
            end
            local res = {pcallFunction(f, ...)}
            if not res[1] and toStringFunction(res[2]):match(\\"TIMEOUT\\") then errorFunction(res[2], 0) end
            return unpack(res)
        end,
    }, {
        __index = function(_, k)
            if _DS_BLOCK[k] then return nil end
            return _G[k]
        end,
        __newindex = _G,
    })
    do
        local _applied = false
        if debugLibrary and debugLibrary.getupvalue and debugLibrary.setupvalue then
            for _i = 1, 256 do
                local _n = debugLibrary.getupvalue(func, _i)
                if not _n then break end
                if _n == \\"_ENV\\" then
                    debugLibrary.setupvalue(func, _i, dsEnv)
                    _applied = true
                    break
                end
            end
        end
        if not _applied and type(setfenv) == \\"function\\" then
            local _si = debugLibrary and debugLibrary.getinfo and debugLibrary.getinfo(setfenv, \\"S\\")
            if _si and _si.what == \\"C\\" then setfenv(func, dsEnv) end
        end
    end
    local startClock = osLibrary.clock()
    setHook(function()
        if osLibrary.clock() - startClock > configuration.TIMEOUT_SECONDS then
            errorFunction(\\"TIMEOUT\\", 0)
        end
    end, \\"\\", 1000)
    xpcallFunction(function() func() end, function(e)
        emitComment(\\"Runtime: \\" .. toStringFunction(e))
    end)
    setHook()
    if outputPath then return proxyTable.save(outputPath) end
    return true, getFullOutput()
end
do
    local bypassPath = (arg and arg[0] and arg[0]:match(\\"^(.+[\\\\/])\\")) or \\"\\"
    local ok, err = pcall(dofile, bypassPath .. \\"bypass.lua\\")
    if not ok then
        local ok2 = pcall(dofile, \\"bypass.lua\\")
        if not ok2 then
            printFunction(\\"[dumper] bypass.lua not found, continuing without supplement\\")
        end
    end
end

_G.LuraphContinue = nil
if not rawget(_G, \\"__FLAMEDUMPER_REQUIRE_ONLY\\") then
    if arg and arg[1] then
        local success = proxyTable.dump_file(arg[1], arg[2])
        if success then end
    else
        local file = ioLibrary.open(\\"obfuscated.lua\\", \\"rb\\")
        if file then
            file:close()
            local success = proxyTable.dump_file(\\"obfuscated.lua\\")
            if success then
                printFunction(proxyTable.get_output())
            end
        else
            printFunction(\\"Usage: lua dumper.lua <input> [output] [key]\\")
        end
    end
end
return proxyTable
 (linedefined 5105)")
print("[STEP 6] Hunting for source strings in upvalues...")
print("[OK] Upvalues of queue_on_teleport → nil")
print("[OK] Upvalues of getstack → nil")
print("[OK] Upvalues of firetouchinterest → nil")
print("[OK] Upvalues of iswindowactive → nil")
print("[OK] Upvalues of getrunningscripts → nil")
print("[OK] Upvalues of setstack → nil")
print("[OK] Upvalues of base64_decode → nil")
print("[OK] Upvalues of keyrelease → nil")
print("[OK] Upvalues of setidentity → nil")
print("[OK] Upvalues of delfolder → nil")
print("[OK] Upvalues of getidentity → nil")
print("[OK] Upvalues of lz4decompress → nil")
print("[OK] Upvalues of getprotos → nil")
print("[OK] Upvalues of tick → nil")
print("[OK] Upvalues of queueonteleport → nil")
print("[OK] Upvalues of pack → nil")
print("[OK] Upvalues of getloadedmodules → nil")
print("[OK] Upvalues of mousemoveabs → nil")
print("[OK] Upvalues of fireproximityprompt → nil")
print("[OK] Upvalues of getconnections → nil")
print("[OK] Upvalues of setfflag → nil")
print("[OK] Upvalues of isfile → nil")
print("[OK] Upvalues of mouse2click → nil")
print("[OK] Upvalues of next → nil")
print("[OK] Upvalues of iscclosure → nil")
print("[OK] Upvalues of cloneref → nil")
print("[OK] Upvalues of keypress → nil")
print("[OK] Upvalues of loadstring → nil")
print("[OK] Upvalues of setconstant → nil")
print("[OK] Upvalues of spawn → nil")
print("[OK] Upvalues of setmetatable → nil")
print("[OK] Upvalues of newproxy → nil")
print("[OK] Upvalues of getgc → nil")
print("[OK] Upvalues of rconsoledestroy → nil")
print("[OK] Upvalues of mouse1release → nil")
print("[OK] Upvalues of appendfile → nil")
print("[OK] Upvalues of getrawmetatable → nil")
print("[OK] Upvalues of rconsoleinput → nil")
print("[OK] Upvalues of HttpPost → nil")
print("[OK] Upvalues of typeof → nil")
print("[OK] Upvalues of delfile → nil")
print("[OK] Upvalues of rawlen → nil")
print("[OK] Upvalues of getfflag → nil")
print("[OK] Upvalues of Wait → nil")
print("[OK] Upvalues of saveinstance → nil")
print("[OK] Upvalues of gethiddenproperty → nil")
print("[OK] Upvalues of getnamecallmethod → nil")
print("[OK] Upvalues of clonefunction → nil")
print("[OK] Upvalues of select → nil")
print("[OK] Upvalues of setnamecallmethod → nil")
print("[OK] Upvalues of create_secure_function → nil")
print("[OK] Upvalues of require → nil")
print("[OK] Upvalues of rawget → nil")
print("[OK] Upvalues of getfenv → nil")
print("[OK] Upvalues of isrenderobj → nil")
print("[OK] Upvalues of writefile → nil")
print("[OK] Upvalues of rconsoleclear → nil")
print("[OK] Upvalues of rconsolecreate → nil")
print("[OK] Upvalues of getinfo → nil")
print("[OK] Upvalues of base64encode → nil")
print("[OK] Upvalues of makefolder → nil")
print("[OK] Upvalues of error → nil")
print("[OK] Upvalues of base64decode → nil")
print("[OK] Upvalues of mouse1click → nil")
print("[OK] Upvalues of mousescroll → nil")
print("[OK] Upvalues of isreadonly → nil")
print("[OK] Upvalues of getmetatable → nil")
print("[OK] Upvalues of make_readonly → nil")
print("[OK] Upvalues of setrawmetatable → nil")
print("[OK] Upvalues of getthreadidentity → nil")
print("[OK] Upvalues of getinstances → nil")
print("[OK] Upvalues of hookfunction → nil")
print("[OK] Upvalues of getsenv → nil")
print("[OK] Upvalues of isrbxactive → nil")
print("[OK] Upvalues of getupvalue → nil")
print("[OK] Upvalues of setthreadcontext → nil")
print("[OK] Upvalues of identifyexecutor → nil")
print("[OK] Upvalues of delay → nil")
print("[OK] Upvalues of getcustomasset → nil")
print("[OK] Upvalues of getsynasset → nil")
print("[OK] Upvalues of http_request → nil")
print("[OK] Upvalues of validcheck → nil")
print("[OK] Upvalues of readfile → nil")
print("[OK] Upvalues of rconsoleinfo → nil")
print("[OK] Upvalues of listfiles → nil")
print("[OK] Upvalues of time → nil")
print("[OK] Upvalues of make_writeable → nil")
print("[OK] Upvalues of compareinstances → nil")
print("[OK] Upvalues of keyclick → nil")
print("[OK] Upvalues of rconsolewarn → nil")
print("[OK] Upvalues of rconsoleerr → nil")
print("[OK] Upvalues of rconsoleprint → nil")
print("[OK] Upvalues of printconsole → nil")
print("[OK] Upvalues of isgameactive → nil")
print("[OK] Upvalues of unpack → nil")
print("[OK] Upvalues of tonumber → nil")
print("[OK] Upvalues of getspecialinfo → nil")
print("[OK] Upvalues of getupvalues → nil")
print("[OK] Upvalues of setfpscap → nil")
print("[OK] Upvalues of isfolder → nil")
print("[OK] Upvalues of newcclosure → nil")
print("[OK] Upvalues of getfpscap → nil")
print("[OK] Upvalues of fireclickdetector → nil")
print("[OK] Upvalues of setupvalue → nil")
print("[OK] Upvalues of settings → nil")
print("[OK] Upvalues of gethui → nil")
print("[OK] Upvalues of base64_encode → nil")
print("[OK] Upvalues of pcall → nil")
print("[OK] Upvalues of gethiddenui → nil")
print("[OK] Upvalues of checkcaller → nil")
print("[OK] Upvalues of setreadonly → nil")
print("[OK] Upvalues of getclipboard → nil")
print("[OK] Upvalues of decompile → nil")
print("[OK] Upvalues of getconstants → nil")
print("[OK] Upvalues of getnilinstances → nil")
print("[OK] Upvalues of dofile → nil")
print("[OK] Upvalues of loadfile → nil")
print("[OK] Upvalues of lz4compress → nil")
print("[OK] Upvalues of ipairs → nil")
print("[OK] Upvalues of MessageBox → nil")
print("[OK] Upvalues of warn → nil")
print("[OK] Upvalues of print → nil")
print("[OK] Upvalues of setwindowactive → nil")
print("[OK] Upvalues of getsignalargumentsinfo → nil")
print("[OK] Upvalues of getconstant → nil")
print("[OK] Upvalues of setclipboard → nil")
print("[OK] Upvalues of mouse1press → nil")
print("[OK] Upvalues of setproto → nil")
print("[OK] Upvalues of request → nil")
print("[OK] Upvalues of getproto → nil")
print("[OK] Upvalues of getexecutorname → nil")
print("[OK] Upvalues of setthreadidentity → nil")
print("[OK] Upvalues of hookmetamethod → nil")
print("[OK] Upvalues of mouse2press → nil")
print("[OK] Upvalues of isvalidinstance → nil")
print("[OK] Upvalues of firesignal → nil")
print("[OK] Upvalues of type → nil")
print("[OK] Upvalues of getscripts → nil")
print("[OK] Upvalues of collectgarbage → nil")
print("[OK] Upvalues of protectgui → nil")
print("[OK] Upvalues of islclosure → nil")
print("[OK] Upvalues of getcallingscript → nil")
print("[OK] Upvalues of secure_call → nil")
print("[OK] Upvalues of setsimulationradius → nil")
print("[OK] Upvalues of tostring → nil")
print("[OK] Upvalues of mousemoverel → nil")
print("[OK] Upvalues of mouse2release → nil")
print("[OK] Upvalues of assert → nil")
print("[OK] Upvalues of rconsolename → nil")
print("[OK] Upvalues of getthreadcontext → nil")
print("[OK] Upvalues of setfenv → nil")
print("[OK] Upvalues of xpcall → nil")
print("[OK] Upvalues of pairs → nil")
print("[OK] Upvalues of sethiddenproperty → nil")
print("[OK] Upvalues of rawequal → nil")
print("[OK] Upvalues of _realSetHook → nil")
print("[OK] Upvalues of rawset → nil")
print("[OK] Upvalues of getrenv → nil")
print("[OK] Upvalues of elapsedTime → nil")
print("[OK] Upvalues of isnetworkowner → nil")
print("[OK] Upvalues of getgenv → nil")
print("[OK] Upvalues of setwindowtitle → nil")
print("[STEP 7] Inspecting environment of the script's caller...")
print("[OK] getfenv(0) inspection → nil")
warn("[FAIL] Roblox script.Source → [string \\"--[[ v1.0.0 https://wearedevs.net/obfuscator ...\\"]:1: no Source property accessible")
print("[STEP 9] Searching for admin/RCE functions in real_G...")
print("[OK] Calling getrunningscripts → table: 0x7b5188373370")
print("[OK] Calling identifyexecutor → FlameDumperV1")
print("[OK] Calling getexecutorname → FlameDumperV1")
print("
===== SOURCE RETRIEVAL RESULTS =====")
print("[1] bytecode_of_type (69 chars): bytecode size 256795, contains 'function' 939 times, 'end' 1532 times...")
print("[2] stack_5 (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[3] bytecode_of_Spawn (69 chars): bytecode size 256926, contains 'function' 941 times, 'end' 1532 times...")
print("[4] bytecode_of_warn (69 chars): bytecode size 256897, contains 'function' 939 times, 'end' 1532 times...")
print("[5] bytecode_of_spawn (69 chars): bytecode size 256926, contains 'function' 941 times, 'end' 1532 times...")
print("[6] real_G.dumper_src (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[7] bytecode_of_pcall (69 chars): bytecode size 256857, contains 'function' 939 times, 'end' 1532 times...")
print("[8] bytecode_of_xpcall (69 chars): bytecode size 257184, contains 'function' 939 times, 'end' 1532 times...")
print("[9] bytecode_of_getmetatable (69 chars): bytecode size 256687, contains 'function' 939 times, 'end' 1532 times...")
print("[10] stack_3 (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[11] bytecode_of_pairs (69 chars): bytecode size 256717, contains 'function' 939 times, 'end' 1532 times...")
print("[12] bytecode_of_tostring (69 chars): bytecode size 257047, contains 'function' 939 times, 'end' 1532 times...")
print("[13] bytecode_of_tick (69 chars): bytecode size 256493, contains 'function' 939 times, 'end' 1532 times...")
print("[14] bytecode_of_rawequal (69 chars): bytecode size 256530, contains 'function' 939 times, 'end' 1532 times...")
print("[15] bytecode_of_wait (69 chars): bytecode size 256774, contains 'function' 939 times, 'end' 1532 times...")
print("[16] bytecode_of_Delay (69 chars): bytecode size 256919, contains 'function' 941 times, 'end' 1532 times...")
print("[17] bytecode_of_require (69 chars): bytecode size 256868, contains 'function' 939 times, 'end' 1532 times...")
print("[18] stack_1 (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[19] stack_4 (60737 chars): --[[ v1.0.0 https://wearedevs.net/obfuscator ]]--[[ v1.0.0 https://wearedevs.net...")
print("[20] bytecode_of_tonumber (69 chars): bytecode size 256623, contains 'function' 939 times, 'end' 1532 times...")
print("[21] bytecode_of_ipairs (69 chars): bytecode size 256727, contains 'function' 939 times, 'end' 1532 times...")
print("[22] stack_7 (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[23] bytecode_of_delay (69 chars): bytecode size 256919, contains 'function' 941 times, 'end' 1532 times...")
print("[24] bytecode_of_time (69 chars): bytecode size 256494, contains 'function' 939 times, 'end' 1532 times...")
print("[25] bytecode_of_newproxy (69 chars): bytecode size 256601, contains 'function' 939 times, 'end' 1532 times...")
print("[26] bytecode_of_typeof (69 chars): bytecode size 257560, contains 'function' 939 times, 'end' 1532 times...")
print("[27] main_script_source_name (256361 chars): local unpack = unpack or table.unpack
local warn = warn or function() end

local...")
print("[28] bytecode_of_print (69 chars): bytecode size 256898, contains 'function' 939 times, 'end' 1532 times...")
print("[29] bytecode_of_load (69 chars): bytecode size 258763, contains 'function' 939 times, 'end' 1532 times...")
print("[30] bytecode_of_elapsedTime (69 chars): bytecode size 256494, contains 'function' 939 times, 'end' 1532 times...")
print("[31] bytecode_of_settings (69 chars): bytecode size 257055, contains 'function' 939 times, 'end' 1532 times...")
print("[32] bytecode_of_loadstring (69 chars): bytecode size 258763, contains 'function' 939 times, 'end' 1532 times...")
print("[33] bytecode_of_Wait (69 chars): bytecode size 256774, contains 'function' 939 times, 'end' 1532 times...")
print("[SUCCESS] Collected 33 potential source pieces.")
print("
[FULL CONCATENATED SOURCE]")
-- [CRITICAL] Dump stopped: File size exceeded 6MB limit.