+                 zipWith (\r a -> toJExpr r |= a) regsFromR1 as'

+-- | Build functions to quickly lookup apply functions

+--  h$apply(r << 8 | n) = function application for r regs, n args

+--  h$paps(r)           = partial application for r registers (number of args is in the object)

+  do paps_fun <- jFunction (name hdPapsStr) \(MkSolo i) -> pure $ SwitchStat i (map case_pap specPap) (returnS hdPapGen)

+     apply_fun <- jFunction (name hdApplyStr) \(MkSolo i) -> pure $ SwitchStat i (mapMaybe' case_apply applySpec) (returnS hdApGen)

+       [ paps_fun

+       , apply_fun

+    case_apply :: ApplySpec -> Maybe (JStgExpr,JStgStat)

+    case_apply spec = case specConv spec of

+      StackConv -> Just (specTagExpr spec, returnS (specApplyExpr spec))

+      RegsConv  -> Nothing

+    case_pap :: Int -> (JStgExpr, JStgStat)

+    case_pap p = (toJExpr p,  returnS $ global (mkFastString (hdPap_ ++ show p)))

+                         , newAp |= ApplExpr hdApply [newTag]

+                         , p      |= ApplExpr hdPaps [given_regs]

+                  , ap |= ApplExpr hdApply [tag]

+                , newAp |= ApplExpr hdApply [newTag]

+                  [ p |= ApplExpr hdPaps [myRegs]

+             let max_low_reg = regNumber maxLowReg

+                 low_regs = [max_low_reg, max_low_reg-1..2] -- R1 isn't used for arguments

+                 pushReg :: Int -> (JStgExpr, JStgStat)

+                 pushReg r = (toJExpr r,  stack .! (sp - toJExpr (r - 2)) |= jsReg r)

+             in return $ mconcat $

+                  [ regs |= tag .>>. 8

+                  , sp |= sp + regs

+                    -- increment the number of regs by 1, so that it matches register

+                    -- numbers (R1 is not used for args)

+                  , postIncrS regs

+                    -- copy high registers with a loop

+                  , WhileStat False (regs .>. toJExpr max_low_reg) $ mconcat

+                      -- rN stored in stack[sp - N - 2] so that r2 is stored in stack[sp], etc.

+                      [ stack .! (sp - regs - 2) |= highReg_expr regs

+                      , postDecrS regs

+                      ]

+                  , SwitchStat regs (map pushReg low_regs) mempty

+                  ]

+             , newAp |= ApplExpr hdApply [(toJExpr nargs-arity0).|.((toJExpr nvars-rs).<<.8)]

+                , stack .! sp |= ApplExpr hdApply [(rsRemain.<<.8).|. (toJExpr nargs - mask8 arity)]

+             , case r of

+                0 -> mempty -- in pap_0 we don't shift any register

+                _ -> moveBy extra

+    moveBy extra =

+      let max_low_reg = regNumber maxLowReg

+          low_regs = [max_low_reg, max_low_reg-1..2] -- R1 isn't used for arguments

+          move_case m = (toJExpr m, jsReg (m+r) |= jsReg m)

+      in mconcat

+          [ -- increment the number of args by 1, so that it matches register

+            -- numbers (R1 is not used for args)

+            postIncrS extra

+            -- copy high registers with a loop

+          ,  WhileStat False (extra .>. toJExpr max_low_reg) $ mconcat

+              [ highReg_expr (extra + toJExpr r) |= highReg_expr extra

+              , postDecrS extra

+              ]

+            -- then copy low registers with a case

+          , SwitchStat extra (map move_case low_regs) mempty

+          ]

+

+                -- shift newly applied arguments into appropriate registers

+                -- load stored arguments into lowest argument registers (i.e. starting from R2)

+      let prop n = d .^ (mkFastString ("d" ++ show n))

+          loadOwnArg n = (toJExpr n, jsReg n |= prop n)

+          max_low_reg = regNumber maxLowReg

+          low_regs = [max_low_reg, max_low_reg-1..2] -- R1 isn't used for arguments

+      in  mconcat

+            [ -- increment the number of args by 1, so that it matches register

+              -- numbers (R1 is not used for args) and PAP fields (starting from d2)

+              postIncrS r

+              -- copy high registers with a loop

+            ,  WhileStat False (r .>. toJExpr max_low_reg) $ mconcat

+                [ highReg_expr r |= (d .! (jString (fsLit "d") + r))

+                , postDecrS r

+                ]

+              -- then copy low registers with a case.

+            , SwitchStat r (map loadOwnArg low_regs) mempty

+            ]

+                       <> BreakStat Nothing)

+    return (declAssignAll args' (jsRegsFrom startReg))

+                  $ ctxSetTarget (assocIdExprs bnd jsRegsFromR1)

+      load          <- flip assignAll jsRegsFromR1 . map toJExpr <$> identsForId e

+{-# LANGUAGE PatternSynonyms #-}

+  , pattern R1, pattern R2, pattern R3, pattern R4

+  , regsFromTo

+  , jsRegsFrom

+  , regNumber

+  , highReg

+  , highReg_expr

+  , maxLowReg

+  , minHighReg

+  , lowRegsCount

+  , lowRegsIdents

+import GHC.Utils.Panic.Plain

+newtype StgReg

+  = StgReg Int

+  deriving (Eq,Ord,Ix)

+

+pattern R1, R2, R3, R4 :: StgReg

+pattern R1 = StgReg 0

+pattern R2 = StgReg 1

+pattern R3 = StgReg 2

+pattern R4 = StgReg 3

+  toJExpr r = register r

+-- | 1-indexed register number (R1 has index 1)

+regNumber :: StgReg -> Int

+regNumber (StgReg r) = r+1

+-- | StgReg from 1-indexed number

+regFromNumber :: Int -> StgReg

+regFromNumber r = assert (r >= 1) $ StgReg (r-1)

+regsFromTo :: StgReg -> StgReg -> [StgReg]

+regsFromTo (StgReg x) (StgReg y) = map StgReg [x .. y]

+-- | Register expression from its 1-indexed index

+jsReg r = toJExpr (regFromNumber r)

+

+minReg :: StgReg

+minReg = R1

+maxReg :: StgReg

+maxReg = regFromNumber maxBound

+lowRegsCount :: Int

+lowRegsCount = 31

+

+maxLowReg :: StgReg

+maxLowReg = regFromNumber lowRegsCount

+

+-- | First register stored in h$regs array instead of having its own top-level

+-- variable

+minHighReg :: StgReg

+minHighReg = case maxLowReg of

+  StgReg r -> StgReg (r+1)

+regsFromR1 = regsFromTo R1 maxReg ++ repeat (panic "StgToJS: code requires too many registers")

+-- | List of registers, starting from given reg as JExpr

+jsRegsFrom :: StgReg -> [JStgExpr]

+jsRegsFrom (StgReg n) = drop n jsRegsFromR1

+

+-- | High register

+highReg :: Int -> JStgExpr

+highReg r = assert (r >= regNumber minHighReg) $ IdxExpr hdRegs (toJExpr (r - regNumber minHighReg))

+

+-- | High register indexing with a JS expression

+highReg_expr :: JStgExpr -> JStgExpr

+highReg_expr r = IdxExpr hdRegs (r - toJExpr (regNumber minHighReg))

+

+

+lowRegs :: [StgReg]

+lowRegs = regsFromTo minReg maxLowReg

+

+lowRegsIdents :: [Ident]

+lowRegsIdents = map reg_to_ident lowRegs

+  where

+    -- low regs are named h$r1, h$r2, etc.

+    reg_to_ident r = name (mkFastString (unpackFS hdStr ++ "r" ++ show (regNumber r)))

+

+-- | Given a register, return the JS syntax object representing that register

+register :: StgReg -> JStgExpr

+register i

+  | i <= maxCachedReg = register_cache ! i -- Expressions of common registers are cached.

+  | otherwise         = make_high_reg i    -- Expression of higher registers are made on the fly

+

+maxCachedReg :: StgReg

+maxCachedReg = regFromNumber 128

+

+-- cache JExpr representing StgReg

+register_cache :: Array StgReg JStgExpr

+register_cache = listArray (minReg, maxCachedReg) (map (global . identFS) lowRegsIdents ++ map make_high_reg (regsFromTo minHighReg maxCachedReg))

+

+-- | Make h$regs[XXX] expression for the register

+make_high_reg :: StgReg -> JStgExpr

+make_high_reg r = highReg (regNumber r)

+    [ jFunction' hdResetRegisters  $ return $ mconcat

+        [ -- reset low registers explicitly

+          mconcat (map resetRegister lowRegs)

+          -- reset the whole h$regs array with h$regs.fill(null)

+        , toStat $ ApplExpr (hdRegs .^ "fill") [null_]

+        ]

+              , mconcat (map declReg lowRegsIdents)

+  do getters <- jFunction (name hdGetRegStr) (\(MkSolo n) -> return $ SwitchStat n getRegCases (defaultGetRegCase n))

+     setters <- jFunction (name hdSetRegStr) (\(n,v)      -> return $ SwitchStat n (setRegCases v) (defaultSetRegCase n v))

+    getRegCases         = map (\r -> (toJExpr (regNumber r) , returnS (toJExpr r))) lowRegs

+    defaultGetRegCase n = returnS (highReg_expr n)

+

+    setRegCases v         = map (\r -> (toJExpr (regNumber r), (toJExpr r |= v) <> BreakStat Nothing)) lowRegs

+    defaultSetRegCase n v = highReg_expr n |= v

+test('T26537', normal, compile_and_run, ['-O2 -fregs-graph'])