local ____lualib = require("lualib_bundle")
local __TS__New = ____lualib.__TS__New
local __TS__ObjectAssign = ____lualib.__TS__ObjectAssign
local __TS__SparseArrayNew = ____lualib.__TS__SparseArrayNew
local __TS__SparseArrayPush = ____lualib.__TS__SparseArrayPush
local __TS__SparseArraySpread = ____lualib.__TS__SparseArraySpread
local __TS__Promise = ____lualib.__TS__Promise
local __TS__AsyncAwaiter = ____lualib.__TS__AsyncAwaiter
local __TS__Await = ____lualib.__TS__Await
local __TS__Number = ____lualib.__TS__Number
local __TS__ArraySlice = ____lualib.__TS__ArraySlice
local __TS__ArrayIncludes = ____lualib.__TS__ArrayIncludes
local __TS__ArrayMap = ____lualib.__TS__ArrayMap
local __TS__PromiseAll = ____lualib.__TS__PromiseAll
local __TS__Iterator = ____lualib.__TS__Iterator
local __TS__InstanceOf = ____lualib.__TS__InstanceOf
local __TS__Spread = ____lualib.__TS__Spread
local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
local __TS__PromiseRace = ____lualib.__TS__PromiseRace
local __TS__ArrayPush = ____lualib.__TS__ArrayPush
local __TS__StringIncludes = ____lualib.__TS__StringIncludes
local ____exports = {}
local ____storyteller = require("code.engine.storyteller")
local ST = ____storyteller.ST
local STAnimation = ____storyteller.STAnimation
local STAtlas = ____storyteller.STAtlas
local STAudio = ____storyteller.STAudio
local STBlend = ____storyteller.STBlend
local STContainer = ____storyteller.STContainer
local STDaemon = ____storyteller.STDaemon
local STFacing = ____storyteller.STFacing
local STFrames = ____storyteller.STFrames
local STHitbox = ____storyteller.STHitbox
local STImage = ____storyteller.STImage
local STPager = ____storyteller.STPager
local STRectangle = ____storyteller.STRectangle
local STSprite = ____storyteller.STSprite
local STText = ____storyteller.STText
local STValue = ____storyteller.STValue
local ____utils = require("code.engine.utils")
local bb_standard = ____utils.bb_standard
local ezecho = ____utils.ezecho
local rainGen = ____utils.rainGen
local standardSplitter = ____utils.standardSplitter
local ____global = require("code.global")
local accessor = ____global.accessor
local random = ____global.random
local ____bloom = require("code.shaders.bloom")
local bloomShader = ____bloom.default
local ____hsv = require("code.shaders.hsv")
local hsvShader = ____hsv.default
local ____outline = require("code.shaders.outline")
local outlineShader = ____outline.default
local ____common = require("code.maps.common")
local commonAreaGen = ____common.commonAreaGen
local commonResourcesGen = ____common.commonResourcesGen
function ____exports.resourcesGen(music, sound)
    local cr = commonResourcesGen(music, sound)
    return {
        daemons = __TS__ObjectAssign(
            {},
            cr.daemons,
            { crickets = __TS__New(STDaemon, "sounds/crickets.ogg", { mixer = sound, loop = true, gain = 0.75 }) }
        ),
        file = "maps/home.json",
        framess = __TS__ObjectAssign(
            {},
            cr.framess,
            {
                door = __TS__New(STFrames, "images/objects/home/door.json", "images/objects/home/door.png"),
                door_side = __TS__New(STFrames, "images/objects/home/door_side.json", "images/objects/home/door_side.png"),
                bed_frame = __TS__New(STFrames, "images/objects/home/bed_frame.json", "images/objects/home/bed_frame.png"),
                broom_box = __TS__New(STFrames, "images/objects/home/broom_box.json", "images/objects/home/broom_box.png"),
                shovel_pot = __TS__New(STFrames, "images/objects/home/shovel_pot.json",
                    "images/objects/home/shovel_pot.png"),
                basket = __TS__New(STFrames, "images/objects/home/basket.json", "images/objects/home/basket.png"),
                fridge = __TS__New(STFrames, "images/objects/home/fridge.json", "images/objects/home/fridge.png"),
                fridge_door = __TS__New(STFrames, "images/objects/home/fridge_door.json",
                    "images/objects/home/fridge_door.png"),
                bed_cover = __TS__New(STFrames, "images/objects/home/bed_cover.json", "images/objects/home/bed_cover.png"),
                fusebox = __TS__New(STFrames, "images/objects/home/fusebox.json", "images/objects/home/fusebox.png"),
                toy = __TS__New(STFrames, "images/objects/home/toy.json", "images/objects/home/toy.png"),
                counter = __TS__New(STFrames, "images/objects/home/counter.json", "images/objects/home/counter.png"),
                counter_extras = __TS__New(STFrames, "images/objects/home/counter_extras.json",
                    "images/objects/home/counter_extras.png"),
                telecomm = __TS__New(STFrames, "images/objects/home/telecomm.json", "images/objects/home/telecomm.png"),
                screwbox = __TS__New(STFrames, "images/objects/home/screwbox.json", "images/objects/home/screwbox.png")
            }
        ),
        images = __TS__ObjectAssign(
            {},
            cr.images,
            {
                desk = __TS__New(STImage, "images/objects/home/desk.png"),
                bed = __TS__New(STImage, "images/objects/home/bed.png"),
                bed_table = __TS__New(STImage, "images/objects/home/bed_table.png"),
                chair = __TS__New(STImage, "images/objects/home/chair.png"),
                dresser = __TS__New(STImage, "images/objects/home/dresser.png"),
                drill = __TS__New(STImage, "images/objects/home/drill.png"),
                mattress = __TS__New(STImage, "images/objects/home/mattress.png"),
                bin = __TS__New(STImage, "images/objects/home/bin.png"),
                entertainment0 = __TS__New(STImage, "images/objects/home/entertainment0.png"),
                entertainment1 = __TS__New(STImage, "images/objects/home/entertainment1.png"),
                entertainment2 = __TS__New(STImage, "images/objects/home/entertainment2.png"),
                lamp = __TS__New(STImage, "images/objects/home/lamp.png"),
                table = __TS__New(STImage, "images/objects/home/table.png"),
                chair_table = __TS__New(STImage, "images/objects/home/chair_table.png"),
                stove = __TS__New(STImage, "images/objects/home/stove.png"),
                board = __TS__New(STImage, "images/objects/home/board.png"),
                nook = __TS__New(STImage, "images/objects/home/nook.png"),
                void_shine1 = __TS__New(STImage, "images/objects/home/void_shine1.png"),
                void_shine2 = __TS__New(STImage, "images/objects/home/void_shine2.png"),
                extrabook = __TS__New(STImage, "images/objects/home/extrabook.png"),
                bowl = __TS__New(STImage, "images/objects/home/bowl.png"),
                night_living0 = __TS__New(STImage, "images/objects/home/night_living0.png"),
                night_living1 = __TS__New(STImage, "images/objects/home/night_living1.png"),
                night_living2 = __TS__New(STImage, "images/objects/home/night_living2.png"),
                night_living3 = __TS__New(STImage, "images/objects/home/night_living3.png"),
                night_living4 = __TS__New(STImage, "images/objects/home/night_living4.png"),
                night_living5 = __TS__New(STImage, "images/objects/home/night_living5.png"),
                night_kitchen0 = __TS__New(STImage, "images/objects/home/night_kitchen0.png"),
                night_kitchen1 = __TS__New(STImage, "images/objects/home/night_kitchen1.png"),
                night_kitchen2 = __TS__New(STImage, "images/objects/home/night_kitchen2.png"),
                night_kitchen3 = __TS__New(STImage, "images/objects/home/night_kitchen3.png"),
                night_kitchen4 = __TS__New(STImage, "images/objects/home/night_kitchen4.png"),
                sippytable = __TS__New(STImage, "images/objects/home/sippytable.png"),
                telescope1 = __TS__New(STImage, "images/objects/home/telescope1.png"),
                telescope2 = __TS__New(STImage, "images/objects/home/telescope2.png"),
                telescope_overlay = __TS__New(STImage, "images/objects/home/telescope_overlay.png"),
                fuseknob = __TS__New(STImage, "images/objects/home/fuseknob.png"),
                fusebox_overlay = __TS__New(STImage, "images/objects/home/fusebox_overlay.png"),
                fusebox_overlay_switch = __TS__New(STImage, "images/objects/home/fusebox_overlay_switch.png"),
                rock = __TS__New(STImage, "images/objects/home/rock.png"),
                powbar = __TS__New(STImage, "images/objects/home/powbar.png"),
                bed_frame_top = __TS__New(STImage, "images/objects/home/bed_frame_top.png"),
                rope = __TS__New(STImage, "images/objects/home/rope.png")
            }
        ),
        sheet = __TS__New(STFrames, "images/maps/home.json", "images/maps/home.png")
    }
end

local function areaGen()
    return commonAreaGen(
        function(____bindingPattern0)
            local sound
            local music
            music = ____bindingPattern0.music
            sound = ____bindingPattern0.sound
            return {
                ["ic$player$right_sit"] = __TS__New(STImage, "images/characters/player/right_sit.png"),
                ["ic$player$right_sit_plush"] = __TS__New(STImage, "images/characters/player/right_sit_plush.png"),
                ["ic$player$slippinjimmy"] = __TS__New(STFrames, "images/characters/player/slippinjimmy.json",
                    "images/characters/player/slippinjimmy.png"),
                ["ic$player$slippinjimmy_plush"] = __TS__New(STFrames, "images/characters/player/slippinjimmy_plush.json",
                    "images/characters/player/slippinjimmy_plush.png"),
                ["m$home"] = __TS__New(STDaemon, "music/home.ogg", { mixer = music, gain = 1, loop = true }),
                ["m$home_full"] = __TS__New(STDaemon, "music/home_full.ogg", { mixer = music, gain = 1, loop = true }),
                ["s$archangel"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/archangel.ogg"),
                    { mixer = sound, gain = 0.25, loop = true }
                ),
                ["s$basketpickup"] = __TS__New(STDaemon, "sounds/basketpickup.ogg", { mixer = sound, gain = 1 }),
                ["s$basketputdown"] = __TS__New(STDaemon, "sounds/basketputdown.ogg", { mixer = sound, gain = 1 }),
                ["s$blankets"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/blankets.ogg"),
                    { mixer = sound, gain = 0.25 }
                ),
                ["s$bowlgrab"] = __TS__New(STDaemon, "sounds/bowlgrab.ogg", { mixer = sound, gain = 1 }),
                ["s$breaker_close"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/breaker_close.ogg"),
                    { mixer = sound, gain = 0.5 }
                ),
                ["s$breaker_navigate"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/breaker_navigate.ogg"),
                    { mixer = sound, gain = 0.2 }
                ),
                ["s$breaker_open"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/breaker_open.ogg"),
                    { mixer = sound, gain = 0.5 }
                ),
                ["s$breaker_switch"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/breaker_switch.ogg"),
                    { mixer = sound, gain = 0.5 }
                ),
                ["s$bucketpickup"] = __TS__New(STDaemon, "sounds/bucketpickup.ogg", { mixer = sound, gain = 0.3 }),
                ["s$bucketputdown"] = __TS__New(STDaemon, "sounds/bucketputdown.ogg", { mixer = sound, gain = 0.7 }),
                ["s$chargethrow"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/chargethrow.ogg"),
                    { mixer = sound, loop = true }
                ),
                ["s$clicky"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/clicky.ogg"),
                    { mixer = sound, gain = 0.5 }
                ),
                ["s$door_close"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/door_close.ogg"),
                    { mixer = sound, gain = 1, rate = 0.9 }
                ),
                ["s$door_open"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/door_open.ogg"),
                    { mixer = sound, gain = 0.23 }
                ),
                ["s$duffellift"] = __TS__New(STDaemon, "sounds/duffellift.ogg", { mixer = sound, gain = 0.75 }),
                ["s$faucet_distant"] = __TS__New(STDaemon, "sounds/faucet_distant.ogg",
                    { mixer = sound, loop = true, gain = 0.3 }),
                ["s$faucet"] = __TS__New(STDaemon, "sounds/faucet.ogg", { mixer = sound, loop = true }),
                ["s$fridge_close"] = __TS__New(STDaemon, "sounds/fridge_close.ogg", { mixer = sound, gain = 0.6 }),
                ["s$fridge_open"] = __TS__New(STDaemon, "sounds/fridge_open.ogg", { mixer = sound, gain = 0.75 }),
                ["s$platformwarble"] = __TS__New(STDaemon, "sounds/platformwarble.ogg", { mixer = sound, gain = 0.5 }),
                ["s$ratchetloop"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/ratchetloop.ogg"),
                    { mixer = sound, gain = 0.6, loop = true }
                ),
                ["s$rockbounce"] = __TS__New(STDaemon, "sounds/rockbounce.ogg", { mixer = sound, gain = 0.8, rate = 1.2 }),
                ["s$shovelchnf"] = __TS__New(STDaemon, "sounds/shovelchnf.ogg", { mixer = sound, gain = 0.35 }),
                ["s$shovelshing"] = __TS__New(STDaemon, "sounds/shovelshing.ogg", { mixer = sound, gain = 0.25 }),
                ["s$spoongrab"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "sounds/spoongrab.ogg"),
                    { mixer = sound }
                ),
                ["s$tripod"] = __TS__New(STDaemon, "sounds/tripod.ogg", { mixer = sound, gain = 0.9, rate = 0.8 }),
                ["v$messenger"] = __TS__New(
                    STDaemon,
                    __TS__New(STAudio, "voices/messenger.ogg"),
                    { mixer = sound, gain = 0.6 }
                )
            }
        end,
        ____exports.resourcesGen
    )
end
local function textGen(pager)
    return {
        item_book = {
            name = "一本书",
            info = function()
                return ({ {
"<p:none>\"The Jensen Paradox, third installment in the Jensen series.\"",
"<p:none>\"How will they escape last time?\""
}, {
"<p:none>\"Surface Tension, the hotel nobody ever leaves.\"",
"<p:none>\"An endless maze of hallways, doors, swimming pools and libraries...\""
}, {
"<p:none>\"Astrae Symphonia, a tale of intrigue, emotion, and music.\"",
"<p:none>\"Follow this rogue starship to the edge of the galaxy!\""
} })[accessor.choice_home_book + 1]
            end
        },
        item_rock = { name = "几块碎石" },
        item_batteries = {
            name = "几节电池",
            info = {
"<p:player>(Type four batteries. Good for small devices and tools.)"
}
        },
        item_cover = {
            name = function() return accessor.item_scissors and "一条床单绳" or "一张床单" end,
            info = function()
                return accessor.item_scissors and ({
"<p:player>(A makeshift \"rope\" made from pieces of a blanket.)"
}) or ({
"<p:player>(A comfortable blanket. Haven't found something to cut it with yet.)"
})
            end
        },
        item_crowbar = {
            name = "一根金属棒",
            info = {
"<p:player>(One bar of pure bed frame.)",
"<p:player><f:sweat4>(It's really heavy.)"
}
        },
        ponder_book = pager:create(0, {
"<p:none>(You ponder why you're still awake.)",
"<p:none>(You realize you don't have a book to read in bed.)"
}, {
"<p:none>(You ponder what kind of book you'd like to read.)",
"<p:none>(You're realize you're in the mood for something novel.)"
}),
        ponder_sleep = {
"<p:none>(You ponder why you're still awake.)",
"<p:none>(You realize you should probably go to bed now.)"
},
        ponder_hello = {
"<p:player>...",
"<p:player>(I don't really know where I am.)",
"<p:player><f:sigh>(Exploring might give me a better idea...)"
},
        ponder_outside = pager:create(
            0,
            {
"<p:player><f:sweat>...",
"<p:player><f:sweat>(This... house... doesn't make any sense.)",
"<p:player><f:confused>(How is it just... floating?)",
"<p:player><f:confused>(Why is there nothing else out there?)",
"<p:player><f:side>(If I could find something to \"test\" this place...)",
"<p:player>(... it might give me a clue how to escape it.)"
},
            function()
                return { "<p:player><f:sweat>(I'm looking for a way to escape.)",
                    "<p:player><f:sweat5>(To do that, I need to know what this place's limits are.)",
                    "<p:player><f:side>(I can't risk walking off the edge myself, so...)", accessor.item_rock and
                "<p:player>(... maybe I could throw those rocks off instead.)" or
                "<p:player>(... maybe I could throw something else off instead.)" }
            end
        ),
        ponder_platform = function()
            return accessor.item_cover and (accessor.item_scissors and ({
"<p:player>(So far, I've cut this blanket and made it into a rope.)",
"<p:player><f:side>(Now, I just need something to hold it in place for the climb...)",
"<p:player>(... something strong and sturdy, like metal.)"
}) or ({
"<p:player>(So far, I've found a blanket, which I can make into a rope.)",
"<p:player><f:sigh>(I still need something to cut it with.)"
})) or ({
"<p:player><f:determined>(I need to find a way down to that platform.)",
"<p:player>(It's too far to jump, so I'll have to try something else.)",
"<p:player><f:side>(A rope would do the trick...)"
})
        end,
        ponder_exit = pager:create(0, {
"<p:player><f:sigh>...",
"<p:player><f:sigh>(It's strange... omething about this house is comfortable.)",
"<p:player><f:side>(In another life, I could see myself living here...)"
}, {
"<p:player>(There's nothing else for me to do here.)",
"<p:player><f:sigh>(It's time to go.)"
}),
        overworld = {
            start1 = "警告",
            start2 =
            "本作讲述了一群可爱的小动物之间的故事。\n在这，你能看到一些真诚暖心的瞬间。\n此外，本作采用了简洁的艺术风格。",
            start3 =
            "如果你是来寻求暴力刺激，惊艳的视觉效果，\n或者哪怕只是一个死亡界面，在本作你就得失望了。",
            tutorial1 = "（按下[↑][↓][←][→]来控制角色移动。）",
            tutorial2 = "按下[Z]来调查物品。",
            tutorial3 = "按[Z]推进对话。",
            tutorial4 = "按[↑][↓]来更改选择。\n按[Z]确认。",
            tutorial5 = "按[C]来开启/关闭菜单。\n{color=0x7f7f7f}试试各个选项能干什么。",
            tutorial6 = "按[X]退出。",
            tutorial7 = "长按[Z], 然后松开来投掷。",
            tutorial8 = "根据提示按下[←][→]来攀爬。",
            blocker1 = {
"<p:none>（太晚了，你待在屋里会安全点。）"
},
            blocker2 = {
"<p:none>（你好像有什么事忘了做。）"
},
            blocker3 = {
"<p:none>Go upstairs and complete the tutorial?"
},
            blocker4 = {
"上楼吧",
"再等等"
},
            blocker5 = {
"<p:none>Go outside and climb down to the golden platform?"
},
            blocker6 = {
"Go Outside",
"Not Yet"
},
            bookshelf1 = {
"<p:none>要拿本书吗？"
},
            bookshelf2 = {
"The Jensen Paradox (Action)",
"Surface Tension (Surreal)",
"Astrae Symphonia (Space)",
"Not Yet"
},
            bookshelf3 = {
"<h:a><p:none>(You got the Book.)"
},
            bookshelf4 = {
"<p:none>（你打算不这么做。）"
},
            hello1 = {
"<p:player><f:sweat>...",
"<p:player><f:sweat>（这好像不是我的床吧。）"
},
            hello2 = {
"<p:player><f:sweat5>(... maybe I slept on the wrong antenna...)"
},
            hello3 = {
"<p:player><f:what>（不对... 这压根就不是我家啊。）",
"<p:player><f:confused>（我咋就来这了？\n难不成... 有人把我绑了？）"
},
            hello4 = {
"<p:player><f:side>(I don't remember being taken...)"
},
            goatplush0 = "Plushie",
            goatplush1 = pager:create(
                0,
                function()
                    return { "<p:player><f:surprise>(Hey, this is MY plushie!)", accessor.plot < 1.1 and
                    "<p:player><f:confused>(Maybe this is my room after all...?)" or
                    "<p:player><f:confused>(... did you follow me here, to this strange place?)", "<p:none>Pick them up?" }
                end,
                {
"<p:none>Pick them up?"
}
            ),
            goatplush2 = {
"Yes",
"No"
},
            goatplush3 = {
"<p:player><f:sigh>Come here, you.",
"<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Plushie.",
"<p:player><f:side>...",
"<p:player>(Maybe I should hold onto this for a while.)"
},
            fusebox1 = function()
                return {
                    "<p:player><f:side>(An electric routing box...)",
                    unpack(accessor.plot < 2 and ({
"<p:player><f:sodesuka>(Maybe I can get main power back on.)"
}) or ({}))
                }
            end,
            fusebox2 = "厨房",
            fusebox3 = "过道",
            fusebox4 = "FAMILY",
            fusebox5 = "卧室",
            fusebox6 = "娱乐中心",
            fusebox7 = "室外",
            fusebox8 = "已通电",
            fusebox9 = "已断电",
            lightswitch = {
"<p:player><f:sigh>(No power.)"
},
            telecomm1 = function()
                return {
                    "<p:player>(A comms device. Must be battery-powered.)",
                    unpack(accessor.plot < 2 and ({
"<p:player><f:confused>(Only two receivers on the contact list...?)"
}) or ({}))
                }
            end,
            telecomm2 = {
"<p:none>What will you do?"
},
            telecomm3a = {
"Call Work",
"Call Neighbors",
"Play Back Message",
"Never Mind"
},
            telecomm3b = {
"Call Work",
"Call Neighbors",
"Never Mind"
},
            telecomm4 = { {
"<p:none>(Calling... Work.)"
}, {
"<p:none>(Calling... Neighbors.)"
} },
            telecomm5 = {
"<p:none>(That Receiver Does Not Exist.)"
},
            telecomm6 = function()
                return {
                    "<p:none>(Beginning Playback...)",
                    "<p:messenger>Jerry's Dabo club, Morn speakin.'",
                    "<p:messenger>... hello? Anyone there?",
                    "<p:messenger>Hmph. Call us back if you'd like to claim your refund.",
                    unpack(accessor.state_home_telecomm_message == 0 and ({
                        "<h:a><p:player><f:annoyed>(Oh. It's just a scam.)",
                        unpack(accessor.event_home_outside and ({
"<p:player><f:sweat5>(I'd delete the message, if it wasn't for the small possibility...)",
"<p:player><f:sweat>(... that this might be the last other person's voice I hear.)"
}) or ({
"<p:player><f:sigh>(Nobody would mind if I deleted this, would they?)",
"<h:b><p:none>(Message Deleted.)"
}))
                    }) or ({}))
                }
            end,
            fridge1 = pager:create(
                0,
                function()
                    return { accessor.plot < 2 and "<p:player><f:sweat4>(You know what? I'm starving...)" or
                    "<p:player><f:sweat3>(Actually, before I go...)", "<p:none>Eat something from the fridge?" }
                end,
                {
"<p:none>Eat something from the fridge?"
}
            ),
            fridge2 = {
"Boka Fruit",
"Tenzka Tracks Ice Cream",
"Morning Leftovers",
"Never Mind"
},
            fridge3 = { {
"<p:player><f:annoyed>(These better be home-grown.)"
}, {
"<p:player><f:surprise>(My favorite food! I must be lucky.)"
}, {
"<p:player>(... it's better than nothing.)"
}, {
"<p:player><f:sweat5>..."
} },
            fridge4 = { {
"<p:player><f:sodesuka>(Huh. Those were actually pretty good.)"
}, {
"<p:player><f:sweat4>(... might've eaten too much.)"
}, {
"<p:player>..."
} },
            fridge5 = function()
                return accessor.plot < 2 and ({
"<p:player><f:sweat>(Oh... right.)",
"<p:player><f:sweat5>(I'm still trying to get out of here.)"
}) or ({
"<p:player>(... time to get back to what I was doing.)"
})
            end,
            outside1 = {
"<p:player><f:what>（什么鬼...）",
"<p:player><f:what>..."
},
            outside2 = {
"<p:player><f:upset2>（这到底什么情况？）",
"<p:player><f:sad>（我... 我究竟在哪？）"
},
            outside3 = {
"<p:player><f:sweat5>（根本望不到边。）",
"<p:player><f:sweat3>（不管往哪儿转，\n我都只能看到...）"
},
            outside4 = {
"<p:player><f:sweat5>（我... 我得想办法离开这儿...）"
},
            telescope1 = {
"<p:player><f:side>（这有台望远镜...）"
},
            telescope2 = {
"<p:player>（兴许我能用它\n在远处看到点什么。）"
},
            basket1a = {
"<p:player>...",
"<h:a><p:player><f:side>(Wait, that box on the bookshelf...)",
"<h:a><p:player><f:surprise>(It's the lockbox from the note!)"
},
            basket1b = {
"<p:player><f:side>(Hm...)"
},
            basket2 = {
"<p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Library Card.",
"<p:player><f:surprise>(There!)"
},
            basket3 = {
"<p:player><f:confused>(A library card...?)"
},
            bucket1 = function()
                return accessor.plot < 3 and
                    (accessor.item_cover and accessor.item_scissors and not accessor.item_crowbar and ({
"<p:player><f:side>(A rusty shovel. I'd use this as an anchor, but...)"
}) or ({
"<p:player><f:side>(A rusty shovel. Looks like it's...)"
})) or ({
"<p:player><f:side>(A rusty shovel...)"
})
            end,
            bucket2 = function()
                return {
                    "<p:player>(Wait.)",
                    unpack(accessor.plot < 2 and ({
"<p:player><f:confused>(What about the pail?)"
}) or ({
"<p:player><f:sigh>(That pail might be come in handy.)"
}))
                }
            end,
            bucket3 = function()
                local ____array_0 = __TS__SparseArrayNew(unpack(accessor.plot < 2 and ({
"<p:player><f:confused>(... how could it be raining when there's nothing else outside?)",
"<p:player><f:side>(Maybe I can learn something by collecting it, and...)",
"<p:player><f:sweat>(Studying it, I guess.)",
"<p:player><f:sigh>(... sounds stupid when I think about it like that, but still.)"
}) or ({
"<p:player>(Just in case.)"
})))
                __TS__SparseArrayPush(____array_0, "<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Pail.")
                return { __TS__SparseArraySpread(____array_0) }
            end,
            bucket4 = {
"<p:player><f:sodesuka>(Don't think I can collect any rain from here.)"
},
            rain1 = {
"<p:player><f:side>..."
},
            rain2 = {
"<p:player><f:side>(That's weird...)",
"<p:player><f:side>(The rain's definitely going inside, but...)",
"<p:player><f:sodesuka>(It's... not filling up.)"
},
            rain3 = {
"<p:player><f:what>(Freaky.)",
"<p:player><f:sigh>(... guess I can't learn anything from this, though.)"
},
            rope1 = function()
                return { "<p:player>（一截麻绳，剩下不多了。）", accessor.plot == 2 and
                "<p:player><f:sigh>(Doubt it's enough to reach the platform, but I'll take it anyway.)" or
                "<p:player><f:sigh>(Still might be useful, though.)",
                    "<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Rope." }
            end,
            rope2 = {
"<p:player><f:sodesuka>(No use for this indoors.)"
},
            dangle1 = {
"<p:player><f:side>(Hm...)"
},
            dangle2 = {
"<p:player><f:sigh>(No, it's nowhere NEAR long enough to get me down there.)"
},
            dangle3 = function()
                return accessor.item_cover and ({
"<p:player>(... the blanket plan will have to do.)"
}) or ({
"<p:player>(... maybe there's something else I could make a rope out of.)"
})
            end,
            drill = {
"<p:player>(A heavy-duty electric drill. Might be useful.)",
"<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Drill.",
"<p:player><f:sigh>(Good thing these batteries were included.)"
},
            drill_tooltip = "Drill",
            broombox1 = {
"<p:player><f:sigh>(A box of old collector's rocks...)",
"<p:player>(... doubt they're important, so instead, I could try throwing them.)",
"<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Rock.",
"<p:player>(Off the edge.)",
"<h:b><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Rock.",
"<p:player>(To see what happens.)",
"<h:c><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Rock."
},
            broombox2 = {
"<p:player><f:sigh>(It's worth a try.)"
},
            broombox3 = {
"<p:player><f:sweat>(Throwing these indoors won't tell me anything.)"
},
            golden1 = {
"<p:player>(... right.)"
},
            golden2 = {
"<p:player><f:sigh>...",
"<h:a><p:player><f:surprise>(Get ready...!)"
},
            golden3 = {
"<p:player><f:sweat3>...",
"<p:player><f:sweat3>(Maybe I didn't throw it far enough.)"
},
            golden4 = {
"<p:player><f:sigh>(Here we go...)",
"<h:a><p:player><f:surprise>(... again!)"
},
            golden5 = {
"<p:player><f:sad>...",
"<p:player><f:sad>(Nothing...)"
},
            golden6 = {
"<p:player><f:sigh>...",
"<p:player><f:sigh>(... what if I just...)"
},
            golden7 = {
"<p:player><f:what>..."
},
            golden8 = {
"<p:player><f:what>(That's new.)"
},
            golden9 = {
"<p:player><f:side>...",
"<p:player><f:side>(Doesn't look like part of the house...)",
"<p:player><f:confused>(Could that be what's behind all of this?)",
"<p:player><f:sweat3>...",
"<p:player><f:sweat3>(Maybe it's silly, but if...)",
"<p:player><f:sweat>(If I could get down there somehow...)"
},
            golden10 = {
"<p:player><f:determined>(... I might just be able to escape!)"
},
            scissors1 = function()
                local ____array_1 = __TS__SparseArrayNew(unpack(accessor.item_cover and ({
"<p:player><f:surprise>(Scissors! For the blanket!)"
}) or ({
"<p:player><f:side>(Scissors...)",
"<p:player>(Could be good to have these on hand.)"
})))
                __TS__SparseArrayPush(
                    ____array_1,
                    "<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Scissors.",
                    unpack(accessor.item_cover and ({
"<p:player><f:sweat4>(Sorry, little blanket...)"
}) or ({}))
                )
                return { __TS__SparseArraySpread(____array_1) }
            end,
            scissors2 = function()
                return {
                    "<p:player><f:side>(... that's that taken care of...)",
                    unpack(accessor.item_crowbar and ({
"<p:player><f:surprise>(Oh! And I can use the bed frame as an anchor!)"
}) or ({
"<p:player><f:sweat>(Now I need something to anchor the \"rope\" to once I'm outside.)"
}))
                }
            end,
            bed1 = {
"<p:player><f:side>(The bed...)",
"<p:player><f:sweat5>(... no...)"
},
            bed2 = function()
                return {
                    "<p:player><f:surprise>(The covers!)",
                    "<p:player><f:side>(If I cut the blanket into pieces, I can tie those together...)",
                    "<p:player><f:surprise>(... and make a rope out of it!)",
                    "<h:a><p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Blanket.",
                    unpack(accessor.item_scissors and ({
"<p:player><f:sweat4>(Sorry, little blanket...)"
}) or ({}))
                }
            end,
            bed3 = function()
                return not accessor.item_scissors and ({
"<p:player><f:sweat>(I'll need something to cut it with, though.)"
}) or (not accessor.item_crowbar and ({
"<p:player><f:sweat>(Now I need something to anchor the \"rope\" to once I'm outside.)"
}) or ({
"<p:player><f:surprise>(Oh! And I can use the bed frame as an anchor!)"
}))
            end,
            framer1 = function()
                return {
                    "<p:player><f:side>(A metal bed frame. I wonder if I could take it apart...)",
                    unpack(accessor.item_drill and ({
"<p:player>(... the drill should do nicely!)"
}) or ({
"<p:player>(... not by hand, that's for sure.)"
}))
                }
            end,
            framer2 = function()
                return {
                    "<p:none>{color=0xa289dc}Dysu{color=0xffffff} got the Metal Bar.",
                    unpack(accessor.item_cover and accessor.item_scissors and ({
"<p:player><f:side>..."
}) or ({
"<p:player><f:surprise>(Nice!)"
}))
                }
            end,
            framer3 = {
"<p:player><f:surprise>(... wait! That's it!)",
"<p:player><f:side>(I'll attach the \"rope\" to the bar, place it behind the doorway...)",
"<p:player><f:determined2>(... and climb my way down to the platform!)"
},
            done1 = {
"<p:player><f:side>(I'll attach the \"rope\" to it, place it behind the doorway...)",
"<p:player><f:determined2>(... and climb my way down to the platform!)"
},
            done2 = {
"<p:player><f:sweat5>(About time...)"
},
            exit1 = {
"<p:player><f:side>(Well, that should do it...)"
},
            exit2 = {
"<p:player><f:sweat>(Don't look down.)"
},
            exit3 = {
"<p:player><f:surprise>... I made it! I'm here!",
"<h:a><p:player><f:side>I'm actually..."
},
            exit4 = {
"<p:player><f:what>(What the-)"
}
        },
        trivia = {
            window = function()
                return accessor.plot < 1 and ({
"<p:none>(You peer through the window, observing the outdoor nightlife.)"
}) or (accessor.plot < 2 and (not accessor.event_home_outside and ({
"<p:player><f:side>(That's weird...)",
"<p:player>(... can't see anything out there.)"
}) or ({
"<p:player><f:sweat>..."
})) or ({
"<p:player><f:determined>..."
}))
            end,
            bed = function()
                return not accessor.item_cover and ({
"<p:player><f:sweat4>(A surprisingly comfortable bed.)"
}) or (accessor.plot < 3 and ({
"<p:player><f:sweat4>(Probably not as comfortable anymore.)"
}) or ({
"<p:player>(A bed.)"
}))
            end,
            computer = function()
                return {
                    "<p:player>(A computer.)",
                    unpack(not accessor.event_home_outside and ({
"<p:player><f:sigh>(The neural input looks worn out. Must have seen a lot of use.)"
}) or (accessor.plot < 3 and ({
"<p:player><f:sigh>(Without any power, it's just a box.)"
}) or ({})))
                }
            end,
            chair = function()
                return accessor.plot < 3 and ({
"<p:player>(Just a chair.)"
}) or ({
"<p:player><f:sigh>(Despite everything, it's still just a chair.)"
})
            end,
            dresser1 = function()
                return accessor.plot < 2 and ({
"<p:player>(Lots of toys and trinkets in these drawers.)"
}) or (accessor.plot < 3 and ({
"<p:player><f:sigh>(Now's not the time for souvenirs.)"
}) or ({
"<p:player><f:sigh>(Toys and trinkets.)"
}))
            end,
            dresser2 = function()
                return accessor.plot < 2 and ({
"<p:player>(Nothing but antenna warmers in these drawers.)"
}) or (accessor.plot < 3 and ({
"<p:player><f:sigh>(Antenna warmers won't help me reach the platform.)"
}) or ({
"<p:player><f:sigh>(Antenna warmers.)"
}))
            end,
            book = function()
                return accessor.plot < 3 and ({ ({
"<p:player><f:side>(\"The Jensen Paradox...\")",
"<p:player><f:side>(\"Surface Tension...\")",
"<p:player><f:side>(\"Astrae Symphonia...\")"
})[accessor.choice_home_book + 1], accessor.plot < 2 and "<p:player>(Not a bad choice.)" or "<p:player><f:sweat>(... part of this story might be coming true.)" }) or
                    ({ {
"<p:player>(\"The Jensen Paradox.\")"
}, {
"<p:player>(\"Surface Tension.\")"
}, {
"<p:player>(\"Astrae Symphonia.\")"
} })[accessor.choice_home_book + 1]
            end,
            cutetunnel = function()
                return accessor.plot < 2 and ({
"<p:player>(Painting of a wild arkette staring down a corridor.)"
}) or ({
"<p:player><f:sigh>(... you and me both, little arkette.)"
})
            end,
            toy = function()
                return accessor.plot < 2 and ({
"<p:player><f:confused>(A perpetual motion toy?)",
"<p:player><f:sodesuka>(Wonder how long it's been going...)"
}) or (accessor.plot < 3 and ({
"<p:player><f:confused>(Wait, wasn't this toy doing something earlier?)"
}) or ({
"<p:player>(A simple toy.)"
}))
            end,
            plant = function()
                return {
                    "<p:player>(Baby boka tree.)",
                    unpack(accessor.plot < 2 and ({
"<p:player><f:sweat3>(Seems like it's almost ready to be planted...)"
}) or (accessor.plot < 3 and ({
"<p:player><f:sigh>(Shame there's nowhere to plant this.)"
}) or ({})))
                }
            end,
            shovel = function()
                return accessor.item_bucket and ({
"<p:player><f:sigh>(A rusty shovel with a great big hole in it.)"
}) or
                    (accessor.plot < 3 and (accessor.item_cover and accessor.item_scissors and not accessor.item_crowbar and ({
"<p:player><f:side>(A rusty shovel. I'd use this as an anchor...)",
"<p:player><f:sweat>(... if it wasn't such a piece of junk.)"
}) or ({
"<p:player>(A rusty shovel. Looks like it's about to fall apart.)"
})) or ({
"<p:player>(Useless shovel.)"
}))
            end,
            broombox = function()
                return accessor.item_rock and ({
"<p:player><f:sigh>(An old broom with a broken handle.)"
}) or ({
"<p:player>(An old broom and some fancy rocks. The broom's handle is broken.)"
})
            end,
            dresserdrawer1 = {
"<p:player><f:sigh>(An empty dresser drawer.)"
},
            dresserdrawer2 = {
"<p:player><f:sigh>(An empty dresser drawer. It's stuck open.)"
},
            dresserpaper = function()
                return {
                    "<p:player>\"After much deliberation, we have come to an agreement.\"",
                    "<p:player>\"For your continued effort, a promotion is in order.\"",
                    "<p:player>\"Accept it at any time by bringing this envelope to work with you.\"",
                    "<p:player>\"Sincerely, the board.\"",
                    accessor.plot < 3 and "<p:player><f:side>..." or "<p:player><f:sigh>..."
                }
            end,
            mattress = function()
                return accessor.plot < 3 and ({
"<p:player><f:sigh>(Don't think this mattress has ever been slept on.)"
}) or ({
"<p:player>(Unused mattress.)"
})
            end,
            bin = {
"<p:player>(An empty bin with a cleaning towel draped over the side.)"
},
            bedframe = function()
                return accessor.plot < 2 and ({
"<p:player>(A metal bed frame. The most dangerous object in the universe.)"
}) or ({
"<p:player>(A metal bed frame, with one side removed.)",
"<p:player><f:sweat3>(If anything, this makes it MORE dangerous...)"
})
            end,
            fusebox = {
"<p:none>（配电箱发出了微弱的电流声。）"
},
            lightswitch = {
"<p:none>（电灯开关。）"
},
            lamp = function()
                return accessor.plot < 1 and ({
"<p:none>（你偏爱黑暗的魅力，\n因此不想开灯。）"
}) or ({
                    "<p:player>(A lamp.)",
                    unpack(accessor.plot < 3 and ({
"<p:player><f:sigh>（...不常用的东西呢。）"
}) or ({}))
                })
            end,
            telescope = function()
                return accessor.plot < 1 and ({
"<p:none>（一个望远镜收纳袋，还没打开过。\n那台望远镜，你总有一天用得上。）"
}) or ({
"<p:player><f:side>（套着袋子的望远镜。\n太可惜了...）"
})
            end,
            bookshelf = function()
                return accessor.plot < 1 and ({
"<p:none>（对你而言，\n书籍才是虚构故事的\n理想载体。）"
}) or (not accessor.event_home_secret and ({
"<p:player><f:what>（这个书架真不错，\n我感觉我能看上一阵子...）"
}) or (accessor.event_home_bookshelf < 1 and ({
"<p:player><f:side>（上面有个坏掉的保险箱，好...）"
}) or (accessor.event_home_bookshelf < 2 and ({
"<p:player><f:sigh>（箱子太高了，我够不着。）"
}) or ({
"<p:player>（通往阅读的大门，\n从各种意义上来说。）"
}))))
            end,
            couch = function()
                return accessor.plot < 1 and ({
"<p:none>（沙发。你想着自己会不会\n又在这里睡着。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sweat5>（有人在这沙发上睡过觉，\n没错吧？）"
}) or ({
"<p:player><f:confused>（我从高处跳到沙发上\n会不会摔死呢？）",
"<p:player><f:sweat>（...不行，太冒险了。）"
}))
            end,
            entertainment = function()
                return accessor.plot < 1 and ({
"<p:none>（家庭娱乐中心，\n每个家庭的标配。）"
}) or (accessor.plot < 2 and ({
"<p:player>（豪华版家庭娱乐中心。）"
}) or ({
"<p:player>（家庭娱乐中心。）"
}))
            end,
            SIPPY = function()
                return accessor.plot < 1 and ({
"<p:none>（一套从本地二手店\n淘来的杯子。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sweat3>（怪怪的杯子，装着...\n外星液体什么的？）",
"<p:player><f:sweat>（很难说里面是什么。）"
}) or ({
"<p:player><f:sigh>（还是别碰这些为妙。）"
}))
            end,
            basket = function()
                return accessor.plot < 1 and ({
"<p:none>（一个空篮子。）",
"<p:none>（你肯定把你最好的朋友\n落在楼上了。）"
}) or
                    (accessor.item_goatplush and ({ "<p:player><f:side>(Somehow, I'm tempted to put the plushie in this basket...)", accessor.floof and "<p:player><f:sweat4>(... of course, I'd still rather keep it on my head.)" or "<p:player><f:sweat4>(... of course, I'd still rather keep it with me.)" }) or ({
"<p:player>（这里是不是少了些什么。）"
}))
            end,
            flipbasket = {
"<p:player><f:sodesuka>（篮子变成了临时脚凳。）"
},
            telecomm = {
"<p:none>（便携通讯器。收到一条新消息。）",
"<p:none>（等清醒些了再看吧。）"
},
            diningchair1 = function()
                return accessor.plot < 1 and ({
"<p:none>（你的餐椅。）"
}) or (accessor.plot < 2 and ({
"<p:player>（不过是张普通的餐椅。）"
}) or ({
"<p:player><f:sigh>（无论发生什么，\n它始终是张餐椅。）"
}))
            end,
            diningchair2 = function()
                return accessor.plot < 1 and ({
"<p:none>（餐椅。这个屋子里就只有\n这里能摆它了。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sigh>（...这张餐椅有股\n说不出的古怪。）"
}) or ({
"<p:player>（这东西根本\n不该出现在这里。）"
}))
            end,
            sink = function()
                return accessor.plot < 1 and ({
"<p:none>（漏水的水龙头。\n得尽快修好才行。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sweat5>（要是这是在我家里，\n我当场就修好了。）"
}) or ({
"<p:player><f:sweat3>（水不流了...）"
}))
            end,
            jars = function()
                return accessor.plot < 1 and ({
"<p:none>（装着高级料理香料的罐子，\n塞得满满当当。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sweat>（陌生人的香料罐千万别乱开，\n这可是血淋淋的教训。）"
}) or ({
"<p:player>（香料罐。）"
}))
            end,
            plate = function()
                return accessor.plot < 1 and ({
"<p:none>（此生仅需这一只餐盘足矣。）"
}) or (accessor.plot < 2 and ({
"<p:player>（餐盘。应该是一整套里的\n某一只。）"
}) or ({
"<p:player>（餐盘。）"
}))
            end,
            silverware = function()
                return accessor.plot < 1 and ({
"<p:none>（厨具三件套。\n现在还没必要换。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:sodesuka>（这些厨具有股复古风...）"
}) or ({
"<p:player>（基础款厨具。）"
}))
            end,
            behindfridge = function()
                return accessor.plot < 1 and ({
"<p:none>（碗碟塔。\n你从没用过它们。）"
}) or (accessor.plot < 2 and ({
"<p:player>（刚沥干水的餐具堆。）"
}) or ({
"<p:player>（洁净如新的碗碟。）"
}))
            end,
            fridge = function()
                return accessor.plot < 1 and ({
"<p:none>（冰箱。要不是这个点了\n你高低找些吃的。）"
}) or ({
"<p:player><f:sweat4>（擅自吃绑匪家的食物\n应该...没问题吧？）"
})
            end,
            stove = function()
                return accessor.plot < 1 and ({
"<p:none>（镭射微波双模烹饪台，\n光洁得能照出人影。）"
}) or (accessor.plot < 2 and ({
"<p:player><f:side>（这台激光灶九成新...）",
"<p:player><f:sodesuka>（看来厨房引爆专家\n不止我一个呢。）"
}) or ({
"<p:player><f:sodesuka>（分子料理级灶台。）"
}))
            end,
            bowl_extra = function()
                return accessor.event_home_food and ({
"<p:player><f:sigh>（只是空碗而已。）"
}) or ({})
            end,
            rope = {
"<p:none>（一截老麻绳，\n用了好些年了。）"
},
            scissors = {
"<p:none>（剪绳专用银剪刀。）"
},
            pantry = function()
                return accessor.plot < 1 and ({
"<p:none>（食品柜。囤了这么多粮食，\n世界末日来了\n你也能镇定自若。）"
}) or (accessor.plot < 2 and ({
"<p:player>(Pantry food. My worst nightmare.)"
}) or ({
"<p:player>（真空包装的永恒保质期。）"
}))
            end,
            board = function()
                return accessor.plot < 1 and ({
"<p:none>（你想着，这块板放这儿挺好。）"
}) or ({
                    "<p:player>(A large piece of wood.)",
                    unpack(accessor.plot < 2 and ({
"<p:player><f:side>（像是能从餐桌边缘\n咔嗒一声伸出来的\n活动板...）"
}) or ({}))
                })
            end,
            secret = function()
                local ____temp_3
                if accessor.plot < 1 then
                    ____temp_3 = {
"<p:none>（钉满重要便签的软木板。）"
}
                else
                    local ____array_2 = __TS__SparseArrayNew(unpack(not accessor.event_home_secret and ({
"<p:player><f:side>（板子上订着一系列便签...）"
}) or ({})))
                    __TS__SparseArrayPush(
                        ____array_2,
                        "<p:player>(\"Plant boka tree tomorrow\")",
                        "<p:player>(\"Download new entertainment center programs\")",
                        "<p:player>(\"Fix broken lockbox\")",
                        unpack(not accessor.event_home_secret and
                            ({ "<p:player><f:confused>(Wait. A lockbox?)", accessor.event_home_bookshelf == 0.1 and "<p:player><f:side>(I swear there was a box like that in the living room somewhere...)" or "<p:player><f:confused>(Was there a lockbox around here somewhere?)" }) or
                            (accessor.event_home_bookshelf < 1 and ({
"<p:player><f:sigh>(... still haven't found the lockbox.)"
}) or (accessor.event_home_bookshelf < 2 and ({
"<p:player><f:sweat5>(... I've found the lockbox, but I can't reach it...)"
}) or ({
"<p:player><f:sodesuka>(... weird how a library card needed a locked box.)"
}))))
                    )
                    ____temp_3 = { __TS__SparseArraySpread(____array_2) }
                end
                return ____temp_3
            end
        },
        trivia_tooltip = {
            window = "一扇窗",
            bed = "一张床",
            computer = "一台电脑",
            chair = "一把椅子",
            dresser1 = "一个衣物收纳柜",
            dresser2 = "一个衣物收纳柜",
            book = "一本书",
            cutetunnel = "一幅画",
            toy = "一个玩具",
            plant = "一株盆栽",
            shovel = "一把铁锹",
            broombox = "一只积满灰的盒子",
            dresserdrawer1 = "一个衣物收纳柜",
            dresserdrawer2 = "一个衣物收纳柜",
            dresserpaper = "一封信",
            mattress = "一张床垫",
            bin = "一个箱子",
            bedframe = "一张床架",
            fusebox = "一个配电箱",
            lightswitch = "一个电灯开关",
            lamp = "一盏灯",
            telescope = "一个望远镜收纳袋",
            bookshelf = "一个书架",
            couch = "一张沙发",
            entertainment = "一个娱乐中心",
            SIPPY = "几只杯子",
            basket = "一个篮筐",
            flipbasket = "Flipped Basket",
            telecomm = "一台无线电",
            diningchair1 = "一把餐椅",
            diningchair2 = "一把餐椅",
            sink = "一个洗碗槽",
            jars = "几只罐子",
            plate = "一个餐盘",
            silverware = "几把银餐具",
            behindfridge = "几个餐盘和几只碗",
            fridge = "一台冰箱",
            stove = "一台激光灶",
            bowl_extra = "一只碗",
            rope = "一截麻绳",
            scissors = "一把剪刀",
            pantry = "一个食品柜",
            board = "Leaflet",
            secret = "Tackboard"
        }
    }
end
function ____exports.default()
    local state
    local ____areaGen_result_4 = areaGen()
    local activators = ____areaGen_result_4.activators
    local hide = ____areaGen_result_4.hide
    local hintGen = ____areaGen_result_4.hintGen
    local map = ____areaGen_result_4.map
    local overworld = ____areaGen_result_4.overworld
    local resources = ____areaGen_result_4.resources
    local reveal = ____areaGen_result_4.reveal
    local pstop = ____areaGen_result_4.pstop
    local shaderSetup = ____areaGen_result_4.shaderSetup
    local stepSFX = ____areaGen_result_4.stepSFX
    local temp = ____areaGen_result_4.temp
    local tooltip = ____areaGen_result_4.tooltip
    local unfailer = ____areaGen_result_4.unfailer
    local ____overworld_5 = overworld
    local assets = ____overworld_5.assets
    local atlas = ____overworld_5.atlas.atlas
    local save = ____overworld_5.atlas.save
    local save_hooks = ____overworld_5.atlas.save_hooks
    local batch = ____overworld_5.batch
    local game = ____overworld_5.game
    local inputs = ____overworld_5.inputs
    local items = ____overworld_5.inventory.items
    local update = ____overworld_5.inventory.update
    local player = ____overworld_5.player.player
    local player_move = ____overworld_5.player.player_move
    local player_walk = ____overworld_5.player.player_walk
    local reader = ____overworld_5.reader.reader
    local object = ____overworld_5.screen.object
    local objects = ____overworld_5.screen.objects
    local screen = ____overworld_5.screen.screen
    local ____resources_6 = resources
    local daemons = ____resources_6.daemons
    local framess = ____resources_6.framess
    local images = ____resources_6.images
    local pager = __TS__New(
        STPager,
        random,
        ST:decode(accessor.pager_home)
    )
    local text = textGen(pager)
    local function hintDialogue()
        return __TS__New(
            __TS__Promise,
            function(____, resolve)
                ST:when(function()
                    if atlas.target == "reader" and reader.next_task ~= nil then
                        local hint2 = hintGen(text.overworld.tutorial3, 2, 60)
                        local ____self_7 = reader.next_task
                        ____self_7["then"](
                            ____self_7,
                            function()
                                hint2()
                                resolve(nil)
                            end
                        )
                        return true
                    end
                    return false
                end)
            end
        )
    end
    local function hintInter()
        return __TS__New(
            __TS__Promise,
            function(____, resolve)
                local hint1 = hintGen(text.overworld.tutorial2, 1, 360)
                ST:when(function()
                    if atlas.target == "reader" and not state.blocker then
                        hint1()
                        resolve(nil)
                        return true
                    end
                    return false
                end)
            end
        )
    end
    local function trans2(r, x, y)
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            game.cutscene = game.cutscene + 1
            local fader = __TS__New(STRectangle, {
                alpha = 0,
                color = 0,
                size = { x = 240, y = 180 },
                anchor = 0.5,
                priority = 1000
            })
            screen:attach(fader)
            for ____, inst in ipairs(assets["s$faucet"].instances) do
                state.faucet_time = inst.position.value
                local ____self_8 = inst.gain:automate(7, 0)
                ____self_8["then"](
                    ____self_8,
                    function()
                        inst:stop()
                    end
                )
            end
            for ____, inst in ipairs(assets["s$faucet_distant"].instances) do
                state.faucet_time = inst.position.value
                local ____self_9 = inst.gain:automate(7, 0)
                ____self_9["then"](
                    ____self_9,
                    function()
                        inst:stop()
                    end
                )
            end
            __TS__Await(fader.alpha:automate(7, 1))
            player.position.x = __TS__Number(x)
            player.position.y = __TS__Number(y)
            game.cutscene = game.cutscene - 1
            local ____opt_10 = map.task
            if ____opt_10 ~= nil then
                ____opt_10.complete(r)
            end
            local ____self_12 = fader.alpha:automate(7, 0)
            ____self_12["then"](
                ____self_12,
                function()
                    screen:detach(fader)
                end
            )
        end)
    end
    local function trans3(r, x, y, tag)
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            pstop()
            local door = object(tag).self
            if door.frame == 0 then
                door.frame = 1
                assets["s$door_open"]:instance()
            end
            door.metadata.lock = true
            __TS__Await(trans2(r, x, y))
            __TS__Await(ST:pause(4))
            local meta = object("doorcontrol").self.metadata
            if meta.lock then
                return ____awaiter_resolve(nil)
            end
            meta.lock = true
            assets["s$door_close"]:instance()
        end)
    end
    local function trivia(key)
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            local entry = text.trivia[key]
            __TS__Await(reader:text(type(entry) == "function" and entry() or entry))
        end)
    end
    state = { blocker = false, faucet_time = 0, mapcolor = { hue = 0, saturation = 1, value = 1 } }
    local scripts = {
        trans = function(test, args)
            local ____opt_13 = map.task
            if ____opt_13 ~= nil then
                ____opt_13.complete(__TS__Number(args[1]))
            end
        end,
        trans2 = function(test, args)
            trans2(
                __TS__Number(args[1]),
                __TS__Number(args[2]),
                __TS__Number(args[3])
            )
        end,
        trans3 = function(test, args)
            trans3(
                __TS__Number(args[1]),
                __TS__Number(args[2]),
                __TS__Number(args[3]),
                args[4]
            )
        end,
        trans4 = function(test, args)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                local meta = object("doorcontrol").self.metadata
                if meta.lock then
                    assets["s$door_open"]:instance()
                else
                    meta.lock = true
                end
                __TS__Await(trans2(
                    __TS__Number(args[1]),
                    __TS__Number(args[2]),
                    __TS__Number(args[3])
                ))
                local door = object(args[4]).self
                door.frame = 1
                local ____self_15 = ST:pause(4)
                __TS__Await(____self_15["then"](
                    ____self_15,
                    function()
                        if door.metadata.lock then
                            return
                        end
                        door.frame = 0
                        assets["s$door_close"]:instance()
                    end
                ))
            end)
        end,
        trivia = function(test, args)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if not (text.trivia[args[1]] ~= nil) then
                    return ____awaiter_resolve(nil)
                end
                local facings = __TS__ArraySlice(args, 1)
                if #facings == 0 or __TS__ArrayIncludes(facings, player.stance) then
                    if test then
                        if text.trivia_tooltip[args[1]] ~= nil then
                            tooltip(text.trivia_tooltip[args[1]])
                        end
                        return ____awaiter_resolve(nil)
                    end
                    __TS__Await(trivia(args[1]))
                end
            end)
        end,
        stairs = function(test, args)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if player.position.x < __TS__Number(args[1]) or player.position.x > __TS__Number(args[2]) then
                    return ____awaiter_resolve(nil)
                end
                if game.c_left or game.c_right then
                    if accessor.plot < 0.4 then
                        pstop()
                        state.blocker = true
                        __TS__Await(reader:text(text.overworld.blocker2))
                        state.blocker = false
                        return ____awaiter_resolve(nil)
                    elseif accessor.plot < 1 then
                        game.cutscene = game.cutscene + 1
                        pstop()
                        state.blocker = true
                        __TS__Await(reader:text(text.overworld.blocker3))
                        state.blocker = false
                        __TS__Await(reader:choice(text.overworld.blocker4))
                        if game.r_choice == 1 then
                            game.cutscene = game.cutscene - 1
                            return ____awaiter_resolve(nil)
                        end
                        accessor.plot = 1
                        local fd = __TS__New(STRectangle, {
                            alpha = 0,
                            priority = 1000,
                            color = 0,
                            size = { x = 240, y = 180 },
                            anchor = 0.5
                        })
                        screen:attach(fd)
                        local cinst = daemons.crickets.instances
                        local ____array_16 = __TS__SparseArrayNew(
                            fd.alpha:automate(90, 1),
                            unpack(__TS__ArrayMap(
                                cinst,
                                function(____, instance)
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        __TS__Await(instance.gain:automate(90, 0))
                                    end)
                                end
                            ))
                        )
                        __TS__SparseArrayPush(
                            ____array_16,
                            unpack(__TS__ArrayMap(
                                assets["s$faucet_distant"].instances,
                                function(____, instance)
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        __TS__Await(instance.gain:automate(90, 0))
                                        instance:stop()
                                    end)
                                end
                            ))
                        )
                        __TS__Await(__TS__PromiseAll({ __TS__SparseArraySpread(____array_16) }))
                        local up
                        up = function()
                            map:removeUpdater(up)
                            map.autoplay = false
                        end
                        map:addUpdater(up)
                        local ____opt_17 = map.task
                        if ____opt_17 ~= nil then
                            ____opt_17.complete(0)
                        end
                        player.alpha.value = 0
                        state.mapcolor.saturation = 1
                        state.mapcolor.value = 1
                        player.stance = "down"
                        update()
                        __TS__Await(ST:pause(30))
                        assets["s$awaken"]:instance()
                        local fd2 = __TS__New(STRectangle, {
                            alpha = 0,
                            color = 12500670,
                            priority = 1001,
                            size = { x = 240, y = 180 },
                            anchor = 0.5
                        })
                        screen:attach(fd2)
                        __TS__Await(fd2.alpha:automate(150, 1))
                        screen:detach(fd)
                        for ____, obj in __TS__Iterator(objects("night")) do
                            obj:destroy()
                        end
                        local spr = __TS__New(STAnimation, {
                            position = { x = 28, y = 109 },
                            anchor = { x = 0.5, y = 1 },
                            frames = assets["ic$player$sleep"],
                            priority = 103,
                            color = 10652124
                        })
                        map:attach(spr)
                        local cover = object("cover").self
                        cover.frame = 1
                        map:play(map.rooms[1].score)
                        map.music.gain.value = 0
                        map.music.gain:automate(7, 1)
                        __TS__Await(fd2.alpha:automate(150, 0))
                        screen:detach(fd2)
                        __TS__Await(ST:pause(60))
                        spr.frame = 1
                        __TS__Await(ST:pause(45))
                        __TS__Await(reader:text(text.overworld.hello1))
                        __TS__Await(ST:pause(30))
                        assets["s$blankets"]:instance()
                        __TS__Await(ST:pause(1))
                        map:detach(spr)
                        player.alpha.value = 1
                        player.position.x = 30
                        player.position.y = 130
                        cover.frame = 0
                        __TS__Await(player_walk(0.5, { y = 140 }))
                        __TS__Await(ST:pause(45))
                        __TS__Await(reader:text(text.overworld.hello2))
                        game.cutscene = game.cutscene - 1
                        return ____awaiter_resolve(nil)
                    end
                    local lx = player.metadata.last_x
                    local ly = player.metadata.last_y
                    player_move(-lx, -ly)
                    local hitboxes = { __TS__Spread(screen:scan(function(container)
                        return __TS__InstanceOf(container,
                            STHitbox) and type(container.metadata) == "table" and container.metadata.scan == true
                    end)) }
                    player_move(
                        lx,
                        ly + lx,
                        false,
                        false,
                        __TS__ArrayFilter(
                            hitboxes,
                            function(____, hitbox)
                                if hitbox.metadata.obstacle == true and hitbox.metadata.walkable ~= true then
                                    hitbox:calculate()
                                    return true
                                end
                                return false
                            end
                        ),
                        __TS__ArrayFilter(
                            hitboxes,
                            function(____, hitbox)
                                if hitbox.metadata.obstacle == true and hitbox.metadata.walkable == true then
                                    hitbox:calculate()
                                    return true
                                end
                                return false
                            end
                        )
                    )
                end
            end)
        end,
        drilltable = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if not accessor.item_drill then
                    if test then
                        tooltip(text.overworld.drill_tooltip)
                        return ____awaiter_resolve(nil)
                    end
                    accessor.item_drill = true
                    update()
                    local ____reader_headers_21 = reader.headers
                    ____reader_headers_21[#____reader_headers_21 + 1] = {
                        "a",
                        function()
                            assets["s$itemget"]:instance()
                            local ____opt_19 = object("driller")
                            if ____opt_19 ~= nil then
                                ____opt_19:destroy()
                            end
                        end
                    }
                    __TS__Await(reader:text(text.overworld.drill))
                end
            end)
        end,
        shovelpot = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.shovel)
                    return ____awaiter_resolve(nil)
                end
                if accessor.event_home_outside and not accessor.item_bucket then
                    accessor.item_bucket = true
                    update()
                    game.cutscene = game.cutscene + 1
                    __TS__Await(reader:text(text.overworld.bucket1()))
                    __TS__Await(ST:pause(30))
                    __TS__Await(reader:text(text.overworld.bucket2()))
                    __TS__Await(ST:pause(20))
                    local anim = object("harry").self
                    anim.frame = 1
                    assets["s$shovelshing"]:instance()
                    __TS__Await(ST:pause(40))
                    anim.frame = 2
                    assets["s$shovelchnf"]:instance()
                    __TS__Await(ST:pause(60))
                    local ____reader_headers_24 = reader.headers
                    ____reader_headers_24[#____reader_headers_24 + 1] = {
                        "a",
                        function()
                            assets["s$itemget"]:instance()
                            anim.frame = 3
                            local ____opt_22 = object("bucketbox1")
                            if ____opt_22 ~= nil then
                                ____opt_22:destroy()
                            end
                            local bb2 = object("bucketbox2").self
                            bb2.position.y = bb2.metadata.y
                        end
                    }
                    __TS__Await(reader:text(text.overworld.bucket3()))
                    game.cutscene = game.cutscene - 1
                else
                    trivia("shovel")
                end
            end)
        end,
        broombox = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.broombox)
                    return ____awaiter_resolve(nil)
                end
                if accessor.event_home_outside and not accessor.item_rock then
                    game.cutscene = game.cutscene + 1
                    accessor.item_rock = true
                    update()
                    local anim = object("SWEEPSWEEPSWEEP").self
                    local ____reader_headers_25 = reader.headers
                    ____reader_headers_25[#____reader_headers_25 + 1] = {
                        "a",
                        function()
                            assets["s$itemget"]:instance()
                            anim.frame = 1
                        end
                    }
                    local ____reader_headers_26 = reader.headers
                    ____reader_headers_26[#____reader_headers_26 + 1] = {
                        "b",
                        function()
                            assets["s$itemget"]:instance()
                            anim.frame = 2
                        end
                    }
                    local ____reader_headers_27 = reader.headers
                    ____reader_headers_27[#____reader_headers_27 + 1] = {
                        "c",
                        function()
                            assets["s$itemget"]:instance()
                            anim.frame = 3
                        end
                    }
                    __TS__Await(reader:text(text.overworld.broombox1))
                    __TS__Await(ST:pause(45))
                    __TS__Await(reader:text(text.overworld.broombox2))
                    game.cutscene = game.cutscene - 1
                else
                    trivia("broombox")
                end
            end)
        end,
        bedframe = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.bedframe)
                    return ____awaiter_resolve(nil)
                end
                if 2 <= accessor.plot and not accessor.item_crowbar then
                    game.cutscene = game.cutscene + 1
                    local can = accessor.item_drill
                    if can then
                        accessor.item_crowbar = true
                        update()
                    end
                    __TS__Await(reader:text(text.overworld.framer1()))
                    if not can then
                        game.cutscene = game.cutscene - 1
                        return ____awaiter_resolve(nil)
                    end
                    __TS__Await(ST:pause(25))
                    if player.position.x > 30 then
                        __TS__Await(player_walk(1.5, { x = 30 }))
                    end
                    if player.position.y < 95 then
                        __TS__Await(player_walk(1.5, { y = 80 }))
                    else
                        __TS__Await(player_walk(1.5, { y = 115 }))
                    end
                    if player.position.x < 30 then
                        __TS__Await(player_walk(1.5, { x = 30 }))
                    else
                        player.stance = "right"
                    end
                    __TS__Await(ST:pause(30))
                    bb_standard(player, assets["ie$surprise"])
                    assets["s$driller"]:instance()
                    __TS__Await(ST:pause(45))
                    if player.position.y < 95 then
                        __TS__Await(player_walk(1.5, { y = 115 }))
                    else
                        __TS__Await(player_walk(1.5, { y = 80 }))
                    end
                    player.stance = "right"
                    __TS__Await(ST:pause(20))
                    bb_standard(player, assets["ie$surprise"])
                    assets["s$driller"]:instance()
                    __TS__Await(ST:pause(35))
                    __TS__Await(player_walk(1.5, { y = 95 }))
                    player.stance = "right"
                    __TS__Await(ST:pause(25))
                    assets["s$itemget"]:instance()
                    local ____opt_28 = object("framebox")
                    if ____opt_28 ~= nil then
                        ____opt_28:destroy()
                    end
                    object("rogerrabbit").self.frame = 1
                    __TS__Await(reader:text(text.overworld.framer2()))
                    if accessor.item_cover and accessor.item_scissors then
                        __TS__Await(ST:pause(30))
                        __TS__Await(reader:text(text.overworld.framer3))
                        __TS__Await(ST:pause(15))
                        __TS__Await(bb_standard(player, assets["ie$note"]))
                        __TS__Await(ST:pause(15))
                        __TS__Await(reader:text(text.overworld.done2))
                        accessor.plot = 3
                    end
                    game.cutscene = game.cutscene - 1
                else
                    trivia("bedframe")
                end
            end)
        end,
        goatplush = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.item_goatplush then
                    return ____awaiter_resolve(nil)
                end
                if test then
                    tooltip(text.overworld.goatplush0)
                    return ____awaiter_resolve(nil)
                end
                __TS__Await(reader:text(text.overworld.goatplush1("overworld/goatplush1")))
                __TS__Await(reader:choice(text.overworld.goatplush2))
                if game.r_choice == 1 then
                    return ____awaiter_resolve(nil)
                end
                accessor.item_goatplush = true
                update()
                local ____reader_headers_34 = reader.headers
                ____reader_headers_34[#____reader_headers_34 + 1] = {
                    "a",
                    function()
                        assets["s$itemget"]:instance()
                        local ____opt_30 = object("goatplush")
                        if ____opt_30 ~= nil then
                            ____opt_30:destroy()
                        end
                        local ____opt_32 = object("goatplush")
                        if ____opt_32 ~= nil then
                            ____opt_32:destroy()
                        end
                    end
                }
                __TS__Await(reader:text(text.overworld.goatplush3))
            end)
        end,
        basket = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.basket)
                    return ____awaiter_resolve(nil)
                end
                if not accessor.event_home_secret then
                    trivia("basket")
                else
                    game.cutscene = game.cutscene + 1
                    local early = accessor.event_home_bookshelf < 1
                    accessor.event_home_bookshelf = 2
                    update()
                    if early then
                        local ____reader_headers_35 = reader.headers
                        ____reader_headers_35[#____reader_headers_35 + 1] = {
                            "a",
                            function()
                                player.stance = "left"
                            end
                        }
                    end
                    __TS__Await(reader:text(early and text.overworld.basket1a or text.overworld.basket1b))
                    __TS__Await(ST:pause(45))
                    if player.position.x < 125 then
                        player.stance = "right"
                    else
                        player.stance = "up"
                    end
                    __TS__Await(ST:pause(25))
                    local ____opt_36 = object("basket")
                    if ____opt_36 ~= nil then
                        ____opt_36:destroy()
                    end
                    local ____opt_38 = object("basket")
                    if ____opt_38 ~= nil then
                        ____opt_38:destroy()
                    end
                    assets["s$basketpickup"]:instance()
                    __TS__Await(ST:pause(30))
                    if math.abs(player.position.y - 85) > 6 then
                        __TS__Await(player_walk(1.5, { y = 85 }))
                    end
                    __TS__Await(player_walk(1.5, { x = 105 }))
                    __TS__Await(ST:pause(15))
                    reveal("flipbasket")
                    assets["s$basketputdown"]:instance()
                    __TS__Await(ST:pause(45))
                    local y = player.position.y
                    __TS__Await(player.position:step(1, { x = 88, y = 72 }))
                    __TS__Await(ST:pause(10))
                    player.stance = "up"
                    __TS__Await(ST:pause(20))
                    object("screwbox").self.frame = 1
                    assets["s$itemget"]:instance()
                    __TS__Await(reader:text(text.overworld.basket2))
                    __TS__Await(ST:pause(20))
                    player.stance = "right"
                    __TS__Await(ST:pause(30))
                    __TS__Await(player.position:step(1, { x = 105, y = y }))
                    __TS__Await(ST:pause(45))
                    player.stance = "down"
                    __TS__Await(reader:text(text.overworld.basket3))
                    game.cutscene = game.cutscene - 1
                end
            end)
        end,
        fridge = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if player.stance ~= "left" then
                    return ____awaiter_resolve(nil)
                end
                if test then
                    tooltip(text.trivia_tooltip.fridge)
                    return ____awaiter_resolve(nil)
                end
                if not accessor.event_home_food and 1 <= accessor.plot then
                    game.cutscene = game.cutscene + 1
                    __TS__Await(reader:text(text.overworld.fridge1("overworld/fridge1")))
                    __TS__Await(reader:choice(text.overworld.fridge2))
                    if game.r_choice ~= 3 then
                        accessor.event_home_food = true
                        accessor.choice_home_food = game.r_choice
                    end
                    __TS__Await(reader:text(text.overworld.fridge3[game.r_choice + 1]))
                    if game.r_choice == 3 then
                        game.cutscene = game.cutscene - 1
                        return ____awaiter_resolve(nil)
                    end
                    __TS__Await(player_walk(1.5, { y = 125 }, { x = 45 }))
                    player.stance = "left"
                    local dory = object("cold").self
                    assets["s$fridge_open"]:instance()
                    local ____self_40 = ST:pause(2)
                    ____self_40["then"](
                        ____self_40,
                        function()
                            dory.frame = 1
                        end
                    )
                    __TS__Await(ST:pause(45))
                    __TS__Await(player_walk(1.5, { y = 77 }, { x = 39 }))
                    __TS__Await(ST:pause(15))
                    local counter = object("counter")
                    counter.self.frame = 1
                    assets["s$bowlgrab"]:instance()
                    __TS__Await(ST:pause(15))
                    __TS__Await(player_walk(1.5, { y = 91 }, { x = 36 }))
                    __TS__Await(ST:pause(15))
                    assets["s$spoongrab"]:instance()
                    local ____self_41 = ST:pause(3)
                    ____self_41["then"](
                        ____self_41,
                        function()
                            counter:destroy()
                        end
                    )
                    __TS__Await(ST:pause(45))
                    __TS__Await(player_walk(1.5, { x = 45 }, { y = 125 }))
                    player.stance = "left"
                    __TS__Await(ST:pause(30))
                    assets["s$fridge_close"]:instance()
                    local ____self_42 = ST:pause(3)
                    ____self_42["then"](
                        ____self_42,
                        function()
                            dory.frame = 0
                        end
                    )
                    __TS__Await(ST:pause(30))
                    player_walk(1.5, { y = 175 }, { x = 114 })
                    __TS__Await(ST:pause(45))
                    local fd = __TS__New(STRectangle, {
                        alpha = 0,
                        color = 0,
                        size = { x = 240, y = 180 },
                        anchor = 0.5,
                        priority = 1000
                    })
                    screen:attach(fd)
                    __TS__Await(__TS__PromiseAll({
                        fd.alpha:automate(30, 1),
                        __TS__ArrayMap(
                            daemons.thunder.instances,
                            function(____, inst) return inst.gain:automate(30, 0) end
                        )
                    }))
                    player_walk()
                    __TS__Await(ST:pause(90))
                    player.alpha.value = 0
                    local spr = __TS__New(STSprite, {
                        position = { x = 115, y = 162 },
                        anchor = { x = 0.5, y = 1 },
                        image = accessor.floof and assets["ic$player$right_sit_plush"] or assets["ic$player$right_sit"],
                        priority = 180,
                        color = 10652124
                    })
                    map:attach(spr)
                    object("bowl").self.alpha.value = 1
                    __TS__Await(__TS__PromiseAll({
                        fd.alpha:automate(30, 0),
                        __TS__ArrayMap(
                            daemons.crickets.instances,
                            function(____, inst) return inst.gain:automate(30, 1) end
                        )
                    }))
                    screen:detach(fd)
                    __TS__Await(ST:pause(60))
                    __TS__Await(reader:text(text.overworld.fridge4[game.r_choice + 1]))
                    __TS__Await(ST:pause(15))
                    map:detach(spr)
                    player.alpha.value = 1
                    __TS__Await(player_walk(1.5, { y = 185 }, { x = 90 }))
                    __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                    __TS__Await(ST:pause(45))
                    __TS__Await(reader:text(text.overworld.fridge5()))
                    game.cutscene = game.cutscene - 1
                else
                    trivia("fridge")
                end
            end)
        end,
        bookshelf = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if player.stance ~= "up" then
                    return ____awaiter_resolve(nil)
                end
                if test then
                    tooltip(text.trivia_tooltip.bookshelf)
                    return ____awaiter_resolve(nil)
                end
                if accessor.plot < 0.4 then
                    game.cutscene = game.cutscene + 1
                    __TS__Await(reader:text(text.overworld.bookshelf1))
                    local ____accessor_tutorial_choice_43
                    if accessor.tutorial_choice then
                        ____accessor_tutorial_choice_43 = nil
                    else
                        ____accessor_tutorial_choice_43 = hintGen(text.overworld.tutorial4, 3, 240, 0)
                    end
                    local hint1 = ____accessor_tutorial_choice_43
                    __TS__Await(reader:choice(text.overworld.bookshelf2))
                    if hint1 ~= nil then
                        hint1()
                    end
                    if game.r_choice ~= 3 then
                        accessor.plot = 0.4
                        accessor.choice_home_book = game.r_choice
                        update()
                        if math.abs(player.position.x - 113) > 6 then
                            __TS__Await(player_walk(1.5, { x = 113 }))
                            player.stance = "up"
                        end
                        local ____reader_headers_48 = reader.headers
                        ____reader_headers_48[#____reader_headers_48 + 1] = {
                            "a",
                            function()
                                assets["s$itemget"]:instance()
                                local ____opt_46 = object("extrabook")
                                if ____opt_46 ~= nil then
                                    ____opt_46:destroy()
                                end
                            end
                        }
                    end
                    if game.r_choice == 3 then
                        __TS__Await(reader:text(text.overworld.bookshelf4))
                        accessor.tutorial_choice = true
                        game.cutscene = game.cutscene - 1
                        return ____awaiter_resolve(nil)
                    end
                    __TS__Await(reader:text(text.overworld.bookshelf3))
                    local hint2 = hintGen(text.overworld.tutorial5, 0, 15)
                    local downListener1
                    downListener1 = function()
                        return __TS__AsyncAwaiter(function(____awaiter_resolve)
                            inputs.tertiary:removeDown(downListener1)
                            hint2()
                            atlas:switch("menu")
                            game.cutscene = game.cutscene - 1
                        end)
                    end
                    inputs.tertiary:addDown(downListener1)
                else
                    trivia("bookshelf")
                    if not accessor.event_home_secret then
                        accessor.event_home_bookshelf = 0.1
                    elseif accessor.event_home_bookshelf < 1 then
                        accessor.event_home_bookshelf = 1
                    end
                end
            end)
        end,
        scissors = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.plot < 1 then
                    if test then
                        tooltip(text.trivia_tooltip.scissors)
                        return ____awaiter_resolve(nil)
                    end
                    trivia("scissors")
                elseif not accessor.item_scissors then
                    if test then
                        tooltip(text.trivia_tooltip.scissors)
                        return ____awaiter_resolve(nil)
                    end
                    game.cutscene = game.cutscene + 1
                    accessor.item_scissors = true
                    update()
                    local ____reader_headers_49 = reader.headers
                    ____reader_headers_49[#____reader_headers_49 + 1] = {
                        "a",
                        function()
                            assets["s$itemget"]:instance()
                            object("hot").self.frame = accessor.item_rope and 3 or 1
                        end
                    }
                    __TS__Await(reader:text(text.overworld.scissors1()))
                    if accessor.item_cover then
                        player.stance = "up"
                        bb_standard(player, assets["ie$ellipsis"])
                        assets["s$scissors"]:instance()
                        __TS__Await(ST:pause(75))
                        local ____reader_51 = reader
                        local ____reader_text_52 = reader.text
                        local ____array_50 = __TS__SparseArrayNew(unpack(text.overworld.scissors2()))
                        __TS__SparseArrayPush(
                            ____array_50,
                            unpack(accessor.item_crowbar and text.overworld.done1 or ({}))
                        )
                        __TS__Await(____reader_text_52(
                            ____reader_51,
                            { __TS__SparseArraySpread(____array_50) }
                        ))
                        if accessor.item_crowbar then
                            __TS__Await(ST:pause(15))
                            __TS__Await(bb_standard(player, assets["ie$note"]))
                            __TS__Await(ST:pause(15))
                            __TS__Await(reader:text(text.overworld.done2))
                            accessor.plot = 3
                        end
                    end
                    game.cutscene = game.cutscene - 1
                end
            end)
        end,
        behindstove = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.secret)
                    return ____awaiter_resolve(nil)
                end
                __TS__Await(trivia("secret"))
                if 1 <= accessor.plot and not accessor.event_home_secret then
                    accessor.event_home_secret = true
                end
            end)
        end,
        outside = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.plot < 1 or accessor.plot == 3 then
                    pstop()
                    local door = object("door4").self
                    local ____door_metadata_53, ____inter_54 = door.metadata, "inter"
                    if ____door_metadata_53[____inter_54] == nil then
                        ____door_metadata_53[____inter_54] = 0
                    end
                    local ____door_metadata_55, ____inter_56 = door.metadata, "inter"
                    local ____door_metadata_inter_57 = ____door_metadata_55[____inter_56] + 1
                    ____door_metadata_55[____inter_56] = ____door_metadata_inter_57
                    local inter = ____door_metadata_inter_57
                    if door.frame == 0 then
                        door.frame = 1
                        assets["s$door_open"]:instance()
                    end
                    state.blocker = true
                    if accessor.plot < 1 then
                        __TS__Await(reader:text(text.overworld.blocker1))
                    else
                        __TS__Await(reader:text(text.overworld.blocker5))
                        __TS__Await(reader:choice(text.overworld.blocker6))
                        if game.r_choice == 0 then
                            state.blocker = false
                            game.cutscene = game.cutscene + 1
                            accessor.plot = 3.1
                            local fd = __TS__New(STRectangle, {
                                alpha = 0,
                                size = { x = 240, y = 180 },
                                anchor = 0.5,
                                color = 0,
                                priority = 1000
                            })
                            screen:attach(fd)
                            __TS__Await(fd.alpha:automate(15, 1))
                            __TS__Await(ST:pause(75))
                            player.position.x = 45
                            player.position.y = 110
                            player.stance = "down"
                            local ____opt_58 = map.task
                            if ____opt_58 ~= nil then
                                ____opt_58.complete(7)
                            end
                            local roper = __TS__New(STSprite,
                                { image = images.rope, position = { y = 103 }, priority = 125 })
                            map:attach(roper)
                            __TS__Await(fd.alpha:automate(15, 0))
                            screen:detach(fd)
                            __TS__Await(ST:pause(60))
                            local ____reader_headers_60 = reader.headers
                            ____reader_headers_60[#____reader_headers_60 + 1] = {
                                "a",
                                function()
                                    player.stance = "left"
                                    return "left"
                                end
                            }
                            __TS__Await(reader:text(text.overworld.exit1))
                            __TS__Await(ST:pause(45))
                            __TS__Await(player_walk(1, { y = 135 }, { x = 51 }))
                            __TS__Await(ST:pause(30))
                            __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                            __TS__Await(ST:pause(15))
                            __TS__Await(reader:text(text.overworld.exit2))
                            __TS__Await(ST:pause(45))
                            __TS__Await(player_walk(0.5, { y = 145 }))
                            player.alpha.value = 0
                            local diff = player.position.y - 150
                            local climber = __TS__New(STAnimation, {
                                anchor = { x = 0.5, y = 1 },
                                priority = 500,
                                color = 10652124,
                                frames = accessor.floof and assets["ic$player$slippinjimmy_plush"] or
                                    assets["ic$player$slippinjimmy"],
                                position = { x = 50.5, y = 150 }
                            }):addTicker(function(self)
                                player.position.y = self.position.y + diff
                            end)
                            map:attach(climber)
                            assets["s$step_carpet"]:instance({ rate = 1.5 })
                            local htext = __TS__New(STText,
                                {
                                    anchor = 0.5,
                                    font = assets["f$helloplayer"],
                                    color = 8355711,
                                    content = text
                                        .overworld.tutorial8
                                })
                            local circler = __TS__New(STSprite,
                                { alpha = 0, image = images.jusant_circle, anchor = 0.5, metadata = 0 }):addTicker(function(
                                self)
                                self.position.x = (self.position.x + self.metadata * 2) / 3
                            end)
                            local jusant = __TS__New(STSprite, {
                                alpha = 0,
                                anchor = 0.5,
                                image = images.jusant,
                                position = { y = 60 },
                                priority = 1000,
                                children = { htext, circler }
                            }):addDrawer(batch.drawer)
                            local side = -1
                            local grabbing = 0
                            local sticky = false
                            screen:attach(jusant)
                            jusant.alpha:automate(15, 0.75)
                            __TS__Await(__TS__New(
                                __TS__Promise,
                                function(____, resolve)
                                    jusant:addTicker(function(self)
                                        if side == 2 then
                                            return
                                        end
                                        local step = 0
                                        if side == -1 then
                                            if inputs.left.held then
                                                side = 0
                                                circler.position.x = 80
                                            elseif inputs.right.held then
                                                side = 1
                                                circler.position.x = -80
                                            else
                                                return
                                            end
                                            grabbing = 1
                                            step = 1
                                            circler.alpha:automate(7, 1)
                                            local ____self_61 = htext.alpha:automate(7, 0)
                                            ____self_61["then"](
                                                ____self_61,
                                                function()
                                                    jusant:detach(htext)
                                                end
                                            )
                                        end
                                        repeat
                                            local ____switch210 = grabbing
                                            local ____cond210 = ____switch210 == 0
                                            if ____cond210 then
                                                if side == 0 then
                                                    if inputs.left.held then
                                                        grabbing = 1
                                                        step = 1
                                                        if inputs.right.held then
                                                            sticky = true
                                                        end
                                                    end
                                                elseif inputs.right.held then
                                                    grabbing = 1
                                                    step = 1
                                                    if inputs.left.held then
                                                        sticky = true
                                                    end
                                                end
                                                break
                                            end
                                            ____cond210 = ____cond210 or ____switch210 == 1
                                            if ____cond210 then
                                                if side == 0 then
                                                    if not inputs.left.held then
                                                        grabbing = 0
                                                        step = -1
                                                        sticky = false
                                                    elseif inputs.right.held then
                                                        if not sticky then
                                                            grabbing = 2
                                                            step = 1
                                                        end
                                                    elseif sticky then
                                                        sticky = false
                                                    end
                                                elseif not inputs.right.held then
                                                    grabbing = 0
                                                    step = -1
                                                    sticky = false
                                                elseif inputs.left.held then
                                                    if not sticky then
                                                        grabbing = 2
                                                        step = 1
                                                    end
                                                elseif sticky then
                                                    sticky = false
                                                end
                                                break
                                            end
                                            ____cond210 = ____cond210 or ____switch210 == 2
                                            if ____cond210 then
                                                if side == 0 then
                                                    if not inputs.left.held then
                                                        side = 1
                                                        if inputs.right.held then
                                                            grabbing = 1
                                                            step = 1
                                                        else
                                                            grabbing = 0
                                                        end
                                                    end
                                                elseif not inputs.right.held then
                                                    side = 0
                                                    if inputs.left.held then
                                                        grabbing = 1
                                                        step = 1
                                                    else
                                                        grabbing = 0
                                                    end
                                                end
                                                break
                                            end
                                        until true
                                        repeat
                                            local ____switch232 = grabbing
                                            local ____cond232 = ____switch232 == 0
                                            if ____cond232 then
                                                circler.metadata = side == 0 and 80 or -80
                                                circler.scale.x = side == 0 and -1 or 1
                                                circler.color.red = 255
                                                circler.color.green = 255
                                                circler.color.blue = 255
                                                break
                                            end
                                            ____cond232 = ____cond232 or ____switch232 == 1
                                            if ____cond232 then
                                                circler.metadata = side == 0 and 0 or 0
                                                circler.scale.x = side == 0 and 1 or -1
                                                if sticky then
                                                    circler.color.red = 127
                                                    circler.color.green = 127
                                                    circler.color.blue = 127
                                                else
                                                    circler.color.red = 255
                                                    circler.color.green = 255
                                                    circler.color.blue = 255
                                                end
                                                break
                                            end
                                            ____cond232 = ____cond232 or ____switch232 == 2
                                            if ____cond232 then
                                                circler.metadata = side == 0 and -80 or 80
                                                circler.scale.x = side == 0 and -1 or 1
                                                circler.color.red = 127
                                                circler.color.green = 127
                                                circler.color.blue = 127
                                                break
                                            end
                                        until true
                                        if step ~= 0 then
                                            local ____climber_position_62, ____y_63 = climber.position, "y"
                                            ____climber_position_62[____y_63] = ____climber_position_62[____y_63] +
                                                step * 2
                                            if grabbing ~= 2 then
                                                climber.frame = 1 - climber.frame
                                            end
                                            assets["s$step_carpet"]:instance({ rate = 1.5 })
                                            if 330 <= climber.position.y then
                                                side = 2
                                                resolve(nil)
                                            end
                                        end
                                    end)
                                end
                            ))
                            local ____self_64 = jusant.alpha:automate(15, 0)
                            ____self_64["then"](
                                ____self_64,
                                function()
                                    screen:detach(jusant)
                                end
                            )
                            climber.gravity.y = 0.25
                            __TS__Await(ST:when(function() return 348 <= climber.position.y end))
                            map:detach(climber)
                            player.position.x = 51
                            player.position.y = 350
                            player.stance = "up"
                            player.alpha.value = 1
                            assets["s$step_glass"]:instance()
                            __TS__Await(ST:pause(45))
                            local ____reader_headers_65 = reader.headers
                            ____reader_headers_65[#____reader_headers_65 + 1] = {
                                "a",
                                function()
                                    player.stance = "down"
                                    return "down"
                                end
                            }
                            __TS__Await(reader:text(text.overworld.exit3))
                            local golden = object("golden").self
                            golden.direction = 1
                            golden:addTicker(function(self)
                                return function()
                                    if self.frame == 23 then
                                        self.frame = 14
                                    end
                                end
                            end)
                            __TS__Await(ST:pause(30))
                            assets["s$platformwarble"]:instance()
                            __TS__Await(bb_standard(player, assets["ie$confused"]))
                            __TS__Await(ST:pause(13))
                            local opt = {
                                threshold = 0,
                                intensity = 0,
                                xsamples = 1,
                                ysamples = 1,
                                limit = 1,
                                bleed = 0,
                                absorb = 0,
                                enabled = function() return accessor["$option_shaders"] ~= 0 end
                            }
                            local bloom = bloomShader(opt)
                            map:addDrawer(bloom.drawer)
                            local sh = 0
                            local flip = false
                            local cam = map:cam_clamped()
                            map.camera = cam
                            map:cam_free()
                            local camY = cam.y
                            local myY = camY
                            local intensity = __TS__New(STValue)
                            local function screenTicker()
                                opt.intensity = intensity.value * 3
                                opt.ysamples = 1 + math.floor(intensity.value * 7 + 0.5) * 2
                                local cyc = ST:bezier(intensity.value, 5, 1, 1)
                                sh = sh + 1
                                if cyc <= sh then
                                    sh = 0
                                    if flip then
                                        flip = false
                                        myY = camY - intensity.value * 3
                                    else
                                        flip = true
                                        myY = camY + intensity.value * 3
                                    end
                                end
                                cam.y = (cam.y + myY * 3) / 4
                            end
                            screen:addTicker(screenTicker)
                            fd.color.red = 190
                            fd.color.green = 190
                            fd.color.blue = 190
                            screen:attach(fd)
                            local ____self_66 = ST:pause(2)
                            local ____self_66_then_result_68 = ____self_66["then"](
                                ____self_66,
                                function()
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        player.stance = "left"
                                        __TS__Await(ST:pause(30))
                                        player.stance = "right"
                                        __TS__Await(ST:pause(45))
                                        player.stance = "down"
                                        __TS__Await(ST:pause(60))
                                        reader:text(text.overworld.exit4)
                                    end)
                                end
                            )
                            local ____self_67 = ST:pause(110)
                            __TS__Await(__TS__PromiseAll({
                                ____self_66_then_result_68,
                                ____self_67["then"](
                                    ____self_67,
                                    function()
                                        assets["s$warp_in"]:instance_forced()
                                    end
                                ),
                                fd.alpha:automate(200, 0, 1),
                                intensity:automate(200, 1),
                                unpack(__TS__ArrayMap(
                                    assets["m$home_full"].instances,
                                    function(____, inst)
                                        return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                            __TS__Await(inst.gain:automate(150, 0))
                                            inst:stop()
                                        end)
                                    end
                                ))
                            }))
                            bloom:release()
                            accessor.location_map = "redleaf"
                            accessor.location_idx = 0
                            accessor.location_pos_x = 60
                            accessor.location_pos_y = 130
                            accessor.location_stance = "right"
                            local ____opt_69 = map.task
                            if ____opt_69 ~= nil then
                                ____opt_69.complete(nil)
                            end
                            return ____awaiter_resolve(nil)
                        end
                    end
                    state.blocker = false
                    __TS__Await(ST:pause(4))
                    if door.frame == 1 and door.metadata.inter == inter then
                        door.frame = 0
                        assets["s$door_close"]:instance()
                    end
                else
                    trans3(7, 10, 100, "door4")
                end
            end)
        end,
        telecomm = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.telecomm)
                    return ____awaiter_resolve(nil)
                end
                if 1 <= accessor.plot then
                    game.cutscene = game.cutscene + 1
                    if not accessor.event_home_telecomm then
                        accessor.event_home_telecomm = true
                        __TS__Await(reader:text(text.overworld.telecomm1()))
                        __TS__Await(ST:pause(15))
                    end
                    local anim = object("telecomm").self
                    anim.direction = 0
                    anim.frame = 1
                    assets["s$beep_power"]:instance()
                    __TS__Await(reader:text(text.overworld.telecomm2))
                    local deleted = accessor.state_home_telecomm_message == 2
                    __TS__Await(reader:choice(deleted and text.overworld.telecomm3b or text.overworld.telecomm3a))
                    if game.r_choice == (deleted and 2 or 3) then
                        if accessor.state_home_telecomm_message ~= 2 then
                            anim.direction = 1
                            anim.frame = 0
                        else
                            anim.direction = 0
                            anim.duration = 0
                            anim.frame = 0
                            anim.step = 0
                        end
                        game.cutscene = game.cutscene - 1
                        return ____awaiter_resolve(nil)
                    end
                    if game.r_choice ~= 2 then
                        anim.direction = 1
                        anim.duration = 2
                        anim.frame = 0
                        anim.step = 0
                        local c = assets["s$archangel"]:instance_forced()
                        __TS__Await(reader:text(text.overworld.telecomm4[game.r_choice + 1]))
                        __TS__Await(ST:pause(90))
                        anim.direction = 0
                        anim.duration = 0
                        anim.frame = 0
                        anim.step = 0
                        c:stop()
                        assets["s$noise"]:instance()
                        __TS__Await(reader:text(text.overworld.telecomm5))
                    else
                        anim.direction = 1
                        anim.duration = 4
                        anim.frame = 0
                        anim.step = 0
                        local ____reader_headers_71 = reader.headers
                        ____reader_headers_71[#____reader_headers_71 + 1] = {
                            "a",
                            function()
                                anim.direction = 0
                                anim.duration = 0
                                anim.frame = 0
                                anim.step = 0
                            end
                        }
                        if accessor.state_home_telecomm_message == 0 and not accessor.event_home_outside then
                            local ____reader_headers_72 = reader.headers
                            ____reader_headers_72[#____reader_headers_72 + 1] = {
                                "b",
                                function()
                                    assets["s$beep_error"]:instance()
                                end
                            }
                        end
                        __TS__Await(reader:text(text.overworld.telecomm6()))
                        if accessor.state_home_telecomm_message == 0 then
                            accessor.state_home_telecomm_message = accessor.event_home_outside and 1 or 2
                        end
                    end
                    if accessor.state_home_telecomm_message ~= 2 then
                        anim.direction = 1
                        anim.frame = 0
                    end
                    game.cutscene = game.cutscene - 1
                else
                    trivia("telecomm")
                end
            end)
        end,
        lightswitch = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.lightswitch)
                    return ____awaiter_resolve(nil)
                end
                if 1 <= accessor.plot then
                    game.cutscene = game.cutscene + 1
                    assets["s$clicky"]:instance()
                    __TS__Await(ST:pause(30))
                    __TS__Await(reader:text(text.overworld.lightswitch))
                    game.cutscene = game.cutscene - 1
                else
                    trivia("lightswitch")
                end
            end)
        end,
        telescope = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.event_home_telescope and player.stance ~= "up" then
                    return ____awaiter_resolve(nil)
                end
                if test then
                    tooltip(text.trivia_tooltip.telescope)
                    return ____awaiter_resolve(nil)
                end
                if accessor.event_home_outside then
                    game.cutscene = game.cutscene + 1
                    if not accessor.event_home_telescope then
                        accessor.event_home_telescope = true
                        __TS__Await(reader:text(text.overworld.telescope1))
                        __TS__Await(ST:pause(15))
                        local ____opt_73 = object("telescope")
                        if ____opt_73 ~= nil then
                            ____opt_73:destroy()
                        end
                        local ____opt_75 = object("telescope")
                        if ____opt_75 ~= nil then
                            ____opt_75:destroy()
                        end
                        assets["s$duffellift"]:instance()
                        __TS__Await(ST:pause(30))
                        __TS__Await(player_walk(1.5, { y = 80 }, { x = 50 }))
                        __TS__Await(ST:pause(15))
                        player.stance = "up"
                        __TS__Await(ST:pause(15))
                        reveal("tscope2")
                        assets["s$tripod"]:instance()
                        __TS__Await(ST:pause(30))
                        __TS__Await(reader:text(text.overworld.telescope2))
                    end
                    local done = false
                    local fd = __TS__New(STRectangle, {
                        alpha = 0,
                        size = { x = 240, y = 180 },
                        anchor = 0.5,
                        color = 0,
                        priority = 1001
                    })
                    screen:attach(fd)
                    __TS__Await(fd.alpha:automate(7, 1))
                    local overlay = __TS__New(STSprite, {
                        image = images.telescope_overlay,
                        anchor = 0.5,
                        position = { x = accessor.state_home_telescope_x, y = accessor.state_home_telescope_y },
                        metadata = nil,
                        priority = 1
                    }):addTicker(function(self)
                        if done then
                            return
                        end
                        local x = self.position.x
                        local y = self.position.y
                        if inputs.up.held then
                            self.position.y = math.max(self.position.y - 2, -75)
                        elseif inputs.down.held then
                            self.position.y = math.min(self.position.y + 2, 75)
                        end
                        if inputs.left.held then
                            self.position.x = math.max(self.position.x - 2, -105)
                        elseif inputs.right.held then
                            self.position.x = math.min(self.position.x + 2, 105)
                        end
                        local m = x ~= self.position.x or y ~= self.position.y
                        if self.metadata == nil then
                            if m then
                                self.metadata = assets["s$ratchetloop"]:instance_forced({ gain = 0.5, rate = 0.8 })
                            end
                        elseif not m then
                            self.metadata:stop()
                            self.metadata = nil
                        end
                    end)
                    local out = outlineShader({ color = { red = 0, green = 0, blue = 0 }, alpha = 0.75, thickness = 1 })
                    local voidpsr = __TS__New(
                        STSprite,
                        {
                            image = images.void,
                            anchor = 0.5,
                            children = {
                                rainGen(),
                                overlay,
                                __TS__New(STText, {
                                    priority = 2,
                                    anchor = 0.5,
                                    position = { y = 80 },
                                    font = assets["f$helloplayer"],
                                    alpha = 0.75,
                                    content = text.overworld.tutorial6
                                }):addDrawer(out.drawer)
                            },
                            priority = 1000
                        }
                    )
                    screen:attach(voidpsr)
                    __TS__Await(fd.alpha:automate(7, 0))
                    screen:detach(fd)
                    __TS__Await(__TS__New(
                        __TS__Promise,
                        function(____, resolve)
                            local downer
                            downer = function()
                                inputs.secondary:removeDown(downer)
                                resolve(nil)
                            end
                            inputs.secondary:addDown(downer)
                        end
                    ))
                    done = true
                    screen:attach(fd)
                    local ____opt_77 = overlay.metadata
                    if ____opt_77 ~= nil then
                        ____opt_77:stop()
                    end
                    __TS__Await(fd.alpha:automate(7, 1))
                    screen:detach(voidpsr)
                    out:release()
                    accessor.state_home_telescope_x = overlay.position.x
                    accessor.state_home_telescope_y = overlay.position.y
                    game.cutscene = game.cutscene - 1
                    __TS__Await(fd.alpha:automate(7, 0))
                    screen:detach(fd)
                else
                    trivia("telescope")
                end
            end)
        end,
        fusebox = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if player.stance ~= "up" then
                    return ____awaiter_resolve(nil)
                end
                if test then
                    tooltip(text.trivia_tooltip.fusebox)
                    return ____awaiter_resolve(nil)
                end
                if 1 <= accessor.plot then
                    game.cutscene = game.cutscene + 1
                    local first = not accessor.event_home_fusebox
                    if first then
                        accessor.event_home_fusebox = true
                        __TS__Await(reader:text(text.overworld.fusebox1()))
                    end
                    if math.abs(player.position.x - 176) > 6 then
                        __TS__Await(player_walk(1.5, { x = 176 }))
                        player.stance = "up"
                    end
                    if first then
                        __TS__Await(ST:pause(15))
                    end
                    assets["s$breaker_open"]:instance()
                    local anim = object("thevibe").self
                    anim.frame = 1
                    local states = ST:populate(
                        6,
                        function(i) return ST:unstack(2, accessor.state_home_fusebox, 5 - i) end
                    )
                    local knobs = ST:populate(
                        6,
                        function(i)
                            return __TS__New(
                                STSprite,
                                {
                                    image = images.fuseknob,
                                    position = { y = 7 + math.floor(i / 2) * 5 }
                                }
                            ):addTicker(function(self)
                                self.position.x = 14 + i % 2 * 8 + states[i + 1] * 4
                            end)
                        end
                    )
                    local knobSystem = __TS__New(
                        STAtlas,
                        {
                            main = {
                                grid = function() return { { 0, 1 }, { 2, 3 }, { 4, 5 } } end,
                                position = { x = 0, y = 0 }
                            }
                        }
                    )
                    local function keyListener(self)
                        repeat
                            local ____switch302 = self
                            local ____cond302 = ____switch302 == inputs.down
                            if ____cond302 then
                                knobSystem:seek(STFacing.DOWN)
                                assets["s$breaker_navigate"]:instance()
                                break
                            end
                            ____cond302 = ____cond302 or ____switch302 == inputs.up
                            if ____cond302 then
                                knobSystem:seek(STFacing.UP)
                                assets["s$breaker_navigate"]:instance()
                                break
                            end
                            ____cond302 = ____cond302 or ____switch302 == inputs.left
                            if ____cond302 then
                                knobSystem:seek(STFacing.LEFT)
                                assets["s$breaker_navigate"]:instance()
                                break
                            end
                            ____cond302 = ____cond302 or ____switch302 == inputs.right
                            if ____cond302 then
                                knobSystem:seek(STFacing.RIGHT)
                                assets["s$breaker_navigate"]:instance()
                                break
                            end
                            ____cond302 = ____cond302 or ____switch302 == inputs.primary
                            if ____cond302 then
                                do
                                    local i = knobSystem:selection()
                                    states[i + 1] = 1 - states[i + 1]
                                    assets["s$breaker_switch"]:instance()
                                    break
                                end
                            end
                        until true
                    end
                    local keys = {
                        inputs.down,
                        inputs.up,
                        inputs.left,
                        inputs.right,
                        inputs.primary
                    }
                    for ____, key in ipairs(keys) do
                        key:addDown(keyListener)
                    end
                    anim:attach(unpack(knobs))
                    knobSystem:switch("main")
                    local out = outlineShader({ color = { red = 0, green = 0, blue = 0 }, alpha = 0.75, thickness = 1 })
                    local overlay = __TS__New(
                        STContainer,
                        {
                            alpha = 0,
                            children = {
                                __TS__New(STRectangle, {
                                    alpha = 0.25,
                                    anchor = 0.5,
                                    size = { x = 240, y = 180 },
                                    color = 0,
                                    priority = -1
                                }),
                                __TS__New(
                                    STSprite,
                                    {
                                        anchor = 0.5,
                                        alpha = 0.75,
                                        position = { y = -35 },
                                        image = images.fusebox_overlay,
                                        children = { unpack(ST:populate(
                                            6,
                                            function(i)
                                                return __TS__New(
                                                    STContainer,
                                                    {
                                                        priority = 1,
                                                        position = {
                                                            x = 23 * (-1 + i % 2 * 2),
                                                            y = -23 + math.floor(i / 2) * 23
                                                        },
                                                        children = {
                                                            __TS__New(STText,
                                                                {
                                                                    anchor = { x = 1 - i % 2, y = 0.5 },
                                                                    font = assets["f$fives"],
                                                                    position = { x = 32 * (-1 + i % 2 * 2) },
                                                                    content = ({
                                                                        text.overworld.fusebox2,
                                                                        text.overworld.fusebox3,
                                                                        text.overworld.fusebox4,
                                                                        text.overworld.fusebox5,
                                                                        text.overworld.fusebox6,
                                                                        text.overworld.fusebox7
                                                                    })[i + 1]
                                                                }),
                                                            __TS__New(STSprite,
                                                                { anchor = 0.5, image = images.fusebox_overlay_switch })
                                                                :addTicker(function(self)
                                                                    self.scale.x = 1 - states[i + 1] * 2
                                                                end),
                                                            __TS__New(STText,
                                                                { anchor = 0.5, font = assets["f$fives"], priority = 1 })
                                                                :addTicker(function(self)
                                                                    self.content = states[i + 1] == i % 2 and
                                                                        text.overworld.fusebox8 or
                                                                        text.overworld.fusebox9
                                                                    self.position.x = 4 - states[i + 1] * 8
                                                                end)
                                                        }
                                                    }
                                                ):addTicker(function(self)
                                                    if knobSystem:selection() == i then
                                                        self.color.red = 255
                                                        self.color.green = 255
                                                        self.color.blue = 255
                                                    else
                                                        self.color.red = 127
                                                        self.color.green = 127
                                                        self.color.blue = 127
                                                    end
                                                end)
                                            end
                                        )) }
                                    }
                                ),
                                __TS__New(STText, {
                                    priority = 1,
                                    anchor = 0.5,
                                    position = { y = 80 },
                                    font = assets["f$helloplayer"],
                                    alpha = 0.75,
                                    content = text.overworld.tutorial6
                                }):addDrawer(out.drawer)
                            },
                            priority = 1000,
                            metadata = true
                        }
                    ):addTicker(function(self)
                        if self.metadata then
                            local ____temp_82 = self.alpha.value < 1
                            if ____temp_82 then
                                local ____self_alpha_79, ____value_80 = self.alpha, "value"
                                local ____self_alpha_value_81 = ____self_alpha_79[____value_80] + 1 / 7
                                ____self_alpha_79[____value_80] = ____self_alpha_value_81
                                ____temp_82 = ____self_alpha_value_81 > 1
                            end
                            if ____temp_82 then
                                self.alpha.value = 1
                            end
                        else
                            local ____temp_86 = self.alpha.value > 0
                            if ____temp_86 then
                                local ____self_alpha_83, ____value_84 = self.alpha, "value"
                                local ____self_alpha_value_85 = ____self_alpha_83[____value_84] - 1 / 7
                                ____self_alpha_83[____value_84] = ____self_alpha_value_85
                                ____temp_86 = ____self_alpha_value_85 <= 0
                            end
                            if ____temp_86 then
                                screen:detach(self)
                                out:release()
                            end
                        end
                    end):addDrawer(batch.drawer)
                    screen:attach(overlay)
                    __TS__Await(__TS__New(
                        __TS__Promise,
                        function(____, resolve)
                            local downer
                            downer = function()
                                inputs.secondary:removeDown(downer)
                                resolve(nil)
                            end
                            inputs.secondary:addDown(downer)
                        end
                    ))
                    knobSystem:switch(nil)
                    for ____, direcKey in ipairs(keys) do
                        direcKey:removeDown(keyListener)
                    end
                    anim:detach(unpack(knobs))
                    anim.frame = 0
                    assets["s$breaker_close"]:instance()
                    accessor.state_home_fusebox = ST:stack(2, states)
                    game.cutscene = game.cutscene - 1
                    overlay.metadata = false
                else
                    trivia("fusebox")
                end
            end)
        end,
        bed = function(test)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if test then
                    tooltip(text.trivia_tooltip.bed)
                    return ____awaiter_resolve(nil)
                end
                if accessor.plot < 2 or accessor.item_cover then
                    trivia("bed")
                else
                    game.cutscene = game.cutscene + 1
                    accessor.item_cover = true
                    update()
                    __TS__Await(reader:text(text.overworld.bed1))
                    __TS__Await(ST:pause(15))
                    __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                    __TS__Await(ST:pause(15))
                    local ____reader_headers_89 = reader.headers
                    ____reader_headers_89[#____reader_headers_89 + 1] = {
                        "a",
                        function()
                            assets["s$itemget"]:instance()
                            local ____opt_87 = object("cover")
                            if ____opt_87 ~= nil then
                                ____opt_87:destroy()
                            end
                        end
                    }
                    __TS__Await(reader:text(text.overworld.bed2()))
                    if accessor.item_scissors then
                        player.stance = "up"
                        bb_standard(player, assets["ie$ellipsis"])
                        assets["s$scissors"]:instance()
                        __TS__Await(ST:pause(75))
                    else
                        __TS__Await(ST:pause(45))
                    end
                    local ____reader_91 = reader
                    local ____reader_text_92 = reader.text
                    local ____array_90 = __TS__SparseArrayNew(unpack(text.overworld.bed3()))
                    __TS__SparseArrayPush(
                        ____array_90,
                        unpack(accessor.item_scissors and accessor.item_crowbar and text.overworld.done1 or ({}))
                    )
                    __TS__Await(____reader_text_92(
                        ____reader_91,
                        { __TS__SparseArraySpread(____array_90) }
                    ))
                    if accessor.item_scissors and accessor.item_crowbar then
                        __TS__Await(ST:pause(15))
                        __TS__Await(bb_standard(player, assets["ie$note"]))
                        __TS__Await(ST:pause(15))
                        __TS__Await(reader:text(text.overworld.done2))
                        accessor.plot = 3
                    end
                    game.cutscene = game.cutscene - 1
                end
            end)
        end,
        book = function(test)
            if player.stance == "left" then
                if test then
                    tooltip(text.trivia_tooltip.book)
                    return
                end
                trivia("book")
            else
                if test then
                    tooltip(text.trivia_tooltip.lamp)
                    return
                end
                trivia("lamp")
            end
        end,
        rope = function(test)
            if accessor.plot < 1 then
                if test then
                    tooltip(text.trivia_tooltip.rope)
                    return
                end
                trivia("rope")
            elseif not accessor.item_rope then
                if test then
                    tooltip(text.trivia_tooltip.rope)
                    return
                end
                accessor.item_rope = true
                update()
                local ____reader_headers_93 = reader.headers
                ____reader_headers_93[#____reader_headers_93 + 1] = {
                    "a",
                    function()
                        assets["s$itemget"]:instance()
                        object("hot").self.frame = accessor.item_scissors and 3 or 2
                    end
                }
                reader:text(text.overworld.rope1())
            end
        end
    }
    local scripts_ex = {
        roper = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.plot < 2 or accessor.event_home_rope or 3 <= accessor.plot then
                    return ____awaiter_resolve(nil, false)
                end
                if map.room == 7 then
                    game.cutscene = game.cutscene + 1
                    accessor.event_home_rope = true
                    __TS__Await(reader:text(text.overworld.dangle1))
                    __TS__Await(ST:pause(15))
                    if player.position.x < 30 then
                        __TS__Await(player_walk(1.5, { x = 30, y = player.position.y + (30 - player.position.x) }))
                    end
                    __TS__Await(player_walk(1.5, { x = 35 }, { y = 135 }))
                    __TS__Await(ST:pause(10))
                    local cam = map:cam_clamped()
                    map.camera = cam
                    local rg = map:cam_free()
                    __TS__Await(cam:automate(90, { y = 300 }))
                    __TS__Await(ST:pause(60))
                    __TS__Await(reader:text(text.overworld.dangle2))
                    __TS__Await(ST:pause(45))
                    __TS__Await(cam:automate(90, { y = 135 }))
                    map:cam_restore(unpack(rg))
                    map.camera = player.position
                    __TS__Await(ST:pause(60))
                    __TS__Await(reader:text(text.overworld.dangle3()))
                    game.cutscene = game.cutscene - 1
                else
                    __TS__Await(reader:text(text.overworld.rope2))
                end
            end)
        end,
        buckey = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.event_home_bucket or 2 <= accessor.plot then
                    return ____awaiter_resolve(nil, false)
                end
                if map.room == 7 then
                    game.cutscene = game.cutscene + 1
                    accessor.event_home_bucket = true
                    __TS__Await(reader:text(text.overworld.rain1))
                    __TS__Await(ST:pause(15))
                    if player.position.x < 30 then
                        __TS__Await(player_walk(1.5, { x = 30, y = player.position.y + (30 - player.position.x) }))
                    end
                    __TS__Await(player_walk(1.5, { x = 35 }))
                    if math.abs(player.position.y - 110) > 6 then
                        __TS__Await(ST:pause(15))
                        __TS__Await(player_walk(1.5, { y = 110 }))
                    end
                    player.stance = "right"
                    __TS__Await(ST:pause(30))
                    local buckey = __TS__New(STAnimation, {
                        anchor = { x = 0.5, y = 1 },
                        position = { x = 50, y = 113 },
                        frames = framess.shovel_pot,
                        frame = 4,
                        priority = 113
                    })
                    map:attach(buckey)
                    assets["s$bucketputdown"]:instance()
                    __TS__Await(ST:pause(120))
                    __TS__Await(bb_standard(player, assets["ie$confused"]))
                    __TS__Await(ST:pause(30))
                    __TS__Await(reader:text(text.overworld.rain2))
                    __TS__Await(ST:pause(30))
                    __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                    __TS__Await(ST:pause(30))
                    __TS__Await(reader:text(text.overworld.rain3))
                    map:detach(buckey)
                    assets["s$bucketpickup"]:instance()
                    game.cutscene = game.cutscene - 1
                else
                    __TS__Await(reader:text(text.overworld.bucket4))
                end
            end)
        end,
        ponder = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                game.cutscene = game.cutscene + 1
                __TS__Await(ST:pause(10))
                __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                if accessor.plot < 0.4 then
                    __TS__Await(reader:text(text.ponder_book("ponder_book")))
                elseif accessor.plot < 1 then
                    __TS__Await(reader:text(text.ponder_sleep))
                elseif not accessor.event_home_outside then
                    __TS__Await(reader:text(text.ponder_hello))
                elseif accessor.plot < 2 then
                    __TS__Await(reader:text(text.ponder_outside("ponder_outside")))
                elseif accessor.plot < 3 then
                    __TS__Await(reader:text(text.ponder_platform()))
                else
                    __TS__Await(reader:text(text.ponder_exit("ponder_exit")))
                end
                game.cutscene = game.cutscene - 1
            end)
        end
    }
    local updaters = {
        [0] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.item_goatplush then
                    local ____opt_94 = object("goatplush")
                    if ____opt_94 ~= nil then
                        ____opt_94:destroy()
                    end
                    local ____opt_96 = object("goatplush")
                    if ____opt_96 ~= nil then
                        ____opt_96:destroy()
                    end
                end
                if accessor.item_cover then
                    local ____opt_98 = object("cover")
                    if ____opt_98 ~= nil then
                        ____opt_98:destroy()
                    end
                end
            end)
        end,
        [1] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if 2 <= accessor.plot then
                    local toy = object("toy").self
                    toy.direction = 0
                    toy.frame = 3
                end
                if physical and accessor.plot < 0.1 then
                    game.cutscene = game.cutscene + 1
                    local fd = __TS__New(STRectangle,
                        { color = 0, anchor = 0.5, priority = 1000, size = { x = 240, y = 180 } })
                    screen:attach(fd)
                    __TS__Await(ST:pause(37))
                    local innerText = __TS__New(
                        STText,
                        {
                            font = assets["f$helloplayer"],
                            anchor = 0.5,
                            justify = 0.5,
                            position = { y = 15 },
                            color = 10652124,
                            content = assets["f$helloplayer"]:wrap(
                                text.overworld.start2,
                                function() return 230 end,
                                standardSplitter
                            )
                        }
                    )
                    local startText = __TS__New(
                        STContainer,
                        {
                            alpha = 0,
                            priority = 1001,
                            children = {
                                __TS__New(STText, {
                                    font = assets["f$helloplayer"],
                                    anchor = 0.5,
                                    position = { y = -25 },
                                    justify = 0.5,
                                    scale = 2,
                                    content = text.overworld.start1
                                }),
                                innerText
                            }
                        }
                    )
                    screen:attach(startText)
                    __TS__Await(startText.alpha:automate(30, 1))
                    __TS__Await(__TS__PromiseRace({
                        ST:pause(150),
                        ST:when(function() return inputs.tertiary.held end)
                    }))
                    __TS__Await(innerText.alpha:automate(30, 0))
                    innerText.content = assets["f$helloplayer"]:wrap(
                        text.overworld.start3,
                        function() return 230 end,
                        standardSplitter
                    )
                    __TS__Await(innerText.alpha:automate(30, 1))
                    __TS__Await(__TS__PromiseRace({
                        ST:pause(150),
                        ST:when(function() return inputs.tertiary.held end)
                    }))
                    __TS__Await(startText.alpha:automate(30, 0))
                    screen:detach(startText)
                    __TS__Await(ST:pause(30))
                    screen:detach(fd)
                    daemons.crickets:instance_forced({ gain = 0 }).gain:automate(120, 1)
                    __TS__Await(unfailer())
                    accessor.plot = 0.1
                    accessor.tutorial_choice = false
                    accessor.tutorial_dialogue = false
                    local ____self_100 = hintDialogue()
                    ____self_100["then"](
                        ____self_100,
                        function()
                            accessor.tutorial_dialogue = true
                        end
                    )
                    game.cutscene = game.cutscene - 1
                    save()
                end
                if physical and accessor.plot < 0.2 then
                    local hint = hintGen(text.overworld.tutorial1, 0, 90)
                    __TS__Await(ST:when(function()
                        return math.abs(player.metadata.last_x) ~= 0 or
                            math.abs(player.metadata.last_y) ~= 0
                    end))
                    accessor.plot = 0.2
                    hint()
                    local ____self_101 = hintInter()
                    ____self_101["then"](
                        ____self_101,
                        function()
                            accessor.plot = 0.3
                        end
                    )
                end
                if physical and accessor.plot == 1 then
                    accessor.plot = 1.1
                    game.cutscene = game.cutscene + 1
                    __TS__Await(ST:pause(15))
                    __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                    __TS__Await(ST:pause(15))
                    player.stance = "left"
                    __TS__Await(ST:pause(30))
                    player.stance = "right"
                    __TS__Await(ST:pause(45))
                    __TS__Await(reader:text(text.overworld.hello3))
                    __TS__Await(ST:pause(55))
                    player.stance = "down"
                    __TS__Await(reader:text(text.overworld.hello4))
                    game.cutscene = game.cutscene - 1
                end
            end)
        end,
        [2] = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.item_crowbar then
                    local ____opt_102 = object("framebox")
                    if ____opt_102 ~= nil then
                        ____opt_102:destroy()
                    end
                    object("rogerrabbit").self.frame = 1
                end
            end)
        end,
        [3] = function()
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if accessor.item_drill then
                    local ____opt_104 = object("driller")
                    if ____opt_104 ~= nil then
                        ____opt_104:destroy()
                    end
                end
                if accessor.item_rock then
                    object("SWEEPSWEEPSWEEP").self.frame = 3
                end
                if accessor.item_bucket then
                    object("harry").self.frame = 3
                    local ____opt_106 = object("bucketbox1")
                    if ____opt_106 ~= nil then
                        ____opt_106:destroy()
                    end
                elseif accessor.event_home_outside then
                    local bb2 = object("bucketbox2").self
                    bb2.metadata.y = bb2.position.y
                    bb2.position.y = 1000
                else
                    local ____opt_108 = object("bucketbox2")
                    if ____opt_108 ~= nil then
                        ____opt_108:destroy()
                    end
                end
            end)
        end,
        [4] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if physical and accessor.plot < 2 then
                    assets["s$faucet_distant"]:instance({ position = state.faucet_time, gain = 0.4 })
                end
                if accessor.event_home_telescope then
                    local ____opt_110 = object("telescope")
                    if ____opt_110 ~= nil then
                        ____opt_110:destroy()
                    end
                    local ____opt_112 = object("telescope")
                    if ____opt_112 ~= nil then
                        ____opt_112:destroy()
                    end
                elseif 1 <= accessor.plot then
                    hide("tscope2")
                else
                    local ____opt_114 = object("tscope2")
                    if ____opt_114 ~= nil then
                        ____opt_114:destroy()
                    end
                    local ____opt_116 = object("tscope2")
                    if ____opt_116 ~= nil then
                        ____opt_116:destroy()
                    end
                    local ____opt_118 = object("tscope2")
                    if ____opt_118 ~= nil then
                        ____opt_118:destroy()
                    end
                end
                if accessor.event_home_bookshelf == 2 then
                    local ____opt_120 = object("basket")
                    if ____opt_120 ~= nil then
                        ____opt_120:destroy()
                    end
                    local ____opt_122 = object("basket")
                    if ____opt_122 ~= nil then
                        ____opt_122:destroy()
                    end
                    object("screwbox").self.frame = 1
                elseif accessor.event_home_secret then
                    hide("flipbasket")
                else
                    local ____opt_124 = object("flipbasket")
                    if ____opt_124 ~= nil then
                        ____opt_124:destroy()
                    end
                    local ____opt_126 = object("flipbasket")
                    if ____opt_126 ~= nil then
                        ____opt_126:destroy()
                    end
                end
                if 0.4 <= accessor.plot then
                    local ____opt_128 = object("extrabook")
                    if ____opt_128 ~= nil then
                        ____opt_128:destroy()
                    end
                end
                if physical and accessor.plot < 1 then
                    object("night0").self:addTicker(function(self)
                        self.offset.y = -10 + ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) -
                            map.camera_min.y
                    end)
                    object("night1").self:addTicker(function(self)
                        self.offset.y = -10 +
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                8 +
                                0.5)
                    end)
                    object("night2").self:addTicker(function(self)
                        self.offset.y = -10 +
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                16 +
                                0.5)
                    end)
                    object("night3").self.offset.y = -10
                    object("night4").self:addTicker(function(self)
                        self.offset.y = -8 -
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                16 +
                                0.5)
                    end)
                    object("night5").self:addTicker(function(self)
                        self.offset.y = -6 -
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                32 +
                                0.5)
                    end)
                end
            end)
        end,
        [5] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if not accessor.event_home_food then
                    object("bowl").self.alpha.value = 0
                else
                    local ____opt_130 = object("counter")
                    if ____opt_130 ~= nil then
                        ____opt_130:destroy()
                    end
                end
                if accessor.state_home_telecomm_message == 2 then
                    local anim = object("telecomm").self
                    anim.direction = 0
                    anim.duration = 0
                    anim.frame = 0
                    anim.step = 0
                end
                if physical and accessor.plot < 2 then
                    local fau = assets["s$faucet"]:instance_forced({ position = state.faucet_time })
                    object("leaker").self:addTicker(function(self)
                        self.frame = math.floor(fau.position.value * 30) % 60
                    end)
                end
                if accessor.item_scissors or accessor.item_rope then
                    object("hot").self.frame = (accessor.item_scissors and 1 or 0) + (accessor.item_rope and 2 or 0)
                end
                if physical and accessor.plot < 1 then
                    object("night0").self:addTicker(function(self)
                        self.offset.y = -10 + ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) -
                            map.camera_min.y
                    end)
                    object("night1").self:addTicker(function(self)
                        self.offset.y = -10 +
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                8 +
                                0.5)
                    end)
                    object("night2").self.offset.y = -10
                    object("night3").self:addTicker(function(self)
                        self.offset.y = -9 -
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                16 +
                                0.5)
                    end)
                    object("night4").self:addTicker(function(self)
                        self.offset.y = -8 -
                            math.floor((ST:clamp(map.camera.y, map.camera_min.y, map.camera_max.y) - map.camera_min.y) /
                                32 +
                                0.5)
                    end)
                end
            end)
        end,
        [6] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if physical and accessor.plot < 2 then
                    assets["s$faucet_distant"]:instance({ position = state.faucet_time, gain = 0.4 })
                end
            end)
        end,
        [7] = function(from, physical)
            return __TS__AsyncAwaiter(function(____awaiter_resolve)
                if physical and not accessor.event_home_outside then
                    accessor.event_home_outside = true
                    game.cutscene = game.cutscene + 1
                    __TS__Await(ST:pause(25))
                    local silly = __TS__New(STSprite, {
                        anchor = { x = 0.5, y = 1 },
                        position = player.position,
                        color = 10652124,
                        priority = player.position.y,
                        image = accessor.floof and assets["ic$player$what_side_plush"] or assets["ic$player$what_side"]
                    })
                    map:attach(silly)
                    player.alpha.value = 0
                    __TS__Await(bb_standard(silly, assets["ie$surprise"]))
                    __TS__Await(ST:pause(15))
                    __TS__Await(reader:text(text.overworld.outside1))
                    __TS__Await(ST:pause(30))
                    assets["m$home"]:instance()
                    player.alpha.value = 1
                    map:detach(silly)
                    __TS__Await(player_walk(1.5, { x = 30, y = 120 }, { x = 45 }))
                    __TS__Await(ST:pause(45))
                    __TS__Await(reader:text(text.overworld.outside2))
                    __TS__Await(ST:pause(30))
                    player.stance = "up"
                    __TS__Await(ST:pause(40))
                    player.stance = "down"
                    __TS__Await(ST:pause(50))
                    player.stance = "right"
                    __TS__Await(ST:pause(60))
                    __TS__Await(reader:text(text.overworld.outside3))
                    __TS__Await(ST:pause(45))
                    __TS__Await(bb_standard(player, assets["ie$xicon"]))
                    __TS__Await(ST:pause(30))
                    player.stance = "down"
                    __TS__Await(reader:text(text.overworld.outside4))
                    game.cutscene = game.cutscene - 1
                end
            end)
        end
    }
    activators[#activators + 1] = function(test, name, ...)
        local args = { ... }
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            if game.cutscene ~= 0 then
                return ____awaiter_resolve(nil)
            end
            if scripts[name] ~= nil then
                local p = scripts[name](test, args)
                if p ~= nil then
                    __TS__Await(p)
                end
            end
        end)
    end
    game.script = function(name)
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            if scripts_ex[name] ~= nil then
                local ____TS__Await_result_132 = __TS__Await(scripts_ex[name]())
                if ____TS__Await_result_132 == nil then
                    ____TS__Await_result_132 = true
                end
                return ____awaiter_resolve(nil, ____TS__Await_result_132)
            end
            return ____awaiter_resolve(nil, false)
        end)
    end
    __TS__ArrayPush(
        items,
        {
            name = function(self)
                return text.item_book.name
            end,
            priority = 100,
            script = function(self, reader)
                return __TS__AsyncAwaiter(function(____awaiter_resolve)
                    __TS__Await(reader:text(text.item_book.info()))
                end)
            end,
            show = function(self)
                return accessor.plot == 0.4
            end
        },
        {
            name = function(self)
                return text.item_rock.name
            end,
            priority = 101,
            script = function(self, reader)
                return __TS__AsyncAwaiter(function(____awaiter_resolve)
                    if map.room == 7 then
                        game.cutscene = game.cutscene + 1
                        accessor.plot = 2
                        update()
                        __TS__Await(reader:text(text.overworld.golden1))
                        if player.position.x < 30 then
                            __TS__Await(player_walk(1.5, { x = 30, y = player.position.y + (30 - player.position.x) }))
                        end
                        if player.position.x > 30 then
                            __TS__Await(player_walk(1.5, { x = 30 }))
                        end
                        if player.position.y < 115 and math.abs(player.position.y - 115) > 6 then
                            __TS__Await(player_walk(1.5, { y = 115 }))
                        elseif player.position.y > 125 and math.abs(player.position.y - 125) > 6 then
                            __TS__Await(player_walk(1.5, { y = 125 }))
                        end
                        player.stance = "right"
                        __TS__Await(ST:pause(45))
                        local cam = map:cam_clamped()
                        map.camera = cam
                        local rg = map:cam_free()
                        local i = 0
                        while i < 2 do
                            local ____self_133 = reader:header("a")
                            local ____self_133_then_result_135 = ____self_133["then"](
                                ____self_133,
                                function()
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        cam:automate(30, { x = 175 })
                                        __TS__Await(bb_standard(player, assets["ie$surprise"]))
                                    end)
                                end
                            )
                            local ____self_134 = reader:text(({ text.overworld.golden2, text.overworld.golden4 })[i + 1])
                            __TS__Await(__TS__PromiseAll({
                                ____self_133_then_result_135,
                                ____self_134["then"](
                                    ____self_134,
                                    function() return ST:pause(15) end
                                )
                            }))
                            local power = __TS__Await(__TS__New(
                                __TS__Promise,
                                function(____, resolve)
                                    local d = false
                                    local ac = inputs.primary.held and -1 or 0
                                    local fx = nil
                                    local function pow(n)
                                        return ST:linear(
                                            n / 90,
                                            0,
                                            0.5,
                                            1,
                                            0
                                        )
                                    end
                                    local rec = __TS__New(STRectangle,
                                        { position = { x = 194 / -2 }, anchor = { y = 0.5 }, size = { y = 24 }, priority = 1 })
                                    local htext = __TS__New(STText, {
                                        content = text.overworld.tutorial7,
                                        priority = 2,
                                        position = { y = 1 },
                                        anchor = 0.5,
                                        font = assets["f$helloplayer"],
                                        color = 8355711
                                    })
                                    local powbar = __TS__New(
                                        STContainer,
                                        {
                                            alpha = 0,
                                            metadata = 0,
                                            children = {
                                                __TS__New(STSprite, { anchor = 0.5, image = images.powbar }),
                                                rec,
                                                htext
                                            },
                                            priority = 1000
                                        }
                                    ):addTicker(function(self)
                                        if d then
                                            local ____temp_139 = self.alpha.value > 0
                                            if ____temp_139 then
                                                local ____self_alpha_136, ____value_137 = self.alpha, "value"
                                                local ____self_alpha_value_138 = ____self_alpha_136[____value_137] -
                                                    0.75 / 7
                                                ____self_alpha_136[____value_137] = ____self_alpha_value_138
                                                ____temp_139 = ____self_alpha_value_138 <= 0
                                            end
                                            if ____temp_139 then
                                                screen:detach(self)
                                            end
                                            return
                                        else
                                            local ____temp_143 = self.alpha.value < 0.75
                                            if ____temp_143 then
                                                local ____self_alpha_140, ____value_141 = self.alpha, "value"
                                                local ____self_alpha_value_142 = ____self_alpha_140[____value_141] +
                                                    0.75 / 7
                                                ____self_alpha_140[____value_141] = ____self_alpha_value_142
                                                ____temp_143 = ____self_alpha_value_142 > 0.75
                                            end
                                            local ____temp_143_144 = ____temp_143
                                            if ____temp_143_144 then
                                                self.alpha.value = 0.75
                                                ____temp_143_144 = 0.75
                                            end
                                        end
                                        repeat
                                            local ____switch437 = ac
                                            local ____cond437 = ____switch437 == -1
                                            if ____cond437 then
                                                if not inputs.primary.held then
                                                    ac = 0
                                                end
                                                break
                                            end
                                            ____cond437 = ____cond437 or ____switch437 == 0
                                            if ____cond437 then
                                                if inputs.primary.held then
                                                    ac = 1
                                                elseif self.metadata ~= 0 then
                                                    self.metadata = self.metadata - 1
                                                end
                                                break
                                            end
                                            ____cond437 = ____cond437 or ____switch437 == 1
                                            if ____cond437 then
                                                local ____temp_148 = not inputs.primary.held
                                                if not ____temp_148 then
                                                    local ____self_145, ____metadata_146 = self, "metadata"
                                                    local ____self_metadata_147 = ____self_145[____metadata_146] + 1
                                                    ____self_145[____metadata_146] = ____self_metadata_147
                                                    ____temp_148 = ____self_metadata_147 == 90
                                                end
                                                if ____temp_148 then
                                                    if self.metadata < 10 then
                                                        ac = 0
                                                        break
                                                    end
                                                    d = true
                                                    local p = pow(self.metadata)
                                                    self.scale:automate(7, 1 + p ^ 3 * 2)
                                                    resolve(nil, p)
                                                    if fx ~= nil then
                                                        ezecho(
                                                            fx,
                                                            10,
                                                            0.4 + p * 0.2,
                                                            0.25 + p * 0.2,
                                                            0.001
                                                        )
                                                    end
                                                    return
                                                end
                                                break
                                            end
                                        until true
                                        rec.size.x = ST:remap(
                                            self.metadata,
                                            0,
                                            194,
                                            0,
                                            90
                                        )
                                        htext.alpha.value = 1 - math.min(self.metadata / 10, 1)
                                        local v = pow(self.metadata)
                                        local s = v ^ 5
                                        self.position.x = (math.random() - 0.5) * s * 2
                                        self.position.y = 60 + (math.random() - 0.5) * s * 2
                                        local c = ST:remap(v ^ 3, 127, 255)
                                        rec.color.red = c
                                        rec.color.green = c
                                        rec.color.blue = c
                                        if fx == nil and 10 <= self.metadata then
                                            fx = assets["s$chargethrow"]:instance_forced()
                                        end
                                    end):addDrawer(batch.drawer)
                                    screen:attach(powbar)
                                end
                            ))
                            __TS__Await(__TS__New(
                                __TS__Promise,
                                function(____, resolve)
                                    local rock
                                    rock = __TS__New(
                                        STSprite,
                                        {
                                            image = images.rock,
                                            anchor = 0.5,
                                            metadata = 0,
                                            velocity = ST:ray(
                                                -30,
                                                ST:remap(power, 5, 10)
                                            ),
                                            gravity = { y = 0.25 },
                                            position = { x = 30, y = player.position.y - 10 },
                                            priority = 500
                                        }
                                    ):addTicker(function(self)
                                        map:attach(__TS__New(
                                            STSprite,
                                            {
                                                alpha = ST:remap(power, 0, 0.3),
                                                image = images.rock,
                                                anchor = 0.5,
                                                scale = { x = self.scale.x },
                                                rotation = self.rotation.value,
                                                position = self.position,
                                                priority = 500
                                            }
                                        ):addTicker(function(self)
                                            local ____self_alpha_149, ____value_150 = self.alpha, "value"
                                            local ____self_alpha_value_151 = ____self_alpha_149[____value_150] - 0.1
                                            ____self_alpha_149[____value_150] = ____self_alpha_value_151
                                            if ____self_alpha_value_151 <= 0 then
                                                map:detach(self)
                                            end
                                        end))
                                        return function()
                                            if self.position.y > cam.y + 100 then
                                                map:detach(rock)
                                                resolve(nil)
                                            else
                                                local ____self_152, ____metadata_153 = self, "metadata"
                                                local ____self_metadata_154 = ____self_152[____metadata_153] + 1
                                                ____self_152[____metadata_153] = ____self_metadata_154
                                                repeat
                                                    local ____switch452 = ____self_metadata_154
                                                    local ____cond452 = ____switch452 == 3
                                                    if ____cond452 then
                                                        self.rotation.value = 90
                                                        self.scale.x = -1
                                                        break
                                                    end
                                                    ____cond452 = ____cond452 or ____switch452 == 6
                                                    if ____cond452 then
                                                        self.metadata = 0
                                                        self.rotation.value = 0
                                                        self.scale.x = 1
                                                        break
                                                    end
                                                until true
                                            end
                                        end
                                    end)
                                    map:attach(rock)
                                end
                            ))
                            __TS__Await(ST:pause(60))
                            __TS__Await(cam:automate(45, { x = 120 }))
                            __TS__Await(ST:pause(30))
                            __TS__Await(reader:text(({ text.overworld.golden3, text.overworld.golden5 })[i + 1]))
                            local ____i_155 = i
                            i = ____i_155 + 1
                            if ____i_155 == 0 then
                                __TS__Await(ST:pause(15))
                                player.stance = "up"
                                __TS__Await(ST:pause(30))
                                player.stance = "down"
                                __TS__Await(ST:pause(45))
                                player.stance = "right"
                                __TS__Await(ST:pause(60))
                            end
                        end
                        __TS__ArrayMap(
                            assets["m$home"].instances,
                            function(____, inst)
                                return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                    __TS__Await(inst.gain:automate(90, 0))
                                    inst:stop()
                                end)
                            end
                        )
                        __TS__Await(ST:pause(60))
                        __TS__Await(bb_standard(player, assets["ie$ellipsis"]))
                        __TS__Await(ST:pause(15))
                        __TS__Await(reader:text(text.overworld.golden6))
                        __TS__Await(ST:pause(45))
                        __TS__Await(player_walk(0.5, { y = 135 }))
                        __TS__Await(ST:pause(10))
                        local task = ST:task()
                        cam:automate(90, { y = 300 })
                        local ____self_164 = ST:pause(60)
                        __TS__Await(__TS__PromiseAll({
                            ____self_164["then"](
                                ____self_164,
                                function()
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        __TS__Await(__TS__New(
                                            __TS__Promise,
                                            function(____, resolve)
                                                local b = false
                                                local rock
                                                rock = __TS__New(STSprite, {
                                                    image = images.rock,
                                                    anchor = 0.5,
                                                    metadata = 0,
                                                    gravity = { y = 0.25 },
                                                    velocity = { x = 0.5 },
                                                    position = { x = 30, y = player.position.y - 10 },
                                                    priority = 500
                                                }):addTicker(function(self)
                                                    if not b then
                                                        map:attach(__TS__New(
                                                            STSprite,
                                                            {
                                                                alpha = ST:remap_clamped(
                                                                    self.velocity.y,
                                                                    0,
                                                                    0.15,
                                                                    0,
                                                                    10
                                                                ),
                                                                image = images.rock,
                                                                anchor = 0.5,
                                                                scale = { x = self.scale.x },
                                                                rotation = self.rotation.value,
                                                                position = self.position,
                                                                priority = 500
                                                            }
                                                        ):addTicker(function(self)
                                                            local ____self_alpha_156, ____value_157 = self.alpha, "value"
                                                            local ____self_alpha_value_158 = ____self_alpha_156
                                                                [____value_157] - 0.1
                                                            ____self_alpha_156[____value_157] = ____self_alpha_value_158
                                                            if ____self_alpha_value_158 <= 0 then
                                                                map:detach(self)
                                                            end
                                                        end))
                                                    end
                                                    return function()
                                                        if not b and 340 <= self.position.y then
                                                            b = true
                                                            self.position.y = 340
                                                            local ____self_velocity_159, ____y_160 = self.velocity, "y"
                                                            ____self_velocity_159[____y_160] = ____self_velocity_159
                                                                [____y_160] * -0.4
                                                            self.velocity.x = 1.5
                                                            assets["s$rockbounce"]:instance()
                                                            task.complete()
                                                        elseif self.position.y > 390 then
                                                            map:detach(rock)
                                                            resolve(nil)
                                                        else
                                                            local ____self_161, ____metadata_162 = self, "metadata"
                                                            local ____self_metadata_163 = ____self_161[____metadata_162] +
                                                                1
                                                            ____self_161[____metadata_162] = ____self_metadata_163
                                                            repeat
                                                                local ____switch465 = ____self_metadata_163
                                                                local ____cond465 = ____switch465 == 6
                                                                if ____cond465 then
                                                                    self.rotation.value = 90
                                                                    self.scale.x = -1
                                                                    break
                                                                end
                                                                ____cond465 = ____cond465 or ____switch465 == 12
                                                                if ____cond465 then
                                                                    self.metadata = 0
                                                                    self.rotation.value = 0
                                                                    self.scale.x = 1
                                                                    break
                                                                end
                                                            until true
                                                        end
                                                    end
                                                end)
                                                map:attach(rock)
                                            end
                                        ))
                                        __TS__Await(ST:pause(60))
                                    end)
                                end
                            ),
                            task["then"](
                                task,
                                function()
                                    return __TS__AsyncAwaiter(function(____awaiter_resolve)
                                        __TS__Await(ST:pause(60))
                                        __TS__Await(reader:text(text.overworld.golden7))
                                        __TS__Await(ST:pause(45))
                                    end)
                                end
                            )
                        }))
                        __TS__Await(cam:automate(90, { y = 135 }))
                        map:cam_restore(unpack(rg))
                        map.camera = player.position
                        __TS__Await(ST:pause(60))
                        __TS__Await(reader:text(text.overworld.golden8))
                        __TS__Await(ST:pause(45))
                        __TS__Await(reader:text(text.overworld.golden9))
                        __TS__Await(ST:pause(15))
                        player.stance = "right"
                        __TS__Await(ST:pause(30))
                        player.stance = "up"
                        __TS__Await(ST:pause(45))
                        player.stance = "down"
                        __TS__Await(ST:pause(60))
                        __TS__Await(reader:text(text.overworld.golden10))
                        assets["m$home_full"]:instance()
                        game.cutscene = game.cutscene - 1
                    else
                        __TS__Await(reader:text(text.overworld.broombox3))
                    end
                end)
            end,
            show = function(self)
                return accessor.item_rock and accessor.plot < 2
            end
        },
        {
            name = function(self)
                return text.item_cover.name()
            end,
            priority = 102,
            script = function(self, reader)
                return __TS__AsyncAwaiter(function(____awaiter_resolve)
                    __TS__Await(reader:text(text.item_cover.info()))
                end)
            end,
            show = function(self)
                return accessor.item_cover
            end
        },
        {
            name = function(self)
                return text.item_crowbar.name
            end,
            priority = 103,
            script = function(self, reader)
                return __TS__AsyncAwaiter(function(____awaiter_resolve)
                    __TS__Await(reader:text(text.item_crowbar.info))
                end)
            end,
            show = function(self)
                return accessor.item_crowbar
            end
        }
    )
    map:addUpdater(function(self, from, to, physical, x, y)
        return __TS__AsyncAwaiter(function(____awaiter_resolve)
            if to == nil then
                return ____awaiter_resolve(nil)
            end
            if physical then
                for key in pairs(pager.storage) do
                    if __TS__StringIncludes(key, "#") then
                        pager.storage[key] = 0
                    end
                end
                if accessor.plot < 1 then
                    map.autoplay = false
                    for ____, obj in __TS__Iterator(objects("void_window")) do
                        obj:destroy()
                    end
                    local rect = __TS__New(STRectangle, {
                        color = 1052688,
                        size = { x = 240, y = 180 },
                        anchor = 0.5,
                        priority = 500,
                        blend = STBlend.SUBTRACT
                    }):addTicker(function(self)
                        self.position.x = x - map.position.x / map.scale.x
                        self.position.y = y - map.position.y / map.scale.y
                        self.scale.x = 1 / map.scale.x
                        self.scale.y = 1 / map.scale.y
                    end)
                    temp[#temp + 1] = rect
                    map:attach(rect)
                else
                    for ____, obj in __TS__Iterator(objects("night")) do
                        obj:destroy()
                    end
                end
            end
            if physical and from == nil then
                if not accessor.tutorial_dialogue then
                    local ____self_165 = hintDialogue()
                    ____self_165["then"](
                        ____self_165,
                        function()
                            accessor.tutorial_dialogue = true
                        end
                    )
                end
                repeat
                    local ____switch491 = accessor.plot
                    local ____cond491 = ____switch491 == 0.2
                    if ____cond491 then
                        local ____self_166 = hintInter()
                        ____self_166["then"](
                            ____self_166,
                            function()
                                accessor.plot = 0.3
                            end
                        )
                    end
                    ____cond491 = ____cond491 or (____switch491 == 0.1 or ____switch491 == 0.2 or ____switch491 == 0.3)
                    if ____cond491 then
                        local ____opt_167 = daemons.crickets:instance({ gain = 0 })
                        if ____opt_167 ~= nil then
                            ____opt_167.gain:automate(7, 1)
                        end
                        break
                    end
                    ____cond491 = ____cond491 or (____switch491 == 1 or ____switch491 == 1.1)
                    if ____cond491 then
                        if accessor.event_home_outside then
                            local ____opt_169 = assets["m$home"]:instance({ gain = 0 })
                            if ____opt_169 ~= nil then
                                ____opt_169.gain:automate(7, 1)
                            end
                        end
                        break
                    end
                    ____cond491 = ____cond491 or (____switch491 == 2 or ____switch491 == 3)
                    if ____cond491 then
                        local ____opt_171 = assets["m$home_full"]:instance({ gain = 0 })
                        if ____opt_171 ~= nil then
                            ____opt_171.gain:automate(7, 1)
                        end
                        break
                    end
                until true
                if accessor.plot < 1 then
                    state.mapcolor.saturation = 0.4
                    state.mapcolor.value = 0.8
                end
            end
            if updaters[to] ~= nil then
                local p = updaters[to](from, physical, x, y)
                if p ~= nil then
                    __TS__Await(p)
                end
            end
        end)
    end)
    player:addDrawer(stepSFX)
    reader.presets.messenger = {
        color = 16777215,
        chunk = 2,
        faces = {},
        font = assets["f$helloplayer"],
        interval = 2,
        voices = { default = { { assets["v$messenger"], 1 } } }
    }
    save_hooks[#save_hooks + 1] = function()
        accessor.location_idx = map.room
        accessor.pager_home = ST:encode(pager.storage)
    end
    local shaderCleanup = shaderSetup()
    local hsv = hsvShader(state.mapcolor)
    map:addDrawer(hsv.drawer)
    return {
        map = map,
        overworld = overworld,
        cleanup = function(self)
            shaderCleanup()
            hsv:release()
        end
    }
end

return ____exports