# Generated by gen.py from UCD 17.0.0. Do not edit.
import Base

def gc.n0(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cc"
    case False{}:
      "Zs"

def gc.n1(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sc"

def gc.n2(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n0(U32.is_lt(c, 32), c)
    case False{}:
      gc.n1(U32.is_lt(c, 36), c)

def gc.n3(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ps"

def gc.n4(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Po"

def gc.n5(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3(U32.is_lt(c, 40), c)
    case False{}:
      gc.n4(U32.is_lt(c, 42), c)

def gc.n6(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2(U32.is_lt(c, 33), c)
    case False{}:
      gc.n5(U32.is_lt(c, 41), c)

def gc.n7(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Po"

def gc.n8(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Po"

def gc.n9(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n7(U32.is_lt(c, 44), c)
    case False{}:
      gc.n8(U32.is_lt(c, 46), c)

def gc.n10(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n11(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Po"

def gc.n12(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n10(U32.is_lt(c, 58), c)
    case False{}:
      gc.n11(U32.is_lt(c, 63), c)

def gc.n13(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n9(U32.is_lt(c, 45), c)
    case False{}:
      gc.n12(U32.is_lt(c, 60), c)

def gc.n14(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n6(U32.is_lt(c, 37), c)
    case False{}:
      gc.n13(U32.is_lt(c, 48), c)

def gc.n15(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ps"

def gc.n16(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pe"

def gc.n17(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n15(U32.is_lt(c, 91), c)
    case False{}:
      gc.n16(U32.is_lt(c, 93), c)

def gc.n18(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Pc"

def gc.n19(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Ll"

def gc.n20(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n18(U32.is_lt(c, 95), c)
    case False{}:
      gc.n19(U32.is_lt(c, 97), c)

def gc.n21(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n17(U32.is_lt(c, 92), c)
    case False{}:
      gc.n20(U32.is_lt(c, 96), c)

def gc.n22(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Sm"

def gc.n23(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Sm"

def gc.n24(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n22(U32.is_lt(c, 124), c)
    case False{}:
      gc.n23(U32.is_lt(c, 126), c)

def gc.n25(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cc"
    case False{}:
      "Zs"

def gc.n26(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sc"

def gc.n27(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n25(U32.is_lt(c, 160), c)
    case False{}:
      gc.n26(U32.is_lt(c, 162), c)

def gc.n28(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n24(U32.is_lt(c, 125), c)
    case False{}:
      gc.n27(U32.is_lt(c, 161), c)

def gc.n29(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n21(U32.is_lt(c, 94), c)
    case False{}:
      gc.n28(U32.is_lt(c, 127), c)

def gc.n30(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n14(U32.is_lt(c, 43), c)
    case False{}:
      gc.n29(U32.is_lt(c, 123), c)

def gc.n31(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Po"

def gc.n32(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "So"

def gc.n33(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n31(U32.is_lt(c, 167), c)
    case False{}:
      gc.n32(U32.is_lt(c, 169), c)

def gc.n34(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Pi"

def gc.n35(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Cf"

def gc.n36(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n34(U32.is_lt(c, 171), c)
    case False{}:
      gc.n35(U32.is_lt(c, 173), c)

def gc.n37(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n33(U32.is_lt(c, 168), c)
    case False{}:
      gc.n36(U32.is_lt(c, 172), c)

def gc.n38(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sk"

def gc.n39(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n40(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n38(U32.is_lt(c, 175), c)
    case False{}:
      gc.n39(U32.is_lt(c, 177), c)

def gc.n41(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Sk"

def gc.n42(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Po"

def gc.n43(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n41(U32.is_lt(c, 180), c)
    case False{}:
      gc.n42(U32.is_lt(c, 182), c)

def gc.n44(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n40(U32.is_lt(c, 176), c)
    case False{}:
      gc.n43(U32.is_lt(c, 181), c)

def gc.n45(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n37(U32.is_lt(c, 170), c)
    case False{}:
      gc.n44(U32.is_lt(c, 178), c)

def gc.n46(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "No"

def gc.n47(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Pf"

def gc.n48(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n46(U32.is_lt(c, 185), c)
    case False{}:
      gc.n47(U32.is_lt(c, 187), c)

def gc.n49(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Po"

def gc.n50(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Sm"

def gc.n51(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n49(U32.is_lt(c, 191), c)
    case False{}:
      gc.n50(U32.is_lt(c, 215), c)

def gc.n52(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n48(U32.is_lt(c, 186), c)
    case False{}:
      gc.n51(U32.is_lt(c, 192), c)

def gc.n53(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n54(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ll"

def gc.n55(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n53(U32.is_lt(c, 223), c)
    case False{}:
      gc.n54(U32.is_lt(c, 248), c)

def gc.n56(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n57(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n58(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n56(U32.is_lt(c, 257), c)
    case False{}:
      gc.n57(U32.is_lt(c, 259), c)

def gc.n59(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n55(U32.is_lt(c, 247), c)
    case False{}:
      gc.n58(U32.is_lt(c, 258), c)

def gc.n60(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n52(U32.is_lt(c, 188), c)
    case False{}:
      gc.n59(U32.is_lt(c, 256), c)

def gc.n61(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n45(U32.is_lt(c, 174), c)
    case False{}:
      gc.n60(U32.is_lt(c, 216), c)

def gc.n62(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n30(U32.is_lt(c, 65), c)
    case False{}:
      gc.n61(U32.is_lt(c, 184), c)

def gc.n63(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n64(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n65(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n63(U32.is_lt(c, 261), c)
    case False{}:
      gc.n64(U32.is_lt(c, 263), c)

def gc.n66(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n67(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n68(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n66(U32.is_lt(c, 265), c)
    case False{}:
      gc.n67(U32.is_lt(c, 267), c)

def gc.n69(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n65(U32.is_lt(c, 262), c)
    case False{}:
      gc.n68(U32.is_lt(c, 266), c)

def gc.n70(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n71(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n72(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n70(U32.is_lt(c, 269), c)
    case False{}:
      gc.n71(U32.is_lt(c, 271), c)

def gc.n73(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n74(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n75(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n73(U32.is_lt(c, 273), c)
    case False{}:
      gc.n74(U32.is_lt(c, 275), c)

def gc.n76(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n72(U32.is_lt(c, 270), c)
    case False{}:
      gc.n75(U32.is_lt(c, 274), c)

def gc.n77(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n69(U32.is_lt(c, 264), c)
    case False{}:
      gc.n76(U32.is_lt(c, 272), c)

def gc.n78(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n79(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n80(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n78(U32.is_lt(c, 277), c)
    case False{}:
      gc.n79(U32.is_lt(c, 279), c)

def gc.n81(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n82(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n83(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n81(U32.is_lt(c, 281), c)
    case False{}:
      gc.n82(U32.is_lt(c, 283), c)

def gc.n84(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n80(U32.is_lt(c, 278), c)
    case False{}:
      gc.n83(U32.is_lt(c, 282), c)

def gc.n85(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n86(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n87(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n85(U32.is_lt(c, 285), c)
    case False{}:
      gc.n86(U32.is_lt(c, 287), c)

def gc.n88(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n89(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n90(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n88(U32.is_lt(c, 289), c)
    case False{}:
      gc.n89(U32.is_lt(c, 291), c)

def gc.n91(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n87(U32.is_lt(c, 286), c)
    case False{}:
      gc.n90(U32.is_lt(c, 290), c)

def gc.n92(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n84(U32.is_lt(c, 280), c)
    case False{}:
      gc.n91(U32.is_lt(c, 288), c)

def gc.n93(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n77(U32.is_lt(c, 268), c)
    case False{}:
      gc.n92(U32.is_lt(c, 284), c)

def gc.n94(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n95(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n96(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n94(U32.is_lt(c, 293), c)
    case False{}:
      gc.n95(U32.is_lt(c, 295), c)

def gc.n97(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n98(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n99(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n97(U32.is_lt(c, 297), c)
    case False{}:
      gc.n98(U32.is_lt(c, 299), c)

def gc.n100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n96(U32.is_lt(c, 294), c)
    case False{}:
      gc.n99(U32.is_lt(c, 298), c)

def gc.n101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n101(U32.is_lt(c, 301), c)
    case False{}:
      gc.n102(U32.is_lt(c, 303), c)

def gc.n104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n104(U32.is_lt(c, 305), c)
    case False{}:
      gc.n105(U32.is_lt(c, 307), c)

def gc.n107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n103(U32.is_lt(c, 302), c)
    case False{}:
      gc.n106(U32.is_lt(c, 306), c)

def gc.n108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n100(U32.is_lt(c, 296), c)
    case False{}:
      gc.n107(U32.is_lt(c, 304), c)

def gc.n109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n109(U32.is_lt(c, 309), c)
    case False{}:
      gc.n110(U32.is_lt(c, 311), c)

def gc.n112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n112(U32.is_lt(c, 314), c)
    case False{}:
      gc.n113(U32.is_lt(c, 316), c)

def gc.n115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n111(U32.is_lt(c, 310), c)
    case False{}:
      gc.n114(U32.is_lt(c, 315), c)

def gc.n116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n116(U32.is_lt(c, 318), c)
    case False{}:
      gc.n117(U32.is_lt(c, 320), c)

def gc.n119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n120(U32.is_lt(c, 325), c)

def gc.n122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n119(U32.is_lt(c, 322), c)
    case False{}:
      gc.n121(U32.is_lt(c, 324), c)

def gc.n123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n118(U32.is_lt(c, 319), c)
    case False{}:
      gc.n122(U32.is_lt(c, 323), c)

def gc.n124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n115(U32.is_lt(c, 313), c)
    case False{}:
      gc.n123(U32.is_lt(c, 321), c)

def gc.n125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n108(U32.is_lt(c, 300), c)
    case False{}:
      gc.n124(U32.is_lt(c, 317), c)

def gc.n126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n93(U32.is_lt(c, 276), c)
    case False{}:
      gc.n125(U32.is_lt(c, 308), c)

def gc.n127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n62(U32.is_lt(c, 166), c)
    case False{}:
      gc.n126(U32.is_lt(c, 292), c)

def gc.n128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n128(U32.is_lt(c, 327), c)
    case False{}:
      gc.n129(U32.is_lt(c, 330), c)

def gc.n131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n131(U32.is_lt(c, 332), c)
    case False{}:
      gc.n132(U32.is_lt(c, 334), c)

def gc.n134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n130(U32.is_lt(c, 328), c)
    case False{}:
      gc.n133(U32.is_lt(c, 333), c)

def gc.n135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n135(U32.is_lt(c, 336), c)
    case False{}:
      gc.n136(U32.is_lt(c, 338), c)

def gc.n138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n138(U32.is_lt(c, 340), c)
    case False{}:
      gc.n139(U32.is_lt(c, 342), c)

def gc.n141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n137(U32.is_lt(c, 337), c)
    case False{}:
      gc.n140(U32.is_lt(c, 341), c)

def gc.n142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n134(U32.is_lt(c, 331), c)
    case False{}:
      gc.n141(U32.is_lt(c, 339), c)

def gc.n143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n143(U32.is_lt(c, 344), c)
    case False{}:
      gc.n144(U32.is_lt(c, 346), c)

def gc.n146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n146(U32.is_lt(c, 348), c)
    case False{}:
      gc.n147(U32.is_lt(c, 350), c)

def gc.n149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n145(U32.is_lt(c, 345), c)
    case False{}:
      gc.n148(U32.is_lt(c, 349), c)

def gc.n150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n150(U32.is_lt(c, 352), c)
    case False{}:
      gc.n151(U32.is_lt(c, 354), c)

def gc.n153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n153(U32.is_lt(c, 356), c)
    case False{}:
      gc.n154(U32.is_lt(c, 358), c)

def gc.n156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n152(U32.is_lt(c, 353), c)
    case False{}:
      gc.n155(U32.is_lt(c, 357), c)

def gc.n157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n149(U32.is_lt(c, 347), c)
    case False{}:
      gc.n156(U32.is_lt(c, 355), c)

def gc.n158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n142(U32.is_lt(c, 335), c)
    case False{}:
      gc.n157(U32.is_lt(c, 351), c)

def gc.n159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n159(U32.is_lt(c, 360), c)
    case False{}:
      gc.n160(U32.is_lt(c, 362), c)

def gc.n162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n162(U32.is_lt(c, 364), c)
    case False{}:
      gc.n163(U32.is_lt(c, 366), c)

def gc.n165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n161(U32.is_lt(c, 361), c)
    case False{}:
      gc.n164(U32.is_lt(c, 365), c)

def gc.n166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n166(U32.is_lt(c, 368), c)
    case False{}:
      gc.n167(U32.is_lt(c, 370), c)

def gc.n169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n169(U32.is_lt(c, 372), c)
    case False{}:
      gc.n170(U32.is_lt(c, 374), c)

def gc.n172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n168(U32.is_lt(c, 369), c)
    case False{}:
      gc.n171(U32.is_lt(c, 373), c)

def gc.n173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n165(U32.is_lt(c, 363), c)
    case False{}:
      gc.n172(U32.is_lt(c, 371), c)

def gc.n174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n174(U32.is_lt(c, 376), c)
    case False{}:
      gc.n175(U32.is_lt(c, 379), c)

def gc.n177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n177(U32.is_lt(c, 381), c)
    case False{}:
      gc.n178(U32.is_lt(c, 385), c)

def gc.n180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n176(U32.is_lt(c, 378), c)
    case False{}:
      gc.n179(U32.is_lt(c, 382), c)

def gc.n181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n181(U32.is_lt(c, 388), c)
    case False{}:
      gc.n182(U32.is_lt(c, 390), c)

def gc.n184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      gc.n185(U32.is_lt(c, 402), c)

def gc.n187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n184(U32.is_lt(c, 393), c)
    case False{}:
      gc.n186(U32.is_lt(c, 398), c)

def gc.n188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n183(U32.is_lt(c, 389), c)
    case False{}:
      gc.n187(U32.is_lt(c, 396), c)

def gc.n189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n180(U32.is_lt(c, 380), c)
    case False{}:
      gc.n188(U32.is_lt(c, 392), c)

def gc.n190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n173(U32.is_lt(c, 367), c)
    case False{}:
      gc.n189(U32.is_lt(c, 387), c)

def gc.n191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n158(U32.is_lt(c, 343), c)
    case False{}:
      gc.n190(U32.is_lt(c, 375), c)

def gc.n192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n192(U32.is_lt(c, 405), c)
    case False{}:
      gc.n193(U32.is_lt(c, 409), c)

def gc.n195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n195(U32.is_lt(c, 414), c)
    case False{}:
      gc.n196(U32.is_lt(c, 417), c)

def gc.n198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n194(U32.is_lt(c, 406), c)
    case False{}:
      gc.n197(U32.is_lt(c, 415), c)

def gc.n199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n199(U32.is_lt(c, 419), c)
    case False{}:
      gc.n200(U32.is_lt(c, 421), c)

def gc.n202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n202(U32.is_lt(c, 424), c)
    case False{}:
      gc.n203(U32.is_lt(c, 426), c)

def gc.n205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n201(U32.is_lt(c, 420), c)
    case False{}:
      gc.n204(U32.is_lt(c, 425), c)

def gc.n206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n198(U32.is_lt(c, 412), c)
    case False{}:
      gc.n205(U32.is_lt(c, 422), c)

def gc.n207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n207(U32.is_lt(c, 429), c)
    case False{}:
      gc.n208(U32.is_lt(c, 432), c)

def gc.n210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n210(U32.is_lt(c, 436), c)
    case False{}:
      gc.n211(U32.is_lt(c, 438), c)

def gc.n213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n209(U32.is_lt(c, 430), c)
    case False{}:
      gc.n212(U32.is_lt(c, 437), c)

def gc.n214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lu"

def gc.n216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n214(U32.is_lt(c, 441), c)
    case False{}:
      gc.n215(U32.is_lt(c, 444), c)

def gc.n217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Lt"

def gc.n219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n217(U32.is_lt(c, 448), c)
    case False{}:
      gc.n218(U32.is_lt(c, 453), c)

def gc.n220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n216(U32.is_lt(c, 443), c)
    case False{}:
      gc.n219(U32.is_lt(c, 452), c)

def gc.n221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n213(U32.is_lt(c, 433), c)
    case False{}:
      gc.n220(U32.is_lt(c, 445), c)

def gc.n222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n206(U32.is_lt(c, 418), c)
    case False{}:
      gc.n221(U32.is_lt(c, 439), c)

def gc.n223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lt"
    case False{}:
      "Ll"

def gc.n225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n223(U32.is_lt(c, 455), c)
    case False{}:
      gc.n224(U32.is_lt(c, 457), c)

def gc.n226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Lt"

def gc.n227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n226(U32.is_lt(c, 459), c)
    case False{}:
      gc.n227(U32.is_lt(c, 461), c)

def gc.n229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n225(U32.is_lt(c, 456), c)
    case False{}:
      gc.n228(U32.is_lt(c, 460), c)

def gc.n230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n230(U32.is_lt(c, 463), c)
    case False{}:
      gc.n231(U32.is_lt(c, 465), c)

def gc.n233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n233(U32.is_lt(c, 467), c)
    case False{}:
      gc.n234(U32.is_lt(c, 469), c)

def gc.n236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n232(U32.is_lt(c, 464), c)
    case False{}:
      gc.n235(U32.is_lt(c, 468), c)

def gc.n237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n229(U32.is_lt(c, 458), c)
    case False{}:
      gc.n236(U32.is_lt(c, 466), c)

def gc.n238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n238(U32.is_lt(c, 471), c)
    case False{}:
      gc.n239(U32.is_lt(c, 473), c)

def gc.n241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n241(U32.is_lt(c, 475), c)
    case False{}:
      gc.n242(U32.is_lt(c, 478), c)

def gc.n244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n240(U32.is_lt(c, 472), c)
    case False{}:
      gc.n243(U32.is_lt(c, 476), c)

def gc.n245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n245(U32.is_lt(c, 480), c)
    case False{}:
      gc.n246(U32.is_lt(c, 482), c)

def gc.n248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      gc.n249(U32.is_lt(c, 487), c)

def gc.n251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n248(U32.is_lt(c, 484), c)
    case False{}:
      gc.n250(U32.is_lt(c, 486), c)

def gc.n252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n247(U32.is_lt(c, 481), c)
    case False{}:
      gc.n251(U32.is_lt(c, 485), c)

def gc.n253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n244(U32.is_lt(c, 474), c)
    case False{}:
      gc.n252(U32.is_lt(c, 483), c)

def gc.n254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n237(U32.is_lt(c, 462), c)
    case False{}:
      gc.n253(U32.is_lt(c, 479), c)

def gc.n255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n222(U32.is_lt(c, 428), c)
    case False{}:
      gc.n254(U32.is_lt(c, 470), c)

def gc.n256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n191(U32.is_lt(c, 359), c)
    case False{}:
      gc.n255(U32.is_lt(c, 454), c)

def gc.n257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n127(U32.is_lt(c, 260), c)
    case False{}:
      gc.n256(U32.is_lt(c, 403), c)

def gc.n258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n258(U32.is_lt(c, 489), c)
    case False{}:
      gc.n259(U32.is_lt(c, 491), c)

def gc.n261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n261(U32.is_lt(c, 493), c)
    case False{}:
      gc.n262(U32.is_lt(c, 495), c)

def gc.n264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n260(U32.is_lt(c, 490), c)
    case False{}:
      gc.n263(U32.is_lt(c, 494), c)

def gc.n265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Lt"

def gc.n266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n265(U32.is_lt(c, 498), c)
    case False{}:
      gc.n266(U32.is_lt(c, 500), c)

def gc.n268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n268(U32.is_lt(c, 502), c)
    case False{}:
      gc.n269(U32.is_lt(c, 506), c)

def gc.n271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n267(U32.is_lt(c, 499), c)
    case False{}:
      gc.n270(U32.is_lt(c, 505), c)

def gc.n272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n264(U32.is_lt(c, 492), c)
    case False{}:
      gc.n271(U32.is_lt(c, 501), c)

def gc.n273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n273(U32.is_lt(c, 508), c)
    case False{}:
      gc.n274(U32.is_lt(c, 510), c)

def gc.n276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n276(U32.is_lt(c, 512), c)
    case False{}:
      gc.n277(U32.is_lt(c, 514), c)

def gc.n279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n275(U32.is_lt(c, 509), c)
    case False{}:
      gc.n278(U32.is_lt(c, 513), c)

def gc.n280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n280(U32.is_lt(c, 516), c)
    case False{}:
      gc.n281(U32.is_lt(c, 518), c)

def gc.n283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n283(U32.is_lt(c, 520), c)
    case False{}:
      gc.n284(U32.is_lt(c, 522), c)

def gc.n286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n282(U32.is_lt(c, 517), c)
    case False{}:
      gc.n285(U32.is_lt(c, 521), c)

def gc.n287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n279(U32.is_lt(c, 511), c)
    case False{}:
      gc.n286(U32.is_lt(c, 519), c)

def gc.n288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n272(U32.is_lt(c, 497), c)
    case False{}:
      gc.n287(U32.is_lt(c, 515), c)

def gc.n289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n289(U32.is_lt(c, 524), c)
    case False{}:
      gc.n290(U32.is_lt(c, 526), c)

def gc.n292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n292(U32.is_lt(c, 528), c)
    case False{}:
      gc.n293(U32.is_lt(c, 530), c)

def gc.n295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n291(U32.is_lt(c, 525), c)
    case False{}:
      gc.n294(U32.is_lt(c, 529), c)

def gc.n296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n296(U32.is_lt(c, 532), c)
    case False{}:
      gc.n297(U32.is_lt(c, 534), c)

def gc.n299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n299(U32.is_lt(c, 536), c)
    case False{}:
      gc.n300(U32.is_lt(c, 538), c)

def gc.n302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n298(U32.is_lt(c, 533), c)
    case False{}:
      gc.n301(U32.is_lt(c, 537), c)

def gc.n303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n295(U32.is_lt(c, 527), c)
    case False{}:
      gc.n302(U32.is_lt(c, 535), c)

def gc.n304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n304(U32.is_lt(c, 540), c)
    case False{}:
      gc.n305(U32.is_lt(c, 542), c)

def gc.n307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n307(U32.is_lt(c, 544), c)
    case False{}:
      gc.n308(U32.is_lt(c, 546), c)

def gc.n310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n306(U32.is_lt(c, 541), c)
    case False{}:
      gc.n309(U32.is_lt(c, 545), c)

def gc.n311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n311(U32.is_lt(c, 548), c)
    case False{}:
      gc.n312(U32.is_lt(c, 550), c)

def gc.n314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n314(U32.is_lt(c, 552), c)
    case False{}:
      gc.n315(U32.is_lt(c, 554), c)

def gc.n317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n313(U32.is_lt(c, 549), c)
    case False{}:
      gc.n316(U32.is_lt(c, 553), c)

def gc.n318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n310(U32.is_lt(c, 543), c)
    case False{}:
      gc.n317(U32.is_lt(c, 551), c)

def gc.n319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n303(U32.is_lt(c, 531), c)
    case False{}:
      gc.n318(U32.is_lt(c, 547), c)

def gc.n320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n288(U32.is_lt(c, 507), c)
    case False{}:
      gc.n319(U32.is_lt(c, 539), c)

def gc.n321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n321(U32.is_lt(c, 556), c)
    case False{}:
      gc.n322(U32.is_lt(c, 558), c)

def gc.n324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n324(U32.is_lt(c, 560), c)
    case False{}:
      gc.n325(U32.is_lt(c, 562), c)

def gc.n327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n323(U32.is_lt(c, 557), c)
    case False{}:
      gc.n326(U32.is_lt(c, 561), c)

def gc.n328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n328(U32.is_lt(c, 570), c)
    case False{}:
      gc.n329(U32.is_lt(c, 573), c)

def gc.n331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n331(U32.is_lt(c, 577), c)
    case False{}:
      gc.n332(U32.is_lt(c, 579), c)

def gc.n334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n330(U32.is_lt(c, 572), c)
    case False{}:
      gc.n333(U32.is_lt(c, 578), c)

def gc.n335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n327(U32.is_lt(c, 559), c)
    case False{}:
      gc.n334(U32.is_lt(c, 575), c)

def gc.n336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n336(U32.is_lt(c, 584), c)
    case False{}:
      gc.n337(U32.is_lt(c, 586), c)

def gc.n339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n339(U32.is_lt(c, 588), c)
    case False{}:
      gc.n340(U32.is_lt(c, 590), c)

def gc.n342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n338(U32.is_lt(c, 585), c)
    case False{}:
      gc.n341(U32.is_lt(c, 589), c)

def gc.n343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lm"

def gc.n345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n343(U32.is_lt(c, 660), c)
    case False{}:
      gc.n344(U32.is_lt(c, 688), c)

def gc.n346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lm"

def gc.n347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lm"

def gc.n348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n346(U32.is_lt(c, 710), c)
    case False{}:
      gc.n347(U32.is_lt(c, 736), c)

def gc.n349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n345(U32.is_lt(c, 662), c)
    case False{}:
      gc.n348(U32.is_lt(c, 722), c)

def gc.n350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n342(U32.is_lt(c, 587), c)
    case False{}:
      gc.n349(U32.is_lt(c, 706), c)

def gc.n351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n335(U32.is_lt(c, 563), c)
    case False{}:
      gc.n350(U32.is_lt(c, 591), c)

def gc.n352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lm"

def gc.n353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lm"

def gc.n354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n352(U32.is_lt(c, 748), c)
    case False{}:
      gc.n353(U32.is_lt(c, 750), c)

def gc.n355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Mn"

def gc.n356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n355(U32.is_lt(c, 768), c)
    case False{}:
      gc.n356(U32.is_lt(c, 881), c)

def gc.n358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n354(U32.is_lt(c, 749), c)
    case False{}:
      gc.n357(U32.is_lt(c, 880), c)

def gc.n359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Sk"

def gc.n361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n359(U32.is_lt(c, 883), c)
    case False{}:
      gc.n360(U32.is_lt(c, 885), c)

def gc.n362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n362(U32.is_lt(c, 887), c)
    case False{}:
      gc.n363(U32.is_lt(c, 890), c)

def gc.n365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n361(U32.is_lt(c, 884), c)
    case False{}:
      gc.n364(U32.is_lt(c, 888), c)

def gc.n366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n358(U32.is_lt(c, 751), c)
    case False{}:
      gc.n365(U32.is_lt(c, 886), c)

def gc.n367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Po"

def gc.n368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n367(U32.is_lt(c, 894), c)
    case False{}:
      gc.n368(U32.is_lt(c, 896), c)

def gc.n370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lu"

def gc.n371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lu"

def gc.n372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n370(U32.is_lt(c, 902), c)
    case False{}:
      gc.n371(U32.is_lt(c, 904), c)

def gc.n373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n369(U32.is_lt(c, 895), c)
    case False{}:
      gc.n372(U32.is_lt(c, 903), c)

def gc.n374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n374(U32.is_lt(c, 908), c)
    case False{}:
      gc.n375(U32.is_lt(c, 910), c)

def gc.n377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n378(U32.is_lt(c, 940), c)

def gc.n380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n377(U32.is_lt(c, 913), c)
    case False{}:
      gc.n379(U32.is_lt(c, 931), c)

def gc.n381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n376(U32.is_lt(c, 909), c)
    case False{}:
      gc.n380(U32.is_lt(c, 930), c)

def gc.n382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n373(U32.is_lt(c, 900), c)
    case False{}:
      gc.n381(U32.is_lt(c, 912), c)

def gc.n383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n366(U32.is_lt(c, 882), c)
    case False{}:
      gc.n382(U32.is_lt(c, 907), c)

def gc.n384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n351(U32.is_lt(c, 583), c)
    case False{}:
      gc.n383(U32.is_lt(c, 891), c)

def gc.n385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n320(U32.is_lt(c, 523), c)
    case False{}:
      gc.n384(U32.is_lt(c, 741), c)

def gc.n386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n386(U32.is_lt(c, 976), c)
    case False{}:
      gc.n387(U32.is_lt(c, 981), c)

def gc.n389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n389(U32.is_lt(c, 985), c)
    case False{}:
      gc.n390(U32.is_lt(c, 987), c)

def gc.n392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n388(U32.is_lt(c, 978), c)
    case False{}:
      gc.n391(U32.is_lt(c, 986), c)

def gc.n393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n393(U32.is_lt(c, 989), c)
    case False{}:
      gc.n394(U32.is_lt(c, 991), c)

def gc.n396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n396(U32.is_lt(c, 993), c)
    case False{}:
      gc.n397(U32.is_lt(c, 995), c)

def gc.n399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n395(U32.is_lt(c, 990), c)
    case False{}:
      gc.n398(U32.is_lt(c, 994), c)

def gc.n400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n392(U32.is_lt(c, 984), c)
    case False{}:
      gc.n399(U32.is_lt(c, 992), c)

def gc.n401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n401(U32.is_lt(c, 997), c)
    case False{}:
      gc.n402(U32.is_lt(c, 999), c)

def gc.n404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n404(U32.is_lt(c, 1001), c)
    case False{}:
      gc.n405(U32.is_lt(c, 1003), c)

def gc.n407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n403(U32.is_lt(c, 998), c)
    case False{}:
      gc.n406(U32.is_lt(c, 1002), c)

def gc.n408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n408(U32.is_lt(c, 1005), c)
    case False{}:
      gc.n409(U32.is_lt(c, 1007), c)

def gc.n411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Lu"

def gc.n413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n411(U32.is_lt(c, 1013), c)
    case False{}:
      gc.n412(U32.is_lt(c, 1015), c)

def gc.n414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n410(U32.is_lt(c, 1006), c)
    case False{}:
      gc.n413(U32.is_lt(c, 1014), c)

def gc.n415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n407(U32.is_lt(c, 1000), c)
    case False{}:
      gc.n414(U32.is_lt(c, 1012), c)

def gc.n416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n400(U32.is_lt(c, 988), c)
    case False{}:
      gc.n415(U32.is_lt(c, 1004), c)

def gc.n417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n417(U32.is_lt(c, 1017), c)
    case False{}:
      gc.n418(U32.is_lt(c, 1021), c)

def gc.n420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n420(U32.is_lt(c, 1120), c)
    case False{}:
      gc.n421(U32.is_lt(c, 1122), c)

def gc.n423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n419(U32.is_lt(c, 1019), c)
    case False{}:
      gc.n422(U32.is_lt(c, 1121), c)

def gc.n424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n424(U32.is_lt(c, 1124), c)
    case False{}:
      gc.n425(U32.is_lt(c, 1126), c)

def gc.n427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n427(U32.is_lt(c, 1128), c)
    case False{}:
      gc.n428(U32.is_lt(c, 1130), c)

def gc.n430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n426(U32.is_lt(c, 1125), c)
    case False{}:
      gc.n429(U32.is_lt(c, 1129), c)

def gc.n431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n423(U32.is_lt(c, 1072), c)
    case False{}:
      gc.n430(U32.is_lt(c, 1127), c)

def gc.n432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n432(U32.is_lt(c, 1132), c)
    case False{}:
      gc.n433(U32.is_lt(c, 1134), c)

def gc.n435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n435(U32.is_lt(c, 1136), c)
    case False{}:
      gc.n436(U32.is_lt(c, 1138), c)

def gc.n438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n434(U32.is_lt(c, 1133), c)
    case False{}:
      gc.n437(U32.is_lt(c, 1137), c)

def gc.n439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n439(U32.is_lt(c, 1140), c)
    case False{}:
      gc.n440(U32.is_lt(c, 1142), c)

def gc.n442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      gc.n443(U32.is_lt(c, 1147), c)

def gc.n445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n442(U32.is_lt(c, 1144), c)
    case False{}:
      gc.n444(U32.is_lt(c, 1146), c)

def gc.n446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n441(U32.is_lt(c, 1141), c)
    case False{}:
      gc.n445(U32.is_lt(c, 1145), c)

def gc.n447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n438(U32.is_lt(c, 1135), c)
    case False{}:
      gc.n446(U32.is_lt(c, 1143), c)

def gc.n448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n431(U32.is_lt(c, 1123), c)
    case False{}:
      gc.n447(U32.is_lt(c, 1139), c)

def gc.n449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n416(U32.is_lt(c, 996), c)
    case False{}:
      gc.n448(U32.is_lt(c, 1131), c)

def gc.n450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n450(U32.is_lt(c, 1149), c)
    case False{}:
      gc.n451(U32.is_lt(c, 1151), c)

def gc.n453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n453(U32.is_lt(c, 1153), c)
    case False{}:
      gc.n454(U32.is_lt(c, 1155), c)

def gc.n456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n452(U32.is_lt(c, 1150), c)
    case False{}:
      gc.n455(U32.is_lt(c, 1154), c)

def gc.n457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Me"
    case False{}:
      "Lu"

def gc.n458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n457(U32.is_lt(c, 1162), c)
    case False{}:
      gc.n458(U32.is_lt(c, 1164), c)

def gc.n460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n460(U32.is_lt(c, 1166), c)
    case False{}:
      gc.n461(U32.is_lt(c, 1168), c)

def gc.n463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n459(U32.is_lt(c, 1163), c)
    case False{}:
      gc.n462(U32.is_lt(c, 1167), c)

def gc.n464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n456(U32.is_lt(c, 1152), c)
    case False{}:
      gc.n463(U32.is_lt(c, 1165), c)

def gc.n465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n465(U32.is_lt(c, 1170), c)
    case False{}:
      gc.n466(U32.is_lt(c, 1172), c)

def gc.n468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n468(U32.is_lt(c, 1174), c)
    case False{}:
      gc.n469(U32.is_lt(c, 1176), c)

def gc.n471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n467(U32.is_lt(c, 1171), c)
    case False{}:
      gc.n470(U32.is_lt(c, 1175), c)

def gc.n472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n472(U32.is_lt(c, 1178), c)
    case False{}:
      gc.n473(U32.is_lt(c, 1180), c)

def gc.n475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n475(U32.is_lt(c, 1182), c)
    case False{}:
      gc.n476(U32.is_lt(c, 1184), c)

def gc.n478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n474(U32.is_lt(c, 1179), c)
    case False{}:
      gc.n477(U32.is_lt(c, 1183), c)

def gc.n479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n471(U32.is_lt(c, 1173), c)
    case False{}:
      gc.n478(U32.is_lt(c, 1181), c)

def gc.n480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n464(U32.is_lt(c, 1160), c)
    case False{}:
      gc.n479(U32.is_lt(c, 1177), c)

def gc.n481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n481(U32.is_lt(c, 1186), c)
    case False{}:
      gc.n482(U32.is_lt(c, 1188), c)

def gc.n484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n484(U32.is_lt(c, 1190), c)
    case False{}:
      gc.n485(U32.is_lt(c, 1192), c)

def gc.n487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n483(U32.is_lt(c, 1187), c)
    case False{}:
      gc.n486(U32.is_lt(c, 1191), c)

def gc.n488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n488(U32.is_lt(c, 1194), c)
    case False{}:
      gc.n489(U32.is_lt(c, 1196), c)

def gc.n491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n491(U32.is_lt(c, 1198), c)
    case False{}:
      gc.n492(U32.is_lt(c, 1200), c)

def gc.n494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n490(U32.is_lt(c, 1195), c)
    case False{}:
      gc.n493(U32.is_lt(c, 1199), c)

def gc.n495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n487(U32.is_lt(c, 1189), c)
    case False{}:
      gc.n494(U32.is_lt(c, 1197), c)

def gc.n496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n496(U32.is_lt(c, 1202), c)
    case False{}:
      gc.n497(U32.is_lt(c, 1204), c)

def gc.n499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n499(U32.is_lt(c, 1206), c)
    case False{}:
      gc.n500(U32.is_lt(c, 1208), c)

def gc.n502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n498(U32.is_lt(c, 1203), c)
    case False{}:
      gc.n501(U32.is_lt(c, 1207), c)

def gc.n503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n503(U32.is_lt(c, 1210), c)
    case False{}:
      gc.n504(U32.is_lt(c, 1212), c)

def gc.n506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      gc.n507(U32.is_lt(c, 1218), c)

def gc.n509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n506(U32.is_lt(c, 1214), c)
    case False{}:
      gc.n508(U32.is_lt(c, 1216), c)

def gc.n510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n505(U32.is_lt(c, 1211), c)
    case False{}:
      gc.n509(U32.is_lt(c, 1215), c)

def gc.n511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n502(U32.is_lt(c, 1205), c)
    case False{}:
      gc.n510(U32.is_lt(c, 1213), c)

def gc.n512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n495(U32.is_lt(c, 1193), c)
    case False{}:
      gc.n511(U32.is_lt(c, 1209), c)

def gc.n513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n480(U32.is_lt(c, 1169), c)
    case False{}:
      gc.n512(U32.is_lt(c, 1201), c)

def gc.n514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n449(U32.is_lt(c, 1016), c)
    case False{}:
      gc.n513(U32.is_lt(c, 1185), c)

def gc.n515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n385(U32.is_lt(c, 555), c)
    case False{}:
      gc.n514(U32.is_lt(c, 1148), c)

def gc.n516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n257(U32.is_lt(c, 326), c)
    case False{}:
      gc.n515(U32.is_lt(c, 975), c)

def gc.n517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n517(U32.is_lt(c, 1220), c)
    case False{}:
      gc.n518(U32.is_lt(c, 1222), c)

def gc.n520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n520(U32.is_lt(c, 1224), c)
    case False{}:
      gc.n521(U32.is_lt(c, 1226), c)

def gc.n523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n519(U32.is_lt(c, 1221), c)
    case False{}:
      gc.n522(U32.is_lt(c, 1225), c)

def gc.n524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n524(U32.is_lt(c, 1228), c)
    case False{}:
      gc.n525(U32.is_lt(c, 1230), c)

def gc.n527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n527(U32.is_lt(c, 1233), c)
    case False{}:
      gc.n528(U32.is_lt(c, 1235), c)

def gc.n530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n526(U32.is_lt(c, 1229), c)
    case False{}:
      gc.n529(U32.is_lt(c, 1234), c)

def gc.n531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n523(U32.is_lt(c, 1223), c)
    case False{}:
      gc.n530(U32.is_lt(c, 1232), c)

def gc.n532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n532(U32.is_lt(c, 1237), c)
    case False{}:
      gc.n533(U32.is_lt(c, 1239), c)

def gc.n535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n535(U32.is_lt(c, 1241), c)
    case False{}:
      gc.n536(U32.is_lt(c, 1243), c)

def gc.n538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n534(U32.is_lt(c, 1238), c)
    case False{}:
      gc.n537(U32.is_lt(c, 1242), c)

def gc.n539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n539(U32.is_lt(c, 1245), c)
    case False{}:
      gc.n540(U32.is_lt(c, 1247), c)

def gc.n542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n542(U32.is_lt(c, 1249), c)
    case False{}:
      gc.n543(U32.is_lt(c, 1251), c)

def gc.n545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n541(U32.is_lt(c, 1246), c)
    case False{}:
      gc.n544(U32.is_lt(c, 1250), c)

def gc.n546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n538(U32.is_lt(c, 1240), c)
    case False{}:
      gc.n545(U32.is_lt(c, 1248), c)

def gc.n547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n531(U32.is_lt(c, 1227), c)
    case False{}:
      gc.n546(U32.is_lt(c, 1244), c)

def gc.n548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n548(U32.is_lt(c, 1253), c)
    case False{}:
      gc.n549(U32.is_lt(c, 1255), c)

def gc.n551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n551(U32.is_lt(c, 1257), c)
    case False{}:
      gc.n552(U32.is_lt(c, 1259), c)

def gc.n554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n550(U32.is_lt(c, 1254), c)
    case False{}:
      gc.n553(U32.is_lt(c, 1258), c)

def gc.n555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n555(U32.is_lt(c, 1261), c)
    case False{}:
      gc.n556(U32.is_lt(c, 1263), c)

def gc.n558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n558(U32.is_lt(c, 1265), c)
    case False{}:
      gc.n559(U32.is_lt(c, 1267), c)

def gc.n561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n557(U32.is_lt(c, 1262), c)
    case False{}:
      gc.n560(U32.is_lt(c, 1266), c)

def gc.n562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n554(U32.is_lt(c, 1256), c)
    case False{}:
      gc.n561(U32.is_lt(c, 1264), c)

def gc.n563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n563(U32.is_lt(c, 1269), c)
    case False{}:
      gc.n564(U32.is_lt(c, 1271), c)

def gc.n566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n566(U32.is_lt(c, 1273), c)
    case False{}:
      gc.n567(U32.is_lt(c, 1275), c)

def gc.n569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n565(U32.is_lt(c, 1270), c)
    case False{}:
      gc.n568(U32.is_lt(c, 1274), c)

def gc.n570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n570(U32.is_lt(c, 1277), c)
    case False{}:
      gc.n571(U32.is_lt(c, 1279), c)

def gc.n573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n573(U32.is_lt(c, 1281), c)
    case False{}:
      gc.n574(U32.is_lt(c, 1283), c)

def gc.n576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n572(U32.is_lt(c, 1278), c)
    case False{}:
      gc.n575(U32.is_lt(c, 1282), c)

def gc.n577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n569(U32.is_lt(c, 1272), c)
    case False{}:
      gc.n576(U32.is_lt(c, 1280), c)

def gc.n578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n562(U32.is_lt(c, 1260), c)
    case False{}:
      gc.n577(U32.is_lt(c, 1276), c)

def gc.n579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n547(U32.is_lt(c, 1236), c)
    case False{}:
      gc.n578(U32.is_lt(c, 1268), c)

def gc.n580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n580(U32.is_lt(c, 1285), c)
    case False{}:
      gc.n581(U32.is_lt(c, 1287), c)

def gc.n583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n583(U32.is_lt(c, 1289), c)
    case False{}:
      gc.n584(U32.is_lt(c, 1291), c)

def gc.n586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n582(U32.is_lt(c, 1286), c)
    case False{}:
      gc.n585(U32.is_lt(c, 1290), c)

def gc.n587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n587(U32.is_lt(c, 1293), c)
    case False{}:
      gc.n588(U32.is_lt(c, 1295), c)

def gc.n590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n590(U32.is_lt(c, 1297), c)
    case False{}:
      gc.n591(U32.is_lt(c, 1299), c)

def gc.n593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n589(U32.is_lt(c, 1294), c)
    case False{}:
      gc.n592(U32.is_lt(c, 1298), c)

def gc.n594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n586(U32.is_lt(c, 1288), c)
    case False{}:
      gc.n593(U32.is_lt(c, 1296), c)

def gc.n595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n595(U32.is_lt(c, 1301), c)
    case False{}:
      gc.n596(U32.is_lt(c, 1303), c)

def gc.n598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n598(U32.is_lt(c, 1305), c)
    case False{}:
      gc.n599(U32.is_lt(c, 1307), c)

def gc.n601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n597(U32.is_lt(c, 1302), c)
    case False{}:
      gc.n600(U32.is_lt(c, 1306), c)

def gc.n602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n602(U32.is_lt(c, 1309), c)
    case False{}:
      gc.n603(U32.is_lt(c, 1311), c)

def gc.n605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n605(U32.is_lt(c, 1313), c)
    case False{}:
      gc.n606(U32.is_lt(c, 1315), c)

def gc.n608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n604(U32.is_lt(c, 1310), c)
    case False{}:
      gc.n607(U32.is_lt(c, 1314), c)

def gc.n609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n601(U32.is_lt(c, 1304), c)
    case False{}:
      gc.n608(U32.is_lt(c, 1312), c)

def gc.n610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n594(U32.is_lt(c, 1292), c)
    case False{}:
      gc.n609(U32.is_lt(c, 1308), c)

def gc.n611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n611(U32.is_lt(c, 1317), c)
    case False{}:
      gc.n612(U32.is_lt(c, 1319), c)

def gc.n614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n614(U32.is_lt(c, 1321), c)
    case False{}:
      gc.n615(U32.is_lt(c, 1323), c)

def gc.n617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n613(U32.is_lt(c, 1318), c)
    case False{}:
      gc.n616(U32.is_lt(c, 1322), c)

def gc.n618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n618(U32.is_lt(c, 1325), c)
    case False{}:
      gc.n619(U32.is_lt(c, 1327), c)

def gc.n621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n621(U32.is_lt(c, 1329), c)
    case False{}:
      gc.n622(U32.is_lt(c, 1369), c)

def gc.n624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n620(U32.is_lt(c, 1326), c)
    case False{}:
      gc.n623(U32.is_lt(c, 1367), c)

def gc.n625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n617(U32.is_lt(c, 1320), c)
    case False{}:
      gc.n624(U32.is_lt(c, 1328), c)

def gc.n626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ll"

def gc.n627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n626(U32.is_lt(c, 1376), c)
    case False{}:
      gc.n627(U32.is_lt(c, 1418), c)

def gc.n629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Cn"

def gc.n631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n629(U32.is_lt(c, 1421), c)
    case False{}:
      gc.n630(U32.is_lt(c, 1424), c)

def gc.n632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n628(U32.is_lt(c, 1417), c)
    case False{}:
      gc.n631(U32.is_lt(c, 1423), c)

def gc.n633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Pd"

def gc.n634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n633(U32.is_lt(c, 1470), c)
    case False{}:
      gc.n634(U32.is_lt(c, 1472), c)

def gc.n636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      gc.n637(U32.is_lt(c, 1479), c)

def gc.n639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n636(U32.is_lt(c, 1475), c)
    case False{}:
      gc.n638(U32.is_lt(c, 1478), c)

def gc.n640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n635(U32.is_lt(c, 1471), c)
    case False{}:
      gc.n639(U32.is_lt(c, 1476), c)

def gc.n641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n632(U32.is_lt(c, 1419), c)
    case False{}:
      gc.n640(U32.is_lt(c, 1473), c)

def gc.n642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n625(U32.is_lt(c, 1324), c)
    case False{}:
      gc.n641(U32.is_lt(c, 1425), c)

def gc.n643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n610(U32.is_lt(c, 1300), c)
    case False{}:
      gc.n642(U32.is_lt(c, 1370), c)

def gc.n644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n579(U32.is_lt(c, 1252), c)
    case False{}:
      gc.n643(U32.is_lt(c, 1316), c)

def gc.n645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n645(U32.is_lt(c, 1488), c)
    case False{}:
      gc.n646(U32.is_lt(c, 1519), c)

def gc.n648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Sm"

def gc.n650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n648(U32.is_lt(c, 1525), c)
    case False{}:
      gc.n649(U32.is_lt(c, 1542), c)

def gc.n651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n647(U32.is_lt(c, 1515), c)
    case False{}:
      gc.n650(U32.is_lt(c, 1536), c)

def gc.n652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sc"

def gc.n653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n652(U32.is_lt(c, 1547), c)
    case False{}:
      gc.n653(U32.is_lt(c, 1550), c)

def gc.n655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Po"

def gc.n657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n655(U32.is_lt(c, 1563), c)
    case False{}:
      gc.n656(U32.is_lt(c, 1565), c)

def gc.n658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n654(U32.is_lt(c, 1548), c)
    case False{}:
      gc.n657(U32.is_lt(c, 1564), c)

def gc.n659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n651(U32.is_lt(c, 1523), c)
    case False{}:
      gc.n658(U32.is_lt(c, 1552), c)

def gc.n660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n660(U32.is_lt(c, 1600), c)
    case False{}:
      gc.n661(U32.is_lt(c, 1611), c)

def gc.n663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n663(U32.is_lt(c, 1642), c)
    case False{}:
      gc.n664(U32.is_lt(c, 1648), c)

def gc.n666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n662(U32.is_lt(c, 1601), c)
    case False{}:
      gc.n665(U32.is_lt(c, 1646), c)

def gc.n667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n667(U32.is_lt(c, 1748), c)
    case False{}:
      gc.n668(U32.is_lt(c, 1750), c)

def gc.n670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "So"

def gc.n671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n670(U32.is_lt(c, 1758), c)
    case False{}:
      gc.n671(U32.is_lt(c, 1765), c)

def gc.n673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n669(U32.is_lt(c, 1749), c)
    case False{}:
      gc.n672(U32.is_lt(c, 1759), c)

def gc.n674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n666(U32.is_lt(c, 1632), c)
    case False{}:
      gc.n673(U32.is_lt(c, 1757), c)

def gc.n675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n659(U32.is_lt(c, 1545), c)
    case False{}:
      gc.n674(U32.is_lt(c, 1649), c)

def gc.n676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n676(U32.is_lt(c, 1769), c)
    case False{}:
      gc.n677(U32.is_lt(c, 1774), c)

def gc.n679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n679(U32.is_lt(c, 1786), c)
    case False{}:
      gc.n680(U32.is_lt(c, 1791), c)

def gc.n682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n678(U32.is_lt(c, 1770), c)
    case False{}:
      gc.n681(U32.is_lt(c, 1789), c)

def gc.n683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Lo"

def gc.n685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n683(U32.is_lt(c, 1806), c)
    case False{}:
      gc.n684(U32.is_lt(c, 1808), c)

def gc.n686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n686(U32.is_lt(c, 1810), c)
    case False{}:
      gc.n687(U32.is_lt(c, 1867), c)

def gc.n689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n685(U32.is_lt(c, 1807), c)
    case False{}:
      gc.n688(U32.is_lt(c, 1840), c)

def gc.n690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n682(U32.is_lt(c, 1776), c)
    case False{}:
      gc.n689(U32.is_lt(c, 1809), c)

def gc.n691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n691(U32.is_lt(c, 1958), c)
    case False{}:
      gc.n692(U32.is_lt(c, 1970), c)

def gc.n694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n694(U32.is_lt(c, 1994), c)
    case False{}:
      gc.n695(U32.is_lt(c, 2036), c)

def gc.n697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n693(U32.is_lt(c, 1969), c)
    case False{}:
      gc.n696(U32.is_lt(c, 2027), c)

def gc.n698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Po"

def gc.n699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n698(U32.is_lt(c, 2039), c)
    case False{}:
      gc.n699(U32.is_lt(c, 2043), c)

def gc.n701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Sc"

def gc.n702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n702(U32.is_lt(c, 2074), c)

def gc.n704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n701(U32.is_lt(c, 2046), c)
    case False{}:
      gc.n703(U32.is_lt(c, 2070), c)

def gc.n705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n700(U32.is_lt(c, 2042), c)
    case False{}:
      gc.n704(U32.is_lt(c, 2048), c)

def gc.n706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n697(U32.is_lt(c, 1984), c)
    case False{}:
      gc.n705(U32.is_lt(c, 2045), c)

def gc.n707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n690(U32.is_lt(c, 1792), c)
    case False{}:
      gc.n706(U32.is_lt(c, 2038), c)

def gc.n708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n675(U32.is_lt(c, 1568), c)
    case False{}:
      gc.n707(U32.is_lt(c, 1869), c)

def gc.n709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n709(U32.is_lt(c, 2084), c)
    case False{}:
      gc.n710(U32.is_lt(c, 2088), c)

def gc.n712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n712(U32.is_lt(c, 2094), c)
    case False{}:
      gc.n713(U32.is_lt(c, 2111), c)

def gc.n715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n711(U32.is_lt(c, 2085), c)
    case False{}:
      gc.n714(U32.is_lt(c, 2096), c)

def gc.n716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n716(U32.is_lt(c, 2137), c)
    case False{}:
      gc.n717(U32.is_lt(c, 2142), c)

def gc.n719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n719(U32.is_lt(c, 2144), c)
    case False{}:
      gc.n720(U32.is_lt(c, 2160), c)

def gc.n722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n718(U32.is_lt(c, 2140), c)
    case False{}:
      gc.n721(U32.is_lt(c, 2155), c)

def gc.n723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n715(U32.is_lt(c, 2089), c)
    case False{}:
      gc.n722(U32.is_lt(c, 2143), c)

def gc.n724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lo"

def gc.n725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Cn"

def gc.n726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n724(U32.is_lt(c, 2185), c)
    case False{}:
      gc.n725(U32.is_lt(c, 2194), c)

def gc.n727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Mn"

def gc.n729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n727(U32.is_lt(c, 2208), c)
    case False{}:
      gc.n728(U32.is_lt(c, 2250), c)

def gc.n730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n726(U32.is_lt(c, 2192), c)
    case False{}:
      gc.n729(U32.is_lt(c, 2249), c)

def gc.n731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Mn"

def gc.n732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n731(U32.is_lt(c, 2275), c)
    case False{}:
      gc.n732(U32.is_lt(c, 2308), c)

def gc.n734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n734(U32.is_lt(c, 2363), c)
    case False{}:
      gc.n735(U32.is_lt(c, 2365), c)

def gc.n737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n733(U32.is_lt(c, 2307), c)
    case False{}:
      gc.n736(U32.is_lt(c, 2364), c)

def gc.n738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n730(U32.is_lt(c, 2199), c)
    case False{}:
      gc.n737(U32.is_lt(c, 2362), c)

def gc.n739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n723(U32.is_lt(c, 2112), c)
    case False{}:
      gc.n738(U32.is_lt(c, 2274), c)

def gc.n740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n740(U32.is_lt(c, 2369), c)
    case False{}:
      gc.n741(U32.is_lt(c, 2381), c)

def gc.n743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n743(U32.is_lt(c, 2384), c)
    case False{}:
      gc.n744(U32.is_lt(c, 2392), c)

def gc.n746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n742(U32.is_lt(c, 2377), c)
    case False{}:
      gc.n745(U32.is_lt(c, 2385), c)

def gc.n747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n747(U32.is_lt(c, 2404), c)
    case False{}:
      gc.n748(U32.is_lt(c, 2416), c)

def gc.n750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n750(U32.is_lt(c, 2418), c)
    case False{}:
      gc.n751(U32.is_lt(c, 2434), c)

def gc.n753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n749(U32.is_lt(c, 2406), c)
    case False{}:
      gc.n752(U32.is_lt(c, 2433), c)

def gc.n754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n746(U32.is_lt(c, 2382), c)
    case False{}:
      gc.n753(U32.is_lt(c, 2417), c)

def gc.n755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n755(U32.is_lt(c, 2437), c)
    case False{}:
      gc.n756(U32.is_lt(c, 2447), c)

def gc.n758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n758(U32.is_lt(c, 2451), c)
    case False{}:
      gc.n759(U32.is_lt(c, 2474), c)

def gc.n761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n757(U32.is_lt(c, 2445), c)
    case False{}:
      gc.n760(U32.is_lt(c, 2473), c)

def gc.n762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n762(U32.is_lt(c, 2482), c)
    case False{}:
      gc.n763(U32.is_lt(c, 2486), c)

def gc.n765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n766(U32.is_lt(c, 2497), c)

def gc.n768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n765(U32.is_lt(c, 2492), c)
    case False{}:
      gc.n767(U32.is_lt(c, 2494), c)

def gc.n769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n764(U32.is_lt(c, 2483), c)
    case False{}:
      gc.n768(U32.is_lt(c, 2493), c)

def gc.n770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n761(U32.is_lt(c, 2449), c)
    case False{}:
      gc.n769(U32.is_lt(c, 2490), c)

def gc.n771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n754(U32.is_lt(c, 2402), c)
    case False{}:
      gc.n770(U32.is_lt(c, 2481), c)

def gc.n772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n739(U32.is_lt(c, 2184), c)
    case False{}:
      gc.n771(U32.is_lt(c, 2436), c)

def gc.n773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n708(U32.is_lt(c, 1767), c)
    case False{}:
      gc.n772(U32.is_lt(c, 2366), c)

def gc.n774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n644(U32.is_lt(c, 1284), c)
    case False{}:
      gc.n773(U32.is_lt(c, 2075), c)

def gc.n775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n775(U32.is_lt(c, 2503), c)
    case False{}:
      gc.n776(U32.is_lt(c, 2507), c)

def gc.n778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n778(U32.is_lt(c, 2510), c)
    case False{}:
      gc.n779(U32.is_lt(c, 2519), c)

def gc.n781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n777(U32.is_lt(c, 2505), c)
    case False{}:
      gc.n780(U32.is_lt(c, 2511), c)

def gc.n782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n782(U32.is_lt(c, 2524), c)
    case False{}:
      gc.n783(U32.is_lt(c, 2527), c)

def gc.n785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n785(U32.is_lt(c, 2532), c)
    case False{}:
      gc.n786(U32.is_lt(c, 2544), c)

def gc.n788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n784(U32.is_lt(c, 2526), c)
    case False{}:
      gc.n787(U32.is_lt(c, 2534), c)

def gc.n789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n781(U32.is_lt(c, 2509), c)
    case False{}:
      gc.n788(U32.is_lt(c, 2530), c)

def gc.n790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "No"

def gc.n791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sc"

def gc.n792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n790(U32.is_lt(c, 2548), c)
    case False{}:
      gc.n791(U32.is_lt(c, 2555), c)

def gc.n793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n793(U32.is_lt(c, 2557), c)
    case False{}:
      gc.n794(U32.is_lt(c, 2559), c)

def gc.n796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n792(U32.is_lt(c, 2554), c)
    case False{}:
      gc.n795(U32.is_lt(c, 2558), c)

def gc.n797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n797(U32.is_lt(c, 2563), c)
    case False{}:
      gc.n798(U32.is_lt(c, 2565), c)

def gc.n800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n800(U32.is_lt(c, 2575), c)
    case False{}:
      gc.n801(U32.is_lt(c, 2579), c)

def gc.n803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n799(U32.is_lt(c, 2564), c)
    case False{}:
      gc.n802(U32.is_lt(c, 2577), c)

def gc.n804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n796(U32.is_lt(c, 2556), c)
    case False{}:
      gc.n803(U32.is_lt(c, 2571), c)

def gc.n805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n789(U32.is_lt(c, 2520), c)
    case False{}:
      gc.n804(U32.is_lt(c, 2561), c)

def gc.n806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n806(U32.is_lt(c, 2602), c)
    case False{}:
      gc.n807(U32.is_lt(c, 2610), c)

def gc.n809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n809(U32.is_lt(c, 2613), c)
    case False{}:
      gc.n810(U32.is_lt(c, 2616), c)

def gc.n812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n808(U32.is_lt(c, 2609), c)
    case False{}:
      gc.n811(U32.is_lt(c, 2615), c)

def gc.n813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n813(U32.is_lt(c, 2620), c)
    case False{}:
      gc.n814(U32.is_lt(c, 2622), c)

def gc.n816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n816(U32.is_lt(c, 2627), c)
    case False{}:
      gc.n817(U32.is_lt(c, 2633), c)

def gc.n819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n815(U32.is_lt(c, 2621), c)
    case False{}:
      gc.n818(U32.is_lt(c, 2631), c)

def gc.n820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n812(U32.is_lt(c, 2612), c)
    case False{}:
      gc.n819(U32.is_lt(c, 2625), c)

def gc.n821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n821(U32.is_lt(c, 2638), c)
    case False{}:
      gc.n822(U32.is_lt(c, 2642), c)

def gc.n824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n824(U32.is_lt(c, 2653), c)
    case False{}:
      gc.n825(U32.is_lt(c, 2655), c)

def gc.n827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n823(U32.is_lt(c, 2641), c)
    case False{}:
      gc.n826(U32.is_lt(c, 2654), c)

def gc.n828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Mn"

def gc.n829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n828(U32.is_lt(c, 2672), c)
    case False{}:
      gc.n829(U32.is_lt(c, 2677), c)

def gc.n831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n831(U32.is_lt(c, 2679), c)
    case False{}:
      gc.n832(U32.is_lt(c, 2691), c)

def gc.n834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n830(U32.is_lt(c, 2674), c)
    case False{}:
      gc.n833(U32.is_lt(c, 2689), c)

def gc.n835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n827(U32.is_lt(c, 2649), c)
    case False{}:
      gc.n834(U32.is_lt(c, 2678), c)

def gc.n836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n820(U32.is_lt(c, 2618), c)
    case False{}:
      gc.n835(U32.is_lt(c, 2662), c)

def gc.n837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n805(U32.is_lt(c, 2546), c)
    case False{}:
      gc.n836(U32.is_lt(c, 2635), c)

def gc.n838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n838(U32.is_lt(c, 2693), c)
    case False{}:
      gc.n839(U32.is_lt(c, 2703), c)

def gc.n841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n841(U32.is_lt(c, 2707), c)
    case False{}:
      gc.n842(U32.is_lt(c, 2730), c)

def gc.n844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n840(U32.is_lt(c, 2702), c)
    case False{}:
      gc.n843(U32.is_lt(c, 2729), c)

def gc.n845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n845(U32.is_lt(c, 2738), c)
    case False{}:
      gc.n846(U32.is_lt(c, 2741), c)

def gc.n848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n848(U32.is_lt(c, 2748), c)
    case False{}:
      gc.n849(U32.is_lt(c, 2750), c)

def gc.n851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n847(U32.is_lt(c, 2740), c)
    case False{}:
      gc.n850(U32.is_lt(c, 2749), c)

def gc.n852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n844(U32.is_lt(c, 2706), c)
    case False{}:
      gc.n851(U32.is_lt(c, 2746), c)

def gc.n853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n853(U32.is_lt(c, 2758), c)
    case False{}:
      gc.n854(U32.is_lt(c, 2761), c)

def gc.n856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n856(U32.is_lt(c, 2763), c)
    case False{}:
      gc.n857(U32.is_lt(c, 2766), c)

def gc.n859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n855(U32.is_lt(c, 2759), c)
    case False{}:
      gc.n858(U32.is_lt(c, 2765), c)

def gc.n860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n860(U32.is_lt(c, 2769), c)
    case False{}:
      gc.n861(U32.is_lt(c, 2786), c)

def gc.n863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sc"

def gc.n865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n863(U32.is_lt(c, 2790), c)
    case False{}:
      gc.n864(U32.is_lt(c, 2801), c)

def gc.n866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n862(U32.is_lt(c, 2784), c)
    case False{}:
      gc.n865(U32.is_lt(c, 2800), c)

def gc.n867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n859(U32.is_lt(c, 2762), c)
    case False{}:
      gc.n866(U32.is_lt(c, 2788), c)

def gc.n868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n852(U32.is_lt(c, 2737), c)
    case False{}:
      gc.n867(U32.is_lt(c, 2768), c)

def gc.n869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n869(U32.is_lt(c, 2809), c)
    case False{}:
      gc.n870(U32.is_lt(c, 2816), c)

def gc.n872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n872(U32.is_lt(c, 2818), c)
    case False{}:
      gc.n873(U32.is_lt(c, 2821), c)

def gc.n875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n871(U32.is_lt(c, 2810), c)
    case False{}:
      gc.n874(U32.is_lt(c, 2820), c)

def gc.n876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n876(U32.is_lt(c, 2831), c)
    case False{}:
      gc.n877(U32.is_lt(c, 2835), c)

def gc.n879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n879(U32.is_lt(c, 2858), c)
    case False{}:
      gc.n880(U32.is_lt(c, 2866), c)

def gc.n882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n878(U32.is_lt(c, 2833), c)
    case False{}:
      gc.n881(U32.is_lt(c, 2865), c)

def gc.n883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n875(U32.is_lt(c, 2817), c)
    case False{}:
      gc.n882(U32.is_lt(c, 2857), c)

def gc.n884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n884(U32.is_lt(c, 2869), c)
    case False{}:
      gc.n885(U32.is_lt(c, 2876), c)

def gc.n887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n887(U32.is_lt(c, 2878), c)
    case False{}:
      gc.n888(U32.is_lt(c, 2880), c)

def gc.n890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n886(U32.is_lt(c, 2874), c)
    case False{}:
      gc.n889(U32.is_lt(c, 2879), c)

def gc.n891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n891(U32.is_lt(c, 2885), c)
    case False{}:
      gc.n892(U32.is_lt(c, 2889), c)

def gc.n894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n895(U32.is_lt(c, 2903), c)

def gc.n897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n894(U32.is_lt(c, 2893), c)
    case False{}:
      gc.n896(U32.is_lt(c, 2901), c)

def gc.n898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n893(U32.is_lt(c, 2887), c)
    case False{}:
      gc.n897(U32.is_lt(c, 2894), c)

def gc.n899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n890(U32.is_lt(c, 2877), c)
    case False{}:
      gc.n898(U32.is_lt(c, 2891), c)

def gc.n900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n883(U32.is_lt(c, 2829), c)
    case False{}:
      gc.n899(U32.is_lt(c, 2881), c)

def gc.n901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n868(U32.is_lt(c, 2753), c)
    case False{}:
      gc.n900(U32.is_lt(c, 2868), c)

def gc.n902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n837(U32.is_lt(c, 2601), c)
    case False{}:
      gc.n901(U32.is_lt(c, 2802), c)

def gc.n903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n903(U32.is_lt(c, 2908), c)
    case False{}:
      gc.n904(U32.is_lt(c, 2911), c)

def gc.n906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "So"

def gc.n908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n906(U32.is_lt(c, 2916), c)
    case False{}:
      gc.n907(U32.is_lt(c, 2928), c)

def gc.n909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n905(U32.is_lt(c, 2910), c)
    case False{}:
      gc.n908(U32.is_lt(c, 2918), c)

def gc.n910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "No"

def gc.n911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n910(U32.is_lt(c, 2930), c)
    case False{}:
      gc.n911(U32.is_lt(c, 2946), c)

def gc.n913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n913(U32.is_lt(c, 2948), c)
    case False{}:
      gc.n914(U32.is_lt(c, 2955), c)

def gc.n916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n912(U32.is_lt(c, 2936), c)
    case False{}:
      gc.n915(U32.is_lt(c, 2949), c)

def gc.n917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n909(U32.is_lt(c, 2914), c)
    case False{}:
      gc.n916(U32.is_lt(c, 2947), c)

def gc.n918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n918(U32.is_lt(c, 2961), c)
    case False{}:
      gc.n919(U32.is_lt(c, 2966), c)

def gc.n921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n921(U32.is_lt(c, 2971), c)
    case False{}:
      gc.n922(U32.is_lt(c, 2973), c)

def gc.n924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n920(U32.is_lt(c, 2962), c)
    case False{}:
      gc.n923(U32.is_lt(c, 2972), c)

def gc.n925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n925(U32.is_lt(c, 2976), c)
    case False{}:
      gc.n926(U32.is_lt(c, 2981), c)

def gc.n928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n928(U32.is_lt(c, 2987), c)
    case False{}:
      gc.n929(U32.is_lt(c, 3002), c)

def gc.n931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n927(U32.is_lt(c, 2979), c)
    case False{}:
      gc.n930(U32.is_lt(c, 2990), c)

def gc.n932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n924(U32.is_lt(c, 2969), c)
    case False{}:
      gc.n931(U32.is_lt(c, 2984), c)

def gc.n933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n917(U32.is_lt(c, 2929), c)
    case False{}:
      gc.n932(U32.is_lt(c, 2974), c)

def gc.n934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n934(U32.is_lt(c, 3008), c)
    case False{}:
      gc.n935(U32.is_lt(c, 3011), c)

def gc.n937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n937(U32.is_lt(c, 3017), c)
    case False{}:
      gc.n938(U32.is_lt(c, 3021), c)

def gc.n940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n936(U32.is_lt(c, 3009), c)
    case False{}:
      gc.n939(U32.is_lt(c, 3018), c)

def gc.n941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n941(U32.is_lt(c, 3024), c)
    case False{}:
      gc.n942(U32.is_lt(c, 3031), c)

def gc.n944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n944(U32.is_lt(c, 3046), c)
    case False{}:
      gc.n945(U32.is_lt(c, 3059), c)

def gc.n947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n943(U32.is_lt(c, 3025), c)
    case False{}:
      gc.n946(U32.is_lt(c, 3056), c)

def gc.n948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n940(U32.is_lt(c, 3014), c)
    case False{}:
      gc.n947(U32.is_lt(c, 3032), c)

def gc.n949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "So"

def gc.n950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n949(U32.is_lt(c, 3066), c)
    case False{}:
      gc.n950(U32.is_lt(c, 3072), c)

def gc.n952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n952(U32.is_lt(c, 3076), c)
    case False{}:
      gc.n953(U32.is_lt(c, 3085), c)

def gc.n955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n951(U32.is_lt(c, 3067), c)
    case False{}:
      gc.n954(U32.is_lt(c, 3077), c)

def gc.n956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n956(U32.is_lt(c, 3089), c)
    case False{}:
      gc.n957(U32.is_lt(c, 3113), c)

def gc.n959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      gc.n960(U32.is_lt(c, 3134), c)

def gc.n962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n959(U32.is_lt(c, 3130), c)
    case False{}:
      gc.n961(U32.is_lt(c, 3133), c)

def gc.n963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n958(U32.is_lt(c, 3090), c)
    case False{}:
      gc.n962(U32.is_lt(c, 3132), c)

def gc.n964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n955(U32.is_lt(c, 3073), c)
    case False{}:
      gc.n963(U32.is_lt(c, 3114), c)

def gc.n965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n948(U32.is_lt(c, 3022), c)
    case False{}:
      gc.n964(U32.is_lt(c, 3086), c)

def gc.n966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n933(U32.is_lt(c, 2958), c)
    case False{}:
      gc.n965(U32.is_lt(c, 3065), c)

def gc.n967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n967(U32.is_lt(c, 3141), c)
    case False{}:
      gc.n968(U32.is_lt(c, 3145), c)

def gc.n970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n970(U32.is_lt(c, 3150), c)
    case False{}:
      gc.n971(U32.is_lt(c, 3159), c)

def gc.n973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n969(U32.is_lt(c, 3142), c)
    case False{}:
      gc.n972(U32.is_lt(c, 3157), c)

def gc.n974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n974(U32.is_lt(c, 3163), c)
    case False{}:
      gc.n975(U32.is_lt(c, 3166), c)

def gc.n977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n977(U32.is_lt(c, 3170), c)
    case False{}:
      gc.n978(U32.is_lt(c, 3174), c)

def gc.n980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n976(U32.is_lt(c, 3164), c)
    case False{}:
      gc.n979(U32.is_lt(c, 3172), c)

def gc.n981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n973(U32.is_lt(c, 3146), c)
    case False{}:
      gc.n980(U32.is_lt(c, 3168), c)

def gc.n982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n982(U32.is_lt(c, 3191), c)
    case False{}:
      gc.n983(U32.is_lt(c, 3199), c)

def gc.n985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Po"

def gc.n987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n985(U32.is_lt(c, 3201), c)
    case False{}:
      gc.n986(U32.is_lt(c, 3204), c)

def gc.n988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n984(U32.is_lt(c, 3192), c)
    case False{}:
      gc.n987(U32.is_lt(c, 3202), c)

def gc.n989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n989(U32.is_lt(c, 3213), c)
    case False{}:
      gc.n990(U32.is_lt(c, 3217), c)

def gc.n992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n992(U32.is_lt(c, 3241), c)
    case False{}:
      gc.n993(U32.is_lt(c, 3252), c)

def gc.n995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n991(U32.is_lt(c, 3214), c)
    case False{}:
      gc.n994(U32.is_lt(c, 3242), c)

def gc.n996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n988(U32.is_lt(c, 3200), c)
    case False{}:
      gc.n995(U32.is_lt(c, 3218), c)

def gc.n997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n981(U32.is_lt(c, 3160), c)
    case False{}:
      gc.n996(U32.is_lt(c, 3205), c)

def gc.n998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n998(U32.is_lt(c, 3258), c)
    case False{}:
      gc.n999(U32.is_lt(c, 3261), c)

def gc.n1001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n1003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1001(U32.is_lt(c, 3263), c)
    case False{}:
      gc.n1002(U32.is_lt(c, 3269), c)

def gc.n1004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1000(U32.is_lt(c, 3260), c)
    case False{}:
      gc.n1003(U32.is_lt(c, 3264), c)

def gc.n1005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1005(U32.is_lt(c, 3271), c)
    case False{}:
      gc.n1006(U32.is_lt(c, 3274), c)

def gc.n1008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n1010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1008(U32.is_lt(c, 3278), c)
    case False{}:
      gc.n1009(U32.is_lt(c, 3287), c)

def gc.n1011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1007(U32.is_lt(c, 3273), c)
    case False{}:
      gc.n1010(U32.is_lt(c, 3285), c)

def gc.n1012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1004(U32.is_lt(c, 3262), c)
    case False{}:
      gc.n1011(U32.is_lt(c, 3276), c)

def gc.n1013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1013(U32.is_lt(c, 3295), c)
    case False{}:
      gc.n1014(U32.is_lt(c, 3298), c)

def gc.n1016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n1017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1016(U32.is_lt(c, 3302), c)
    case False{}:
      gc.n1017(U32.is_lt(c, 3313), c)

def gc.n1019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1015(U32.is_lt(c, 3296), c)
    case False{}:
      gc.n1018(U32.is_lt(c, 3312), c)

def gc.n1020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n1021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1020(U32.is_lt(c, 3316), c)
    case False{}:
      gc.n1021(U32.is_lt(c, 3330), c)

def gc.n1023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n1024(U32.is_lt(c, 3346), c)

def gc.n1026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1023(U32.is_lt(c, 3341), c)
    case False{}:
      gc.n1025(U32.is_lt(c, 3345), c)

def gc.n1027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1022(U32.is_lt(c, 3328), c)
    case False{}:
      gc.n1026(U32.is_lt(c, 3342), c)

def gc.n1028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1019(U32.is_lt(c, 3300), c)
    case False{}:
      gc.n1027(U32.is_lt(c, 3332), c)

def gc.n1029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1012(U32.is_lt(c, 3270), c)
    case False{}:
      gc.n1028(U32.is_lt(c, 3315), c)

def gc.n1030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n997(U32.is_lt(c, 3184), c)
    case False{}:
      gc.n1029(U32.is_lt(c, 3292), c)

def gc.n1031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n966(U32.is_lt(c, 3006), c)
    case False{}:
      gc.n1030(U32.is_lt(c, 3253), c)

def gc.n1032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n902(U32.is_lt(c, 2692), c)
    case False{}:
      gc.n1031(U32.is_lt(c, 3137), c)

def gc.n1033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n774(U32.is_lt(c, 1480), c)
    case False{}:
      gc.n1032(U32.is_lt(c, 2904), c)

def gc.n1034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n516(U32.is_lt(c, 488), c)
    case False{}:
      gc.n1033(U32.is_lt(c, 2501), c)

def gc.n1035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1035(U32.is_lt(c, 3389), c)
    case False{}:
      gc.n1036(U32.is_lt(c, 3393), c)

def gc.n1038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1038(U32.is_lt(c, 3398), c)
    case False{}:
      gc.n1039(U32.is_lt(c, 3402), c)

def gc.n1041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1037(U32.is_lt(c, 3390), c)
    case False{}:
      gc.n1040(U32.is_lt(c, 3401), c)

def gc.n1042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n1044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1042(U32.is_lt(c, 3406), c)
    case False{}:
      gc.n1043(U32.is_lt(c, 3408), c)

def gc.n1045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Lo"

def gc.n1047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1045(U32.is_lt(c, 3415), c)
    case False{}:
      gc.n1046(U32.is_lt(c, 3423), c)

def gc.n1048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1044(U32.is_lt(c, 3407), c)
    case False{}:
      gc.n1047(U32.is_lt(c, 3416), c)

def gc.n1049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1041(U32.is_lt(c, 3397), c)
    case False{}:
      gc.n1048(U32.is_lt(c, 3412), c)

def gc.n1050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "No"

def gc.n1052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1050(U32.is_lt(c, 3428), c)
    case False{}:
      gc.n1051(U32.is_lt(c, 3440), c)

def gc.n1053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n1054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1053(U32.is_lt(c, 3450), c)
    case False{}:
      gc.n1054(U32.is_lt(c, 3457), c)

def gc.n1056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1052(U32.is_lt(c, 3430), c)
    case False{}:
      gc.n1055(U32.is_lt(c, 3456), c)

def gc.n1057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n1058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1057(U32.is_lt(c, 3460), c)
    case False{}:
      gc.n1058(U32.is_lt(c, 3479), c)

def gc.n1060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1060(U32.is_lt(c, 3506), c)
    case False{}:
      gc.n1061(U32.is_lt(c, 3516), c)

def gc.n1063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1059(U32.is_lt(c, 3461), c)
    case False{}:
      gc.n1062(U32.is_lt(c, 3507), c)

def gc.n1064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1056(U32.is_lt(c, 3449), c)
    case False{}:
      gc.n1063(U32.is_lt(c, 3482), c)

def gc.n1065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1049(U32.is_lt(c, 3405), c)
    case False{}:
      gc.n1064(U32.is_lt(c, 3458), c)

def gc.n1066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1066(U32.is_lt(c, 3518), c)
    case False{}:
      gc.n1067(U32.is_lt(c, 3527), c)

def gc.n1069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1069(U32.is_lt(c, 3531), c)
    case False{}:
      gc.n1070(U32.is_lt(c, 3538), c)

def gc.n1072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1068(U32.is_lt(c, 3520), c)
    case False{}:
      gc.n1071(U32.is_lt(c, 3535), c)

def gc.n1073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1073(U32.is_lt(c, 3542), c)
    case False{}:
      gc.n1074(U32.is_lt(c, 3544), c)

def gc.n1076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n1077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1076(U32.is_lt(c, 3558), c)
    case False{}:
      gc.n1077(U32.is_lt(c, 3570), c)

def gc.n1079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1075(U32.is_lt(c, 3543), c)
    case False{}:
      gc.n1078(U32.is_lt(c, 3568), c)

def gc.n1080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1072(U32.is_lt(c, 3530), c)
    case False{}:
      gc.n1079(U32.is_lt(c, 3552), c)

def gc.n1081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n1082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1081(U32.is_lt(c, 3573), c)
    case False{}:
      gc.n1082(U32.is_lt(c, 3633), c)

def gc.n1084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sc"

def gc.n1086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1084(U32.is_lt(c, 3636), c)
    case False{}:
      gc.n1085(U32.is_lt(c, 3647), c)

def gc.n1087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1083(U32.is_lt(c, 3585), c)
    case False{}:
      gc.n1086(U32.is_lt(c, 3643), c)

def gc.n1088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n1089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n1090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1088(U32.is_lt(c, 3654), c)
    case False{}:
      gc.n1089(U32.is_lt(c, 3663), c)

def gc.n1091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n1092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1091(U32.is_lt(c, 3674), c)
    case False{}:
      gc.n1092(U32.is_lt(c, 3713), c)

def gc.n1094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1090(U32.is_lt(c, 3655), c)
    case False{}:
      gc.n1093(U32.is_lt(c, 3676), c)

def gc.n1095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1087(U32.is_lt(c, 3634), c)
    case False{}:
      gc.n1094(U32.is_lt(c, 3664), c)

def gc.n1096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1080(U32.is_lt(c, 3541), c)
    case False{}:
      gc.n1095(U32.is_lt(c, 3648), c)

def gc.n1097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1065(U32.is_lt(c, 3426), c)
    case False{}:
      gc.n1096(U32.is_lt(c, 3572), c)

def gc.n1098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1098(U32.is_lt(c, 3716), c)
    case False{}:
      gc.n1099(U32.is_lt(c, 3718), c)

def gc.n1101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1101(U32.is_lt(c, 3724), c)
    case False{}:
      gc.n1102(U32.is_lt(c, 3749), c)

def gc.n1104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1100(U32.is_lt(c, 3717), c)
    case False{}:
      gc.n1103(U32.is_lt(c, 3748), c)

def gc.n1105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1105(U32.is_lt(c, 3751), c)
    case False{}:
      gc.n1106(U32.is_lt(c, 3762), c)

def gc.n1108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1108(U32.is_lt(c, 3773), c)
    case False{}:
      gc.n1109(U32.is_lt(c, 3776), c)

def gc.n1111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1107(U32.is_lt(c, 3761), c)
    case False{}:
      gc.n1110(U32.is_lt(c, 3774), c)

def gc.n1112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1104(U32.is_lt(c, 3723), c)
    case False{}:
      gc.n1111(U32.is_lt(c, 3764), c)

def gc.n1113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n1114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1113(U32.is_lt(c, 3782), c)
    case False{}:
      gc.n1114(U32.is_lt(c, 3784), c)

def gc.n1116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n1117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1116(U32.is_lt(c, 3792), c)
    case False{}:
      gc.n1117(U32.is_lt(c, 3804), c)

def gc.n1119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1115(U32.is_lt(c, 3783), c)
    case False{}:
      gc.n1118(U32.is_lt(c, 3802), c)

def gc.n1120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Po"

def gc.n1122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1120(U32.is_lt(c, 3840), c)
    case False{}:
      gc.n1121(U32.is_lt(c, 3844), c)

def gc.n1123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Po"

def gc.n1124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n1125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1123(U32.is_lt(c, 3860), c)
    case False{}:
      gc.n1124(U32.is_lt(c, 3864), c)

def gc.n1126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1122(U32.is_lt(c, 3841), c)
    case False{}:
      gc.n1125(U32.is_lt(c, 3861), c)

def gc.n1127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1119(U32.is_lt(c, 3791), c)
    case False{}:
      gc.n1126(U32.is_lt(c, 3859), c)

def gc.n1128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1112(U32.is_lt(c, 3750), c)
    case False{}:
      gc.n1127(U32.is_lt(c, 3808), c)

def gc.n1129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Nd"

def gc.n1130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n1131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1129(U32.is_lt(c, 3872), c)
    case False{}:
      gc.n1130(U32.is_lt(c, 3892), c)

def gc.n1132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n1133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n1134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1132(U32.is_lt(c, 3894), c)
    case False{}:
      gc.n1133(U32.is_lt(c, 3896), c)

def gc.n1135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1131(U32.is_lt(c, 3882), c)
    case False{}:
      gc.n1134(U32.is_lt(c, 3895), c)

def gc.n1136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Ps"

def gc.n1137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1136(U32.is_lt(c, 3898), c)
    case False{}:
      gc.n1137(U32.is_lt(c, 3900), c)

def gc.n1139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Mc"

def gc.n1140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1139(U32.is_lt(c, 3902), c)
    case False{}:
      gc.n1140(U32.is_lt(c, 3912), c)

def gc.n1142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1138(U32.is_lt(c, 3899), c)
    case False{}:
      gc.n1141(U32.is_lt(c, 3904), c)

def gc.n1143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1135(U32.is_lt(c, 3893), c)
    case False{}:
      gc.n1142(U32.is_lt(c, 3901), c)

def gc.n1144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1144(U32.is_lt(c, 3949), c)
    case False{}:
      gc.n1145(U32.is_lt(c, 3967), c)

def gc.n1147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n1148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1147(U32.is_lt(c, 3973), c)
    case False{}:
      gc.n1148(U32.is_lt(c, 3976), c)

def gc.n1150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1146(U32.is_lt(c, 3953), c)
    case False{}:
      gc.n1149(U32.is_lt(c, 3974), c)

def gc.n1151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1151(U32.is_lt(c, 3992), c)
    case False{}:
      gc.n1152(U32.is_lt(c, 4029), c)

def gc.n1154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n1155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n1156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      gc.n1155(U32.is_lt(c, 4046), c)

def gc.n1157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1154(U32.is_lt(c, 4038), c)
    case False{}:
      gc.n1156(U32.is_lt(c, 4045), c)

def gc.n1158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1153(U32.is_lt(c, 3993), c)
    case False{}:
      gc.n1157(U32.is_lt(c, 4039), c)

def gc.n1159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1150(U32.is_lt(c, 3968), c)
    case False{}:
      gc.n1158(U32.is_lt(c, 4030), c)

def gc.n1160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1143(U32.is_lt(c, 3897), c)
    case False{}:
      gc.n1159(U32.is_lt(c, 3981), c)

def gc.n1161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1128(U32.is_lt(c, 3781), c)
    case False{}:
      gc.n1160(U32.is_lt(c, 3913), c)

def gc.n1162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1097(U32.is_lt(c, 3517), c)
    case False{}:
      gc.n1161(U32.is_lt(c, 3866), c)

def gc.n1163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n1164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n1165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1163(U32.is_lt(c, 4053), c)
    case False{}:
      gc.n1164(U32.is_lt(c, 4059), c)

def gc.n1166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1166(U32.is_lt(c, 4139), c)
    case False{}:
      gc.n1167(U32.is_lt(c, 4145), c)

def gc.n1169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1165(U32.is_lt(c, 4057), c)
    case False{}:
      gc.n1168(U32.is_lt(c, 4141), c)

def gc.n1170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1170(U32.is_lt(c, 4152), c)
    case False{}:
      gc.n1171(U32.is_lt(c, 4155), c)

def gc.n1173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n1175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1173(U32.is_lt(c, 4159), c)
    case False{}:
      gc.n1174(U32.is_lt(c, 4170), c)

def gc.n1176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1172(U32.is_lt(c, 4153), c)
    case False{}:
      gc.n1175(U32.is_lt(c, 4160), c)

def gc.n1177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1169(U32.is_lt(c, 4096), c)
    case False{}:
      gc.n1176(U32.is_lt(c, 4157), c)

def gc.n1178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1178(U32.is_lt(c, 4182), c)
    case False{}:
      gc.n1179(U32.is_lt(c, 4186), c)

def gc.n1181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n1183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1181(U32.is_lt(c, 4193), c)
    case False{}:
      gc.n1182(U32.is_lt(c, 4197), c)

def gc.n1184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1180(U32.is_lt(c, 4184), c)
    case False{}:
      gc.n1183(U32.is_lt(c, 4194), c)

def gc.n1185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n1186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1185(U32.is_lt(c, 4206), c)
    case False{}:
      gc.n1186(U32.is_lt(c, 4213), c)

def gc.n1188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1188(U32.is_lt(c, 4227), c)
    case False{}:
      gc.n1189(U32.is_lt(c, 4231), c)

def gc.n1191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1187(U32.is_lt(c, 4209), c)
    case False{}:
      gc.n1190(U32.is_lt(c, 4229), c)

def gc.n1192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1184(U32.is_lt(c, 4190), c)
    case False{}:
      gc.n1191(U32.is_lt(c, 4226), c)

def gc.n1193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1177(U32.is_lt(c, 4146), c)
    case False{}:
      gc.n1192(U32.is_lt(c, 4199), c)

def gc.n1194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Nd"

def gc.n1196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1194(U32.is_lt(c, 4238), c)
    case False{}:
      gc.n1195(U32.is_lt(c, 4240), c)

def gc.n1197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n1199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1197(U32.is_lt(c, 4253), c)
    case False{}:
      gc.n1198(U32.is_lt(c, 4256), c)

def gc.n1200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1196(U32.is_lt(c, 4239), c)
    case False{}:
      gc.n1199(U32.is_lt(c, 4254), c)

def gc.n1201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n1202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n1203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1201(U32.is_lt(c, 4295), c)
    case False{}:
      gc.n1202(U32.is_lt(c, 4301), c)

def gc.n1204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n1205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lm"

def gc.n1206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1204(U32.is_lt(c, 4304), c)
    case False{}:
      gc.n1205(U32.is_lt(c, 4348), c)

def gc.n1207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1203(U32.is_lt(c, 4296), c)
    case False{}:
      gc.n1206(U32.is_lt(c, 4347), c)

def gc.n1208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1200(U32.is_lt(c, 4250), c)
    case False{}:
      gc.n1207(U32.is_lt(c, 4302), c)

def gc.n1209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n1210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1209(U32.is_lt(c, 4352), c)
    case False{}:
      gc.n1210(U32.is_lt(c, 4682), c)

def gc.n1212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1212(U32.is_lt(c, 4688), c)
    case False{}:
      gc.n1213(U32.is_lt(c, 4696), c)

def gc.n1215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1211(U32.is_lt(c, 4681), c)
    case False{}:
      gc.n1214(U32.is_lt(c, 4695), c)

def gc.n1216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1216(U32.is_lt(c, 4698), c)
    case False{}:
      gc.n1217(U32.is_lt(c, 4704), c)

def gc.n1219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n1220(U32.is_lt(c, 4785), c)

def gc.n1222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1219(U32.is_lt(c, 4746), c)
    case False{}:
      gc.n1221(U32.is_lt(c, 4752), c)

def gc.n1223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1218(U32.is_lt(c, 4702), c)
    case False{}:
      gc.n1222(U32.is_lt(c, 4750), c)

def gc.n1224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1215(U32.is_lt(c, 4686), c)
    case False{}:
      gc.n1223(U32.is_lt(c, 4745), c)

def gc.n1225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1208(U32.is_lt(c, 4294), c)
    case False{}:
      gc.n1224(U32.is_lt(c, 4697), c)

def gc.n1226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1193(U32.is_lt(c, 4176), c)
    case False{}:
      gc.n1225(U32.is_lt(c, 4349), c)

def gc.n1227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1227(U32.is_lt(c, 4790), c)
    case False{}:
      gc.n1228(U32.is_lt(c, 4799), c)

def gc.n1230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1230(U32.is_lt(c, 4801), c)
    case False{}:
      gc.n1231(U32.is_lt(c, 4806), c)

def gc.n1233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1229(U32.is_lt(c, 4792), c)
    case False{}:
      gc.n1232(U32.is_lt(c, 4802), c)

def gc.n1234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1234(U32.is_lt(c, 4823), c)
    case False{}:
      gc.n1235(U32.is_lt(c, 4881), c)

def gc.n1237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1237(U32.is_lt(c, 4886), c)
    case False{}:
      gc.n1238(U32.is_lt(c, 4955), c)

def gc.n1240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1236(U32.is_lt(c, 4824), c)
    case False{}:
      gc.n1239(U32.is_lt(c, 4888), c)

def gc.n1241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1233(U32.is_lt(c, 4800), c)
    case False{}:
      gc.n1240(U32.is_lt(c, 4882), c)

def gc.n1242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n1243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n1244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1242(U32.is_lt(c, 4960), c)
    case False{}:
      gc.n1243(U32.is_lt(c, 4989), c)

def gc.n1245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n1246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n1247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1245(U32.is_lt(c, 5008), c)
    case False{}:
      gc.n1246(U32.is_lt(c, 5024), c)

def gc.n1248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1244(U32.is_lt(c, 4969), c)
    case False{}:
      gc.n1247(U32.is_lt(c, 5018), c)

def gc.n1249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n1250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Pd"

def gc.n1251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1249(U32.is_lt(c, 5112), c)
    case False{}:
      gc.n1250(U32.is_lt(c, 5120), c)

def gc.n1252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n1253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n1254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1252(U32.is_lt(c, 5741), c)
    case False{}:
      gc.n1253(U32.is_lt(c, 5743), c)

def gc.n1255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1251(U32.is_lt(c, 5118), c)
    case False{}:
      gc.n1254(U32.is_lt(c, 5742), c)

def gc.n1256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1248(U32.is_lt(c, 4992), c)
    case False{}:
      gc.n1255(U32.is_lt(c, 5121), c)

def gc.n1257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1241(U32.is_lt(c, 4808), c)
    case False{}:
      gc.n1256(U32.is_lt(c, 5110), c)

def gc.n1258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Zs"
    case False{}:
      "Lo"

def gc.n1259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1258(U32.is_lt(c, 5761), c)
    case False{}:
      gc.n1259(U32.is_lt(c, 5788), c)

def gc.n1261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nl"

def gc.n1263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1261(U32.is_lt(c, 5792), c)
    case False{}:
      gc.n1262(U32.is_lt(c, 5870), c)

def gc.n1264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1260(U32.is_lt(c, 5787), c)
    case False{}:
      gc.n1263(U32.is_lt(c, 5867), c)

def gc.n1265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1265(U32.is_lt(c, 5881), c)
    case False{}:
      gc.n1266(U32.is_lt(c, 5906), c)

def gc.n1268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n1269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1268(U32.is_lt(c, 5910), c)
    case False{}:
      gc.n1269(U32.is_lt(c, 5938), c)

def gc.n1271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1267(U32.is_lt(c, 5888), c)
    case False{}:
      gc.n1270(U32.is_lt(c, 5919), c)

def gc.n1272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1264(U32.is_lt(c, 5789), c)
    case False{}:
      gc.n1271(U32.is_lt(c, 5909), c)

def gc.n1273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Po"

def gc.n1274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1273(U32.is_lt(c, 5941), c)
    case False{}:
      gc.n1274(U32.is_lt(c, 5952), c)

def gc.n1276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1276(U32.is_lt(c, 5972), c)
    case False{}:
      gc.n1277(U32.is_lt(c, 5997), c)

def gc.n1279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1275(U32.is_lt(c, 5943), c)
    case False{}:
      gc.n1278(U32.is_lt(c, 5984), c)

def gc.n1280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1280(U32.is_lt(c, 6001), c)
    case False{}:
      gc.n1281(U32.is_lt(c, 6004), c)

def gc.n1283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      gc.n1284(U32.is_lt(c, 6078), c)

def gc.n1286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1283(U32.is_lt(c, 6068), c)
    case False{}:
      gc.n1285(U32.is_lt(c, 6071), c)

def gc.n1287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1282(U32.is_lt(c, 6002), c)
    case False{}:
      gc.n1286(U32.is_lt(c, 6070), c)

def gc.n1288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1279(U32.is_lt(c, 5970), c)
    case False{}:
      gc.n1287(U32.is_lt(c, 6016), c)

def gc.n1289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1272(U32.is_lt(c, 5873), c)
    case False{}:
      gc.n1288(U32.is_lt(c, 5998), c)

def gc.n1290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1257(U32.is_lt(c, 4957), c)
    case False{}:
      gc.n1289(U32.is_lt(c, 5940), c)

def gc.n1291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1226(U32.is_lt(c, 4237), c)
    case False{}:
      gc.n1290(U32.is_lt(c, 5760), c)

def gc.n1292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1162(U32.is_lt(c, 3715), c)
    case False{}:
      gc.n1291(U32.is_lt(c, 4786), c)

def gc.n1293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n1295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1293(U32.is_lt(c, 6087), c)
    case False{}:
      gc.n1294(U32.is_lt(c, 6100), c)

def gc.n1296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Po"

def gc.n1297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Lo"

def gc.n1298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1296(U32.is_lt(c, 6104), c)
    case False{}:
      gc.n1297(U32.is_lt(c, 6108), c)

def gc.n1299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1295(U32.is_lt(c, 6089), c)
    case False{}:
      gc.n1298(U32.is_lt(c, 6107), c)

def gc.n1300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n1302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1300(U32.is_lt(c, 6110), c)
    case False{}:
      gc.n1301(U32.is_lt(c, 6122), c)

def gc.n1303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n1304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n1305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1303(U32.is_lt(c, 6138), c)
    case False{}:
      gc.n1304(U32.is_lt(c, 6150), c)

def gc.n1306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1302(U32.is_lt(c, 6112), c)
    case False{}:
      gc.n1305(U32.is_lt(c, 6144), c)

def gc.n1307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1299(U32.is_lt(c, 6103), c)
    case False{}:
      gc.n1306(U32.is_lt(c, 6128), c)

def gc.n1308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n1309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Mn"

def gc.n1310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1308(U32.is_lt(c, 6155), c)
    case False{}:
      gc.n1309(U32.is_lt(c, 6159), c)

def gc.n1311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n1312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n1313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1311(U32.is_lt(c, 6170), c)
    case False{}:
      gc.n1312(U32.is_lt(c, 6211), c)

def gc.n1314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1310(U32.is_lt(c, 6158), c)
    case False{}:
      gc.n1313(U32.is_lt(c, 6176), c)

def gc.n1315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1315(U32.is_lt(c, 6265), c)
    case False{}:
      gc.n1316(U32.is_lt(c, 6277), c)

def gc.n1318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1318(U32.is_lt(c, 6313), c)
    case False{}:
      gc.n1319(U32.is_lt(c, 6315), c)

def gc.n1321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1317(U32.is_lt(c, 6272), c)
    case False{}:
      gc.n1320(U32.is_lt(c, 6314), c)

def gc.n1322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1314(U32.is_lt(c, 6160), c)
    case False{}:
      gc.n1321(U32.is_lt(c, 6279), c)

def gc.n1323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1307(U32.is_lt(c, 6109), c)
    case False{}:
      gc.n1322(U32.is_lt(c, 6212), c)

def gc.n1324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1324(U32.is_lt(c, 6390), c)
    case False{}:
      gc.n1325(U32.is_lt(c, 6431), c)

def gc.n1327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1327(U32.is_lt(c, 6435), c)
    case False{}:
      gc.n1328(U32.is_lt(c, 6441), c)

def gc.n1330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1326(U32.is_lt(c, 6400), c)
    case False{}:
      gc.n1329(U32.is_lt(c, 6439), c)

def gc.n1331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n1332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1331(U32.is_lt(c, 6448), c)
    case False{}:
      gc.n1332(U32.is_lt(c, 6451), c)

def gc.n1334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n1336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1334(U32.is_lt(c, 6460), c)
    case False{}:
      gc.n1335(U32.is_lt(c, 6465), c)

def gc.n1337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1333(U32.is_lt(c, 6450), c)
    case False{}:
      gc.n1336(U32.is_lt(c, 6464), c)

def gc.n1338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1330(U32.is_lt(c, 6432), c)
    case False{}:
      gc.n1337(U32.is_lt(c, 6457), c)

def gc.n1339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n1340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1339(U32.is_lt(c, 6470), c)
    case False{}:
      gc.n1340(U32.is_lt(c, 6510), c)

def gc.n1342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1342(U32.is_lt(c, 6517), c)
    case False{}:
      gc.n1343(U32.is_lt(c, 6572), c)

def gc.n1345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1341(U32.is_lt(c, 6480), c)
    case False{}:
      gc.n1344(U32.is_lt(c, 6528), c)

def gc.n1346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "No"

def gc.n1348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1346(U32.is_lt(c, 6602), c)
    case False{}:
      gc.n1347(U32.is_lt(c, 6618), c)

def gc.n1349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n1350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1349(U32.is_lt(c, 6622), c)
    case False{}:
      gc.n1350(U32.is_lt(c, 6679), c)

def gc.n1352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1348(U32.is_lt(c, 6608), c)
    case False{}:
      gc.n1351(U32.is_lt(c, 6656), c)

def gc.n1353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1345(U32.is_lt(c, 6512), c)
    case False{}:
      gc.n1352(U32.is_lt(c, 6619), c)

def gc.n1354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1338(U32.is_lt(c, 6444), c)
    case False{}:
      gc.n1353(U32.is_lt(c, 6576), c)

def gc.n1355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1323(U32.is_lt(c, 6151), c)
    case False{}:
      gc.n1354(U32.is_lt(c, 6468), c)

def gc.n1356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n1358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1356(U32.is_lt(c, 6683), c)
    case False{}:
      gc.n1357(U32.is_lt(c, 6686), c)

def gc.n1359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1359(U32.is_lt(c, 6741), c)
    case False{}:
      gc.n1360(U32.is_lt(c, 6743), c)

def gc.n1362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1358(U32.is_lt(c, 6684), c)
    case False{}:
      gc.n1361(U32.is_lt(c, 6742), c)

def gc.n1363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1363(U32.is_lt(c, 6751), c)
    case False{}:
      gc.n1364(U32.is_lt(c, 6753), c)

def gc.n1366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1366(U32.is_lt(c, 6755), c)
    case False{}:
      gc.n1367(U32.is_lt(c, 6765), c)

def gc.n1369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1365(U32.is_lt(c, 6752), c)
    case False{}:
      gc.n1368(U32.is_lt(c, 6757), c)

def gc.n1370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1362(U32.is_lt(c, 6688), c)
    case False{}:
      gc.n1369(U32.is_lt(c, 6754), c)

def gc.n1371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Nd"

def gc.n1373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1371(U32.is_lt(c, 6781), c)
    case False{}:
      gc.n1372(U32.is_lt(c, 6784), c)

def gc.n1374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n1375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n1376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1374(U32.is_lt(c, 6800), c)
    case False{}:
      gc.n1375(U32.is_lt(c, 6816), c)

def gc.n1377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1373(U32.is_lt(c, 6783), c)
    case False{}:
      gc.n1376(U32.is_lt(c, 6810), c)

def gc.n1378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Po"

def gc.n1379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1378(U32.is_lt(c, 6824), c)
    case False{}:
      gc.n1379(U32.is_lt(c, 6832), c)

def gc.n1381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Me"
    case False{}:
      "Mn"

def gc.n1382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1381(U32.is_lt(c, 6847), c)
    case False{}:
      gc.n1382(U32.is_lt(c, 6880), c)

def gc.n1384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1380(U32.is_lt(c, 6830), c)
    case False{}:
      gc.n1383(U32.is_lt(c, 6878), c)

def gc.n1385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1377(U32.is_lt(c, 6794), c)
    case False{}:
      gc.n1384(U32.is_lt(c, 6846), c)

def gc.n1386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1370(U32.is_lt(c, 6744), c)
    case False{}:
      gc.n1385(U32.is_lt(c, 6823), c)

def gc.n1387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n1389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1387(U32.is_lt(c, 6912), c)
    case False{}:
      gc.n1388(U32.is_lt(c, 6917), c)

def gc.n1390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1390(U32.is_lt(c, 6965), c)
    case False{}:
      gc.n1391(U32.is_lt(c, 6971), c)

def gc.n1393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1389(U32.is_lt(c, 6916), c)
    case False{}:
      gc.n1392(U32.is_lt(c, 6966), c)

def gc.n1394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1394(U32.is_lt(c, 6973), c)
    case False{}:
      gc.n1395(U32.is_lt(c, 6979), c)

def gc.n1397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n1398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n1399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1397(U32.is_lt(c, 6989), c)
    case False{}:
      gc.n1398(U32.is_lt(c, 6992), c)

def gc.n1400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1396(U32.is_lt(c, 6978), c)
    case False{}:
      gc.n1399(U32.is_lt(c, 6990), c)

def gc.n1401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1393(U32.is_lt(c, 6964), c)
    case False{}:
      gc.n1400(U32.is_lt(c, 6981), c)

def gc.n1402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n1403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n1404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1402(U32.is_lt(c, 7009), c)
    case False{}:
      gc.n1403(U32.is_lt(c, 7028), c)

def gc.n1405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n1406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n1407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1405(U32.is_lt(c, 7040), c)
    case False{}:
      gc.n1406(U32.is_lt(c, 7043), c)

def gc.n1408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1404(U32.is_lt(c, 7019), c)
    case False{}:
      gc.n1407(U32.is_lt(c, 7042), c)

def gc.n1409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1409(U32.is_lt(c, 7074), c)
    case False{}:
      gc.n1410(U32.is_lt(c, 7080), c)

def gc.n1412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n1414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n1413(U32.is_lt(c, 7098), c)

def gc.n1415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1412(U32.is_lt(c, 7083), c)
    case False{}:
      gc.n1414(U32.is_lt(c, 7088), c)

def gc.n1416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1411(U32.is_lt(c, 7078), c)
    case False{}:
      gc.n1415(U32.is_lt(c, 7086), c)

def gc.n1417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1408(U32.is_lt(c, 7037), c)
    case False{}:
      gc.n1416(U32.is_lt(c, 7082), c)

def gc.n1418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1401(U32.is_lt(c, 6972), c)
    case False{}:
      gc.n1417(U32.is_lt(c, 7073), c)

def gc.n1419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1386(U32.is_lt(c, 6771), c)
    case False{}:
      gc.n1418(U32.is_lt(c, 7002), c)

def gc.n1420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1355(U32.is_lt(c, 6320), c)
    case False{}:
      gc.n1419(U32.is_lt(c, 6892), c)

def gc.n1421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1421(U32.is_lt(c, 7143), c)
    case False{}:
      gc.n1422(U32.is_lt(c, 7146), c)

def gc.n1424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1424(U32.is_lt(c, 7150), c)
    case False{}:
      gc.n1425(U32.is_lt(c, 7154), c)

def gc.n1427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1423(U32.is_lt(c, 7144), c)
    case False{}:
      gc.n1426(U32.is_lt(c, 7151), c)

def gc.n1428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n1429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1428(U32.is_lt(c, 7164), c)
    case False{}:
      gc.n1429(U32.is_lt(c, 7204), c)

def gc.n1431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n1432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n1433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1431(U32.is_lt(c, 7220), c)
    case False{}:
      gc.n1432(U32.is_lt(c, 7224), c)

def gc.n1434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1430(U32.is_lt(c, 7168), c)
    case False{}:
      gc.n1433(U32.is_lt(c, 7222), c)

def gc.n1435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1427(U32.is_lt(c, 7149), c)
    case False{}:
      gc.n1434(U32.is_lt(c, 7212), c)

def gc.n1436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n1437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n1438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1436(U32.is_lt(c, 7232), c)
    case False{}:
      gc.n1437(U32.is_lt(c, 7245), c)

def gc.n1439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n1440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Po"

def gc.n1441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1439(U32.is_lt(c, 7258), c)
    case False{}:
      gc.n1440(U32.is_lt(c, 7294), c)

def gc.n1442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1438(U32.is_lt(c, 7242), c)
    case False{}:
      gc.n1441(U32.is_lt(c, 7288), c)

def gc.n1443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1443(U32.is_lt(c, 7305), c)
    case False{}:
      gc.n1444(U32.is_lt(c, 7307), c)

def gc.n1446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n1447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Po"

def gc.n1448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1446(U32.is_lt(c, 7355), c)
    case False{}:
      gc.n1447(U32.is_lt(c, 7360), c)

def gc.n1449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1445(U32.is_lt(c, 7306), c)
    case False{}:
      gc.n1448(U32.is_lt(c, 7357), c)

def gc.n1450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1442(U32.is_lt(c, 7248), c)
    case False{}:
      gc.n1449(U32.is_lt(c, 7312), c)

def gc.n1451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1435(U32.is_lt(c, 7156), c)
    case False{}:
      gc.n1450(U32.is_lt(c, 7296), c)

def gc.n1452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n1454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1452(U32.is_lt(c, 7376), c)
    case False{}:
      gc.n1453(U32.is_lt(c, 7380), c)

def gc.n1455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n1456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1455(U32.is_lt(c, 7394), c)
    case False{}:
      gc.n1456(U32.is_lt(c, 7405), c)

def gc.n1458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1454(U32.is_lt(c, 7379), c)
    case False{}:
      gc.n1457(U32.is_lt(c, 7401), c)

def gc.n1459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n1460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n1461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1459(U32.is_lt(c, 7412), c)
    case False{}:
      gc.n1460(U32.is_lt(c, 7415), c)

def gc.n1462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n1463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n1464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1462(U32.is_lt(c, 7418), c)
    case False{}:
      gc.n1463(U32.is_lt(c, 7424), c)

def gc.n1465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1461(U32.is_lt(c, 7413), c)
    case False{}:
      gc.n1464(U32.is_lt(c, 7419), c)

def gc.n1466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1458(U32.is_lt(c, 7393), c)
    case False{}:
      gc.n1465(U32.is_lt(c, 7416), c)

def gc.n1467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Ll"

def gc.n1468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Ll"

def gc.n1469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1467(U32.is_lt(c, 7531), c)
    case False{}:
      gc.n1468(U32.is_lt(c, 7545), c)

def gc.n1470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Mn"

def gc.n1471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1470(U32.is_lt(c, 7616), c)
    case False{}:
      gc.n1471(U32.is_lt(c, 7681), c)

def gc.n1473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1469(U32.is_lt(c, 7544), c)
    case False{}:
      gc.n1472(U32.is_lt(c, 7680), c)

def gc.n1474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1474(U32.is_lt(c, 7683), c)
    case False{}:
      gc.n1475(U32.is_lt(c, 7685), c)

def gc.n1477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n1478(U32.is_lt(c, 7690), c)

def gc.n1480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1477(U32.is_lt(c, 7687), c)
    case False{}:
      gc.n1479(U32.is_lt(c, 7689), c)

def gc.n1481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1476(U32.is_lt(c, 7684), c)
    case False{}:
      gc.n1480(U32.is_lt(c, 7688), c)

def gc.n1482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1473(U32.is_lt(c, 7579), c)
    case False{}:
      gc.n1481(U32.is_lt(c, 7686), c)

def gc.n1483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1466(U32.is_lt(c, 7406), c)
    case False{}:
      gc.n1482(U32.is_lt(c, 7682), c)

def gc.n1484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1451(U32.is_lt(c, 7227), c)
    case False{}:
      gc.n1483(U32.is_lt(c, 7468), c)

def gc.n1485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1485(U32.is_lt(c, 7692), c)
    case False{}:
      gc.n1486(U32.is_lt(c, 7694), c)

def gc.n1488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1488(U32.is_lt(c, 7696), c)
    case False{}:
      gc.n1489(U32.is_lt(c, 7698), c)

def gc.n1491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1487(U32.is_lt(c, 7693), c)
    case False{}:
      gc.n1490(U32.is_lt(c, 7697), c)

def gc.n1492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1492(U32.is_lt(c, 7700), c)
    case False{}:
      gc.n1493(U32.is_lt(c, 7702), c)

def gc.n1495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1495(U32.is_lt(c, 7704), c)
    case False{}:
      gc.n1496(U32.is_lt(c, 7706), c)

def gc.n1498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1494(U32.is_lt(c, 7701), c)
    case False{}:
      gc.n1497(U32.is_lt(c, 7705), c)

def gc.n1499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1491(U32.is_lt(c, 7695), c)
    case False{}:
      gc.n1498(U32.is_lt(c, 7703), c)

def gc.n1500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1500(U32.is_lt(c, 7708), c)
    case False{}:
      gc.n1501(U32.is_lt(c, 7710), c)

def gc.n1503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1503(U32.is_lt(c, 7712), c)
    case False{}:
      gc.n1504(U32.is_lt(c, 7714), c)

def gc.n1506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1502(U32.is_lt(c, 7709), c)
    case False{}:
      gc.n1505(U32.is_lt(c, 7713), c)

def gc.n1507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1507(U32.is_lt(c, 7716), c)
    case False{}:
      gc.n1508(U32.is_lt(c, 7718), c)

def gc.n1510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1510(U32.is_lt(c, 7720), c)
    case False{}:
      gc.n1511(U32.is_lt(c, 7722), c)

def gc.n1513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1509(U32.is_lt(c, 7717), c)
    case False{}:
      gc.n1512(U32.is_lt(c, 7721), c)

def gc.n1514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1506(U32.is_lt(c, 7711), c)
    case False{}:
      gc.n1513(U32.is_lt(c, 7719), c)

def gc.n1515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1499(U32.is_lt(c, 7699), c)
    case False{}:
      gc.n1514(U32.is_lt(c, 7715), c)

def gc.n1516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1516(U32.is_lt(c, 7724), c)
    case False{}:
      gc.n1517(U32.is_lt(c, 7726), c)

def gc.n1519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1519(U32.is_lt(c, 7728), c)
    case False{}:
      gc.n1520(U32.is_lt(c, 7730), c)

def gc.n1522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1518(U32.is_lt(c, 7725), c)
    case False{}:
      gc.n1521(U32.is_lt(c, 7729), c)

def gc.n1523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1523(U32.is_lt(c, 7732), c)
    case False{}:
      gc.n1524(U32.is_lt(c, 7734), c)

def gc.n1526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1526(U32.is_lt(c, 7736), c)
    case False{}:
      gc.n1527(U32.is_lt(c, 7738), c)

def gc.n1529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1525(U32.is_lt(c, 7733), c)
    case False{}:
      gc.n1528(U32.is_lt(c, 7737), c)

def gc.n1530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1522(U32.is_lt(c, 7727), c)
    case False{}:
      gc.n1529(U32.is_lt(c, 7735), c)

def gc.n1531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1531(U32.is_lt(c, 7740), c)
    case False{}:
      gc.n1532(U32.is_lt(c, 7742), c)

def gc.n1534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1534(U32.is_lt(c, 7744), c)
    case False{}:
      gc.n1535(U32.is_lt(c, 7746), c)

def gc.n1537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1533(U32.is_lt(c, 7741), c)
    case False{}:
      gc.n1536(U32.is_lt(c, 7745), c)

def gc.n1538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1538(U32.is_lt(c, 7748), c)
    case False{}:
      gc.n1539(U32.is_lt(c, 7750), c)

def gc.n1541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      gc.n1542(U32.is_lt(c, 7755), c)

def gc.n1544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1541(U32.is_lt(c, 7752), c)
    case False{}:
      gc.n1543(U32.is_lt(c, 7754), c)

def gc.n1545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1540(U32.is_lt(c, 7749), c)
    case False{}:
      gc.n1544(U32.is_lt(c, 7753), c)

def gc.n1546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1537(U32.is_lt(c, 7743), c)
    case False{}:
      gc.n1545(U32.is_lt(c, 7751), c)

def gc.n1547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1530(U32.is_lt(c, 7731), c)
    case False{}:
      gc.n1546(U32.is_lt(c, 7747), c)

def gc.n1548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1515(U32.is_lt(c, 7707), c)
    case False{}:
      gc.n1547(U32.is_lt(c, 7739), c)

def gc.n1549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1484(U32.is_lt(c, 7368), c)
    case False{}:
      gc.n1548(U32.is_lt(c, 7723), c)

def gc.n1550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1420(U32.is_lt(c, 6681), c)
    case False{}:
      gc.n1549(U32.is_lt(c, 7691), c)

def gc.n1551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1292(U32.is_lt(c, 4048), c)
    case False{}:
      gc.n1550(U32.is_lt(c, 7142), c)

def gc.n1552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1552(U32.is_lt(c, 7757), c)
    case False{}:
      gc.n1553(U32.is_lt(c, 7759), c)

def gc.n1555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1555(U32.is_lt(c, 7761), c)
    case False{}:
      gc.n1556(U32.is_lt(c, 7763), c)

def gc.n1558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1554(U32.is_lt(c, 7758), c)
    case False{}:
      gc.n1557(U32.is_lt(c, 7762), c)

def gc.n1559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1559(U32.is_lt(c, 7765), c)
    case False{}:
      gc.n1560(U32.is_lt(c, 7767), c)

def gc.n1562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1562(U32.is_lt(c, 7769), c)
    case False{}:
      gc.n1563(U32.is_lt(c, 7771), c)

def gc.n1565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1561(U32.is_lt(c, 7766), c)
    case False{}:
      gc.n1564(U32.is_lt(c, 7770), c)

def gc.n1566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1558(U32.is_lt(c, 7760), c)
    case False{}:
      gc.n1565(U32.is_lt(c, 7768), c)

def gc.n1567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1567(U32.is_lt(c, 7773), c)
    case False{}:
      gc.n1568(U32.is_lt(c, 7775), c)

def gc.n1570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1570(U32.is_lt(c, 7777), c)
    case False{}:
      gc.n1571(U32.is_lt(c, 7779), c)

def gc.n1573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1569(U32.is_lt(c, 7774), c)
    case False{}:
      gc.n1572(U32.is_lt(c, 7778), c)

def gc.n1574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1574(U32.is_lt(c, 7781), c)
    case False{}:
      gc.n1575(U32.is_lt(c, 7783), c)

def gc.n1577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1577(U32.is_lt(c, 7785), c)
    case False{}:
      gc.n1578(U32.is_lt(c, 7787), c)

def gc.n1580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1576(U32.is_lt(c, 7782), c)
    case False{}:
      gc.n1579(U32.is_lt(c, 7786), c)

def gc.n1581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1573(U32.is_lt(c, 7776), c)
    case False{}:
      gc.n1580(U32.is_lt(c, 7784), c)

def gc.n1582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1566(U32.is_lt(c, 7764), c)
    case False{}:
      gc.n1581(U32.is_lt(c, 7780), c)

def gc.n1583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1583(U32.is_lt(c, 7789), c)
    case False{}:
      gc.n1584(U32.is_lt(c, 7791), c)

def gc.n1586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1586(U32.is_lt(c, 7793), c)
    case False{}:
      gc.n1587(U32.is_lt(c, 7795), c)

def gc.n1589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1585(U32.is_lt(c, 7790), c)
    case False{}:
      gc.n1588(U32.is_lt(c, 7794), c)

def gc.n1590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1590(U32.is_lt(c, 7797), c)
    case False{}:
      gc.n1591(U32.is_lt(c, 7799), c)

def gc.n1593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1593(U32.is_lt(c, 7801), c)
    case False{}:
      gc.n1594(U32.is_lt(c, 7803), c)

def gc.n1596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1592(U32.is_lt(c, 7798), c)
    case False{}:
      gc.n1595(U32.is_lt(c, 7802), c)

def gc.n1597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1589(U32.is_lt(c, 7792), c)
    case False{}:
      gc.n1596(U32.is_lt(c, 7800), c)

def gc.n1598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1598(U32.is_lt(c, 7805), c)
    case False{}:
      gc.n1599(U32.is_lt(c, 7807), c)

def gc.n1601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1601(U32.is_lt(c, 7809), c)
    case False{}:
      gc.n1602(U32.is_lt(c, 7811), c)

def gc.n1604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1600(U32.is_lt(c, 7806), c)
    case False{}:
      gc.n1603(U32.is_lt(c, 7810), c)

def gc.n1605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1605(U32.is_lt(c, 7813), c)
    case False{}:
      gc.n1606(U32.is_lt(c, 7815), c)

def gc.n1608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1608(U32.is_lt(c, 7817), c)
    case False{}:
      gc.n1609(U32.is_lt(c, 7819), c)

def gc.n1611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1607(U32.is_lt(c, 7814), c)
    case False{}:
      gc.n1610(U32.is_lt(c, 7818), c)

def gc.n1612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1604(U32.is_lt(c, 7808), c)
    case False{}:
      gc.n1611(U32.is_lt(c, 7816), c)

def gc.n1613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1597(U32.is_lt(c, 7796), c)
    case False{}:
      gc.n1612(U32.is_lt(c, 7812), c)

def gc.n1614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1582(U32.is_lt(c, 7772), c)
    case False{}:
      gc.n1613(U32.is_lt(c, 7804), c)

def gc.n1615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1615(U32.is_lt(c, 7821), c)
    case False{}:
      gc.n1616(U32.is_lt(c, 7823), c)

def gc.n1618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1618(U32.is_lt(c, 7825), c)
    case False{}:
      gc.n1619(U32.is_lt(c, 7827), c)

def gc.n1621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1617(U32.is_lt(c, 7822), c)
    case False{}:
      gc.n1620(U32.is_lt(c, 7826), c)

def gc.n1622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1622(U32.is_lt(c, 7829), c)
    case False{}:
      gc.n1623(U32.is_lt(c, 7839), c)

def gc.n1625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1625(U32.is_lt(c, 7841), c)
    case False{}:
      gc.n1626(U32.is_lt(c, 7843), c)

def gc.n1628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1624(U32.is_lt(c, 7838), c)
    case False{}:
      gc.n1627(U32.is_lt(c, 7842), c)

def gc.n1629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1621(U32.is_lt(c, 7824), c)
    case False{}:
      gc.n1628(U32.is_lt(c, 7840), c)

def gc.n1630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1630(U32.is_lt(c, 7845), c)
    case False{}:
      gc.n1631(U32.is_lt(c, 7847), c)

def gc.n1633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1633(U32.is_lt(c, 7849), c)
    case False{}:
      gc.n1634(U32.is_lt(c, 7851), c)

def gc.n1636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1632(U32.is_lt(c, 7846), c)
    case False{}:
      gc.n1635(U32.is_lt(c, 7850), c)

def gc.n1637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1637(U32.is_lt(c, 7853), c)
    case False{}:
      gc.n1638(U32.is_lt(c, 7855), c)

def gc.n1640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1640(U32.is_lt(c, 7857), c)
    case False{}:
      gc.n1641(U32.is_lt(c, 7859), c)

def gc.n1643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1639(U32.is_lt(c, 7854), c)
    case False{}:
      gc.n1642(U32.is_lt(c, 7858), c)

def gc.n1644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1636(U32.is_lt(c, 7848), c)
    case False{}:
      gc.n1643(U32.is_lt(c, 7856), c)

def gc.n1645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1629(U32.is_lt(c, 7828), c)
    case False{}:
      gc.n1644(U32.is_lt(c, 7852), c)

def gc.n1646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1646(U32.is_lt(c, 7861), c)
    case False{}:
      gc.n1647(U32.is_lt(c, 7863), c)

def gc.n1649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1649(U32.is_lt(c, 7865), c)
    case False{}:
      gc.n1650(U32.is_lt(c, 7867), c)

def gc.n1652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1648(U32.is_lt(c, 7862), c)
    case False{}:
      gc.n1651(U32.is_lt(c, 7866), c)

def gc.n1653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1653(U32.is_lt(c, 7869), c)
    case False{}:
      gc.n1654(U32.is_lt(c, 7871), c)

def gc.n1656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1656(U32.is_lt(c, 7873), c)
    case False{}:
      gc.n1657(U32.is_lt(c, 7875), c)

def gc.n1659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1655(U32.is_lt(c, 7870), c)
    case False{}:
      gc.n1658(U32.is_lt(c, 7874), c)

def gc.n1660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1652(U32.is_lt(c, 7864), c)
    case False{}:
      gc.n1659(U32.is_lt(c, 7872), c)

def gc.n1661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1661(U32.is_lt(c, 7877), c)
    case False{}:
      gc.n1662(U32.is_lt(c, 7879), c)

def gc.n1664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1664(U32.is_lt(c, 7881), c)
    case False{}:
      gc.n1665(U32.is_lt(c, 7883), c)

def gc.n1667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1663(U32.is_lt(c, 7878), c)
    case False{}:
      gc.n1666(U32.is_lt(c, 7882), c)

def gc.n1668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1668(U32.is_lt(c, 7885), c)
    case False{}:
      gc.n1669(U32.is_lt(c, 7887), c)

def gc.n1671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n1672(U32.is_lt(c, 7892), c)

def gc.n1674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1671(U32.is_lt(c, 7889), c)
    case False{}:
      gc.n1673(U32.is_lt(c, 7891), c)

def gc.n1675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1670(U32.is_lt(c, 7886), c)
    case False{}:
      gc.n1674(U32.is_lt(c, 7890), c)

def gc.n1676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1667(U32.is_lt(c, 7880), c)
    case False{}:
      gc.n1675(U32.is_lt(c, 7888), c)

def gc.n1677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1660(U32.is_lt(c, 7868), c)
    case False{}:
      gc.n1676(U32.is_lt(c, 7884), c)

def gc.n1678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1645(U32.is_lt(c, 7844), c)
    case False{}:
      gc.n1677(U32.is_lt(c, 7876), c)

def gc.n1679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1614(U32.is_lt(c, 7788), c)
    case False{}:
      gc.n1678(U32.is_lt(c, 7860), c)

def gc.n1680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1680(U32.is_lt(c, 7894), c)
    case False{}:
      gc.n1681(U32.is_lt(c, 7896), c)

def gc.n1683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1683(U32.is_lt(c, 7898), c)
    case False{}:
      gc.n1684(U32.is_lt(c, 7900), c)

def gc.n1686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1682(U32.is_lt(c, 7895), c)
    case False{}:
      gc.n1685(U32.is_lt(c, 7899), c)

def gc.n1687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1687(U32.is_lt(c, 7902), c)
    case False{}:
      gc.n1688(U32.is_lt(c, 7904), c)

def gc.n1690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1690(U32.is_lt(c, 7906), c)
    case False{}:
      gc.n1691(U32.is_lt(c, 7908), c)

def gc.n1693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1689(U32.is_lt(c, 7903), c)
    case False{}:
      gc.n1692(U32.is_lt(c, 7907), c)

def gc.n1694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1686(U32.is_lt(c, 7897), c)
    case False{}:
      gc.n1693(U32.is_lt(c, 7905), c)

def gc.n1695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1695(U32.is_lt(c, 7910), c)
    case False{}:
      gc.n1696(U32.is_lt(c, 7912), c)

def gc.n1698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1698(U32.is_lt(c, 7914), c)
    case False{}:
      gc.n1699(U32.is_lt(c, 7916), c)

def gc.n1701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1697(U32.is_lt(c, 7911), c)
    case False{}:
      gc.n1700(U32.is_lt(c, 7915), c)

def gc.n1702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1702(U32.is_lt(c, 7918), c)
    case False{}:
      gc.n1703(U32.is_lt(c, 7920), c)

def gc.n1705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1705(U32.is_lt(c, 7922), c)
    case False{}:
      gc.n1706(U32.is_lt(c, 7924), c)

def gc.n1708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1704(U32.is_lt(c, 7919), c)
    case False{}:
      gc.n1707(U32.is_lt(c, 7923), c)

def gc.n1709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1701(U32.is_lt(c, 7913), c)
    case False{}:
      gc.n1708(U32.is_lt(c, 7921), c)

def gc.n1710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1694(U32.is_lt(c, 7901), c)
    case False{}:
      gc.n1709(U32.is_lt(c, 7917), c)

def gc.n1711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1711(U32.is_lt(c, 7926), c)
    case False{}:
      gc.n1712(U32.is_lt(c, 7928), c)

def gc.n1714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1714(U32.is_lt(c, 7930), c)
    case False{}:
      gc.n1715(U32.is_lt(c, 7932), c)

def gc.n1717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1713(U32.is_lt(c, 7927), c)
    case False{}:
      gc.n1716(U32.is_lt(c, 7931), c)

def gc.n1718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1718(U32.is_lt(c, 7934), c)
    case False{}:
      gc.n1719(U32.is_lt(c, 7944), c)

def gc.n1721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n1723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1721(U32.is_lt(c, 7958), c)
    case False{}:
      gc.n1722(U32.is_lt(c, 7966), c)

def gc.n1724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1720(U32.is_lt(c, 7935), c)
    case False{}:
      gc.n1723(U32.is_lt(c, 7960), c)

def gc.n1725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1717(U32.is_lt(c, 7929), c)
    case False{}:
      gc.n1724(U32.is_lt(c, 7952), c)

def gc.n1726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1726(U32.is_lt(c, 7976), c)
    case False{}:
      gc.n1727(U32.is_lt(c, 7992), c)

def gc.n1729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n1731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1729(U32.is_lt(c, 8006), c)
    case False{}:
      gc.n1730(U32.is_lt(c, 8014), c)

def gc.n1732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1728(U32.is_lt(c, 7984), c)
    case False{}:
      gc.n1731(U32.is_lt(c, 8008), c)

def gc.n1733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n1735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1733(U32.is_lt(c, 8024), c)
    case False{}:
      gc.n1734(U32.is_lt(c, 8026), c)

def gc.n1736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n1737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n1738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n1737(U32.is_lt(c, 8031), c)

def gc.n1739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1736(U32.is_lt(c, 8028), c)
    case False{}:
      gc.n1738(U32.is_lt(c, 8030), c)

def gc.n1740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1735(U32.is_lt(c, 8025), c)
    case False{}:
      gc.n1739(U32.is_lt(c, 8029), c)

def gc.n1741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1732(U32.is_lt(c, 8000), c)
    case False{}:
      gc.n1740(U32.is_lt(c, 8027), c)

def gc.n1742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1725(U32.is_lt(c, 7933), c)
    case False{}:
      gc.n1741(U32.is_lt(c, 8016), c)

def gc.n1743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1710(U32.is_lt(c, 7909), c)
    case False{}:
      gc.n1742(U32.is_lt(c, 7968), c)

def gc.n1744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1744(U32.is_lt(c, 8040), c)
    case False{}:
      gc.n1745(U32.is_lt(c, 8062), c)

def gc.n1747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lt"

def gc.n1748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lt"

def gc.n1749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1747(U32.is_lt(c, 8072), c)
    case False{}:
      gc.n1748(U32.is_lt(c, 8088), c)

def gc.n1750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1746(U32.is_lt(c, 8048), c)
    case False{}:
      gc.n1749(U32.is_lt(c, 8080), c)

def gc.n1751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lt"

def gc.n1752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1751(U32.is_lt(c, 8104), c)
    case False{}:
      gc.n1752(U32.is_lt(c, 8117), c)

def gc.n1754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lt"
    case False{}:
      "Sk"

def gc.n1756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1754(U32.is_lt(c, 8120), c)
    case False{}:
      gc.n1755(U32.is_lt(c, 8125), c)

def gc.n1757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1753(U32.is_lt(c, 8112), c)
    case False{}:
      gc.n1756(U32.is_lt(c, 8124), c)

def gc.n1758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1750(U32.is_lt(c, 8064), c)
    case False{}:
      gc.n1757(U32.is_lt(c, 8118), c)

def gc.n1759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Sk"

def gc.n1760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1759(U32.is_lt(c, 8127), c)
    case False{}:
      gc.n1760(U32.is_lt(c, 8133), c)

def gc.n1762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lt"
    case False{}:
      "Sk"

def gc.n1764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1762(U32.is_lt(c, 8136), c)
    case False{}:
      gc.n1763(U32.is_lt(c, 8141), c)

def gc.n1765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1761(U32.is_lt(c, 8130), c)
    case False{}:
      gc.n1764(U32.is_lt(c, 8140), c)

def gc.n1766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1766(U32.is_lt(c, 8148), c)
    case False{}:
      gc.n1767(U32.is_lt(c, 8152), c)

def gc.n1769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sk"

def gc.n1770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1769(U32.is_lt(c, 8157), c)
    case False{}:
      gc.n1770(U32.is_lt(c, 8168), c)

def gc.n1772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1768(U32.is_lt(c, 8150), c)
    case False{}:
      gc.n1771(U32.is_lt(c, 8160), c)

def gc.n1773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1765(U32.is_lt(c, 8134), c)
    case False{}:
      gc.n1772(U32.is_lt(c, 8156), c)

def gc.n1774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1758(U32.is_lt(c, 8096), c)
    case False{}:
      gc.n1773(U32.is_lt(c, 8144), c)

def gc.n1775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Cn"

def gc.n1776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n1777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1775(U32.is_lt(c, 8176), c)
    case False{}:
      gc.n1776(U32.is_lt(c, 8181), c)

def gc.n1778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lt"
    case False{}:
      "Sk"

def gc.n1780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1778(U32.is_lt(c, 8184), c)
    case False{}:
      gc.n1779(U32.is_lt(c, 8189), c)

def gc.n1781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1777(U32.is_lt(c, 8178), c)
    case False{}:
      gc.n1780(U32.is_lt(c, 8188), c)

def gc.n1782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Zs"

def gc.n1783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Pd"

def gc.n1784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1782(U32.is_lt(c, 8192), c)
    case False{}:
      gc.n1783(U32.is_lt(c, 8208), c)

def gc.n1785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pi"

def gc.n1786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pf"
    case False{}:
      "Ps"

def gc.n1787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1785(U32.is_lt(c, 8216), c)
    case False{}:
      gc.n1786(U32.is_lt(c, 8218), c)

def gc.n1788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1784(U32.is_lt(c, 8203), c)
    case False{}:
      gc.n1787(U32.is_lt(c, 8217), c)

def gc.n1789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1781(U32.is_lt(c, 8182), c)
    case False{}:
      gc.n1788(U32.is_lt(c, 8214), c)

def gc.n1790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pi"
    case False{}:
      "Pf"

def gc.n1791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pi"

def gc.n1792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1790(U32.is_lt(c, 8221), c)
    case False{}:
      gc.n1791(U32.is_lt(c, 8223), c)

def gc.n1793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Zl"

def gc.n1794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Zp"
    case False{}:
      "Cf"

def gc.n1795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1793(U32.is_lt(c, 8232), c)
    case False{}:
      gc.n1794(U32.is_lt(c, 8234), c)

def gc.n1796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1792(U32.is_lt(c, 8222), c)
    case False{}:
      gc.n1795(U32.is_lt(c, 8233), c)

def gc.n1797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Zs"
    case False{}:
      "Po"

def gc.n1798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pi"
    case False{}:
      "Pf"

def gc.n1799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1797(U32.is_lt(c, 8240), c)
    case False{}:
      gc.n1798(U32.is_lt(c, 8250), c)

def gc.n1800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pc"

def gc.n1801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ps"

def gc.n1802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      gc.n1801(U32.is_lt(c, 8261), c)

def gc.n1803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1800(U32.is_lt(c, 8255), c)
    case False{}:
      gc.n1802(U32.is_lt(c, 8260), c)

def gc.n1804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1799(U32.is_lt(c, 8249), c)
    case False{}:
      gc.n1803(U32.is_lt(c, 8257), c)

def gc.n1805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1796(U32.is_lt(c, 8224), c)
    case False{}:
      gc.n1804(U32.is_lt(c, 8251), c)

def gc.n1806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1789(U32.is_lt(c, 8191), c)
    case False{}:
      gc.n1805(U32.is_lt(c, 8239), c)

def gc.n1807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1774(U32.is_lt(c, 8126), c)
    case False{}:
      gc.n1806(U32.is_lt(c, 8219), c)

def gc.n1808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1743(U32.is_lt(c, 7925), c)
    case False{}:
      gc.n1807(U32.is_lt(c, 8173), c)

def gc.n1809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1679(U32.is_lt(c, 7820), c)
    case False{}:
      gc.n1808(U32.is_lt(c, 8032), c)

def gc.n1810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Po"

def gc.n1811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Po"

def gc.n1812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1810(U32.is_lt(c, 8263), c)
    case False{}:
      gc.n1811(U32.is_lt(c, 8275), c)

def gc.n1813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pc"
    case False{}:
      "Po"

def gc.n1814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Zs"
    case False{}:
      "Cf"

def gc.n1815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1813(U32.is_lt(c, 8277), c)
    case False{}:
      gc.n1814(U32.is_lt(c, 8288), c)

def gc.n1816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1812(U32.is_lt(c, 8274), c)
    case False{}:
      gc.n1815(U32.is_lt(c, 8287), c)

def gc.n1817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Cf"

def gc.n1818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Lm"

def gc.n1819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1817(U32.is_lt(c, 8294), c)
    case False{}:
      gc.n1818(U32.is_lt(c, 8305), c)

def gc.n1820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n1821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ps"

def gc.n1822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1820(U32.is_lt(c, 8308), c)
    case False{}:
      gc.n1821(U32.is_lt(c, 8317), c)

def gc.n1823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1819(U32.is_lt(c, 8304), c)
    case False{}:
      gc.n1822(U32.is_lt(c, 8314), c)

def gc.n1824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1816(U32.is_lt(c, 8276), c)
    case False{}:
      gc.n1823(U32.is_lt(c, 8306), c)

def gc.n1825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Lm"

def gc.n1826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Sm"

def gc.n1827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1825(U32.is_lt(c, 8319), c)
    case False{}:
      gc.n1826(U32.is_lt(c, 8330), c)

def gc.n1828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n1830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1828(U32.is_lt(c, 8334), c)
    case False{}:
      gc.n1829(U32.is_lt(c, 8336), c)

def gc.n1831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1827(U32.is_lt(c, 8320), c)
    case False{}:
      gc.n1830(U32.is_lt(c, 8335), c)

def gc.n1832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sc"

def gc.n1833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n1834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1832(U32.is_lt(c, 8352), c)
    case False{}:
      gc.n1833(U32.is_lt(c, 8400), c)

def gc.n1835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Me"
    case False{}:
      "Mn"

def gc.n1836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Me"
    case False{}:
      "Mn"

def gc.n1837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1835(U32.is_lt(c, 8417), c)
    case False{}:
      gc.n1836(U32.is_lt(c, 8421), c)

def gc.n1838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1834(U32.is_lt(c, 8386), c)
    case False{}:
      gc.n1837(U32.is_lt(c, 8418), c)

def gc.n1839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1831(U32.is_lt(c, 8333), c)
    case False{}:
      gc.n1838(U32.is_lt(c, 8413), c)

def gc.n1840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1824(U32.is_lt(c, 8293), c)
    case False{}:
      gc.n1839(U32.is_lt(c, 8349), c)

def gc.n1841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n1842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "So"

def gc.n1843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1841(U32.is_lt(c, 8448), c)
    case False{}:
      gc.n1842(U32.is_lt(c, 8451), c)

def gc.n1844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "So"

def gc.n1845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1844(U32.is_lt(c, 8456), c)
    case False{}:
      gc.n1845(U32.is_lt(c, 8459), c)

def gc.n1847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1843(U32.is_lt(c, 8450), c)
    case False{}:
      gc.n1846(U32.is_lt(c, 8458), c)

def gc.n1848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n1849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "So"

def gc.n1850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1848(U32.is_lt(c, 8464), c)
    case False{}:
      gc.n1849(U32.is_lt(c, 8468), c)

def gc.n1851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "So"

def gc.n1852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Lu"

def gc.n1853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1851(U32.is_lt(c, 8470), c)
    case False{}:
      gc.n1852(U32.is_lt(c, 8473), c)

def gc.n1854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1850(U32.is_lt(c, 8467), c)
    case False{}:
      gc.n1853(U32.is_lt(c, 8472), c)

def gc.n1855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1847(U32.is_lt(c, 8455), c)
    case False{}:
      gc.n1854(U32.is_lt(c, 8469), c)

def gc.n1856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n1857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n1858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1856(U32.is_lt(c, 8484), c)
    case False{}:
      gc.n1857(U32.is_lt(c, 8486), c)

def gc.n1859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n1860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n1861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1859(U32.is_lt(c, 8488), c)
    case False{}:
      gc.n1860(U32.is_lt(c, 8490), c)

def gc.n1862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1858(U32.is_lt(c, 8485), c)
    case False{}:
      gc.n1861(U32.is_lt(c, 8489), c)

def gc.n1863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ll"

def gc.n1864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1863(U32.is_lt(c, 8495), c)
    case False{}:
      gc.n1864(U32.is_lt(c, 8500), c)

def gc.n1866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Ll"

def gc.n1867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ll"

def gc.n1868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1866(U32.is_lt(c, 8505), c)
    case False{}:
      gc.n1867(U32.is_lt(c, 8508), c)

def gc.n1869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1865(U32.is_lt(c, 8496), c)
    case False{}:
      gc.n1868(U32.is_lt(c, 8506), c)

def gc.n1870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1862(U32.is_lt(c, 8487), c)
    case False{}:
      gc.n1869(U32.is_lt(c, 8501), c)

def gc.n1871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1855(U32.is_lt(c, 8462), c)
    case False{}:
      gc.n1870(U32.is_lt(c, 8494), c)

def gc.n1872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1840(U32.is_lt(c, 8318), c)
    case False{}:
      gc.n1871(U32.is_lt(c, 8478), c)

def gc.n1873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Sm"

def gc.n1874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n1875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1873(U32.is_lt(c, 8512), c)
    case False{}:
      gc.n1874(U32.is_lt(c, 8518), c)

def gc.n1876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ll"

def gc.n1878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1876(U32.is_lt(c, 8523), c)
    case False{}:
      gc.n1877(U32.is_lt(c, 8526), c)

def gc.n1879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1875(U32.is_lt(c, 8517), c)
    case False{}:
      gc.n1878(U32.is_lt(c, 8524), c)

def gc.n1880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "No"

def gc.n1881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Lu"

def gc.n1882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1880(U32.is_lt(c, 8528), c)
    case False{}:
      gc.n1881(U32.is_lt(c, 8579), c)

def gc.n1883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Nl"

def gc.n1884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n1885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1883(U32.is_lt(c, 8581), c)
    case False{}:
      gc.n1884(U32.is_lt(c, 8586), c)

def gc.n1886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1882(U32.is_lt(c, 8544), c)
    case False{}:
      gc.n1885(U32.is_lt(c, 8585), c)

def gc.n1887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1879(U32.is_lt(c, 8522), c)
    case False{}:
      gc.n1886(U32.is_lt(c, 8580), c)

def gc.n1888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sm"

def gc.n1889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1888(U32.is_lt(c, 8592), c)
    case False{}:
      gc.n1889(U32.is_lt(c, 8602), c)

def gc.n1891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1891(U32.is_lt(c, 8608), c)
    case False{}:
      gc.n1892(U32.is_lt(c, 8611), c)

def gc.n1894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1890(U32.is_lt(c, 8597), c)
    case False{}:
      gc.n1893(U32.is_lt(c, 8609), c)

def gc.n1895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1895(U32.is_lt(c, 8614), c)
    case False{}:
      gc.n1896(U32.is_lt(c, 8622), c)

def gc.n1898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1898(U32.is_lt(c, 8654), c)
    case False{}:
      gc.n1899(U32.is_lt(c, 8658), c)

def gc.n1901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1897(U32.is_lt(c, 8615), c)
    case False{}:
      gc.n1900(U32.is_lt(c, 8656), c)

def gc.n1902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1894(U32.is_lt(c, 8604), c)
    case False{}:
      gc.n1901(U32.is_lt(c, 8623), c)

def gc.n1903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1887(U32.is_lt(c, 8527), c)
    case False{}:
      gc.n1902(U32.is_lt(c, 8612), c)

def gc.n1904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1904(U32.is_lt(c, 8660), c)
    case False{}:
      gc.n1905(U32.is_lt(c, 8692), c)

def gc.n1907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ps"

def gc.n1908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1907(U32.is_lt(c, 8968), c)
    case False{}:
      gc.n1908(U32.is_lt(c, 8970), c)

def gc.n1910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1906(U32.is_lt(c, 8661), c)
    case False{}:
      gc.n1909(U32.is_lt(c, 8969), c)

def gc.n1911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "So"

def gc.n1912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "So"

def gc.n1913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1911(U32.is_lt(c, 8972), c)
    case False{}:
      gc.n1912(U32.is_lt(c, 8994), c)

def gc.n1914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1914(U32.is_lt(c, 9002), c)
    case False{}:
      gc.n1915(U32.is_lt(c, 9084), c)

def gc.n1917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1913(U32.is_lt(c, 8992), c)
    case False{}:
      gc.n1916(U32.is_lt(c, 9003), c)

def gc.n1918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1910(U32.is_lt(c, 8960), c)
    case False{}:
      gc.n1917(U32.is_lt(c, 9001), c)

def gc.n1919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1919(U32.is_lt(c, 9115), c)
    case False{}:
      gc.n1920(U32.is_lt(c, 9180), c)

def gc.n1922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n1923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n1924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1922(U32.is_lt(c, 9258), c)
    case False{}:
      gc.n1923(U32.is_lt(c, 9291), c)

def gc.n1925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1921(U32.is_lt(c, 9140), c)
    case False{}:
      gc.n1924(U32.is_lt(c, 9280), c)

def gc.n1926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n1927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n1928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1926(U32.is_lt(c, 9372), c)
    case False{}:
      gc.n1927(U32.is_lt(c, 9472), c)

def gc.n1929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "So"

def gc.n1930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      gc.n1930(U32.is_lt(c, 9720), c)

def gc.n1932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1929(U32.is_lt(c, 9656), c)
    case False{}:
      gc.n1931(U32.is_lt(c, 9666), c)

def gc.n1933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1928(U32.is_lt(c, 9450), c)
    case False{}:
      gc.n1932(U32.is_lt(c, 9665), c)

def gc.n1934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1925(U32.is_lt(c, 9186), c)
    case False{}:
      gc.n1933(U32.is_lt(c, 9655), c)

def gc.n1935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1918(U32.is_lt(c, 8971), c)
    case False{}:
      gc.n1934(U32.is_lt(c, 9312), c)

def gc.n1936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1903(U32.is_lt(c, 8588), c)
    case False{}:
      gc.n1935(U32.is_lt(c, 9085), c)

def gc.n1937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1872(U32.is_lt(c, 8433), c)
    case False{}:
      gc.n1936(U32.is_lt(c, 8659), c)

def gc.n1938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ps"

def gc.n1940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1938(U32.is_lt(c, 9839), c)
    case False{}:
      gc.n1939(U32.is_lt(c, 10088), c)

def gc.n1941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1941(U32.is_lt(c, 10090), c)
    case False{}:
      gc.n1942(U32.is_lt(c, 10092), c)

def gc.n1944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1940(U32.is_lt(c, 9840), c)
    case False{}:
      gc.n1943(U32.is_lt(c, 10091), c)

def gc.n1945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1945(U32.is_lt(c, 10094), c)
    case False{}:
      gc.n1946(U32.is_lt(c, 10096), c)

def gc.n1948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1948(U32.is_lt(c, 10098), c)
    case False{}:
      gc.n1949(U32.is_lt(c, 10100), c)

def gc.n1951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1947(U32.is_lt(c, 10095), c)
    case False{}:
      gc.n1950(U32.is_lt(c, 10099), c)

def gc.n1952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1944(U32.is_lt(c, 10089), c)
    case False{}:
      gc.n1951(U32.is_lt(c, 10097), c)

def gc.n1953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "No"

def gc.n1954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1953(U32.is_lt(c, 10102), c)
    case False{}:
      gc.n1954(U32.is_lt(c, 10176), c)

def gc.n1956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ps"

def gc.n1958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1956(U32.is_lt(c, 10182), c)
    case False{}:
      gc.n1957(U32.is_lt(c, 10214), c)

def gc.n1959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1955(U32.is_lt(c, 10132), c)
    case False{}:
      gc.n1958(U32.is_lt(c, 10183), c)

def gc.n1960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1960(U32.is_lt(c, 10216), c)
    case False{}:
      gc.n1961(U32.is_lt(c, 10218), c)

def gc.n1963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1963(U32.is_lt(c, 10220), c)
    case False{}:
      gc.n1964(U32.is_lt(c, 10222), c)

def gc.n1966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1962(U32.is_lt(c, 10217), c)
    case False{}:
      gc.n1965(U32.is_lt(c, 10221), c)

def gc.n1967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1959(U32.is_lt(c, 10181), c)
    case False{}:
      gc.n1966(U32.is_lt(c, 10219), c)

def gc.n1968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1952(U32.is_lt(c, 10093), c)
    case False{}:
      gc.n1967(U32.is_lt(c, 10215), c)

def gc.n1969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Sm"

def gc.n1970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n1971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1969(U32.is_lt(c, 10224), c)
    case False{}:
      gc.n1970(U32.is_lt(c, 10496), c)

def gc.n1972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1972(U32.is_lt(c, 10628), c)
    case False{}:
      gc.n1973(U32.is_lt(c, 10630), c)

def gc.n1975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1971(U32.is_lt(c, 10240), c)
    case False{}:
      gc.n1974(U32.is_lt(c, 10629), c)

def gc.n1976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1976(U32.is_lt(c, 10632), c)
    case False{}:
      gc.n1977(U32.is_lt(c, 10634), c)

def gc.n1979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1979(U32.is_lt(c, 10636), c)
    case False{}:
      gc.n1980(U32.is_lt(c, 10638), c)

def gc.n1982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1978(U32.is_lt(c, 10633), c)
    case False{}:
      gc.n1981(U32.is_lt(c, 10637), c)

def gc.n1983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1975(U32.is_lt(c, 10627), c)
    case False{}:
      gc.n1982(U32.is_lt(c, 10635), c)

def gc.n1984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1984(U32.is_lt(c, 10640), c)
    case False{}:
      gc.n1985(U32.is_lt(c, 10642), c)

def gc.n1987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1987(U32.is_lt(c, 10644), c)
    case False{}:
      gc.n1988(U32.is_lt(c, 10646), c)

def gc.n1990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1986(U32.is_lt(c, 10641), c)
    case False{}:
      gc.n1989(U32.is_lt(c, 10645), c)

def gc.n1991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n1992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ps"

def gc.n1993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1991(U32.is_lt(c, 10648), c)
    case False{}:
      gc.n1992(U32.is_lt(c, 10712), c)

def gc.n1994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n1995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ps"

def gc.n1996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      gc.n1995(U32.is_lt(c, 10748), c)

def gc.n1997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1994(U32.is_lt(c, 10714), c)
    case False{}:
      gc.n1996(U32.is_lt(c, 10716), c)

def gc.n1998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1993(U32.is_lt(c, 10649), c)
    case False{}:
      gc.n1997(U32.is_lt(c, 10715), c)

def gc.n1999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1990(U32.is_lt(c, 10643), c)
    case False{}:
      gc.n1998(U32.is_lt(c, 10713), c)

def gc.n2000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1983(U32.is_lt(c, 10631), c)
    case False{}:
      gc.n1999(U32.is_lt(c, 10647), c)

def gc.n2001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1968(U32.is_lt(c, 10101), c)
    case False{}:
      gc.n2000(U32.is_lt(c, 10639), c)

def gc.n2002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Sm"

def gc.n2003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n2004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2002(U32.is_lt(c, 10750), c)
    case False{}:
      gc.n2003(U32.is_lt(c, 11056), c)

def gc.n2005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n2006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2005(U32.is_lt(c, 11079), c)
    case False{}:
      gc.n2006(U32.is_lt(c, 11124), c)

def gc.n2008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2004(U32.is_lt(c, 11008), c)
    case False{}:
      gc.n2007(U32.is_lt(c, 11085), c)

def gc.n2009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lu"

def gc.n2010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2009(U32.is_lt(c, 11264), c)
    case False{}:
      gc.n2010(U32.is_lt(c, 11360), c)

def gc.n2012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2012(U32.is_lt(c, 11362), c)
    case False{}:
      gc.n2013(U32.is_lt(c, 11367), c)

def gc.n2015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2011(U32.is_lt(c, 11312), c)
    case False{}:
      gc.n2014(U32.is_lt(c, 11365), c)

def gc.n2016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2008(U32.is_lt(c, 11077), c)
    case False{}:
      gc.n2015(U32.is_lt(c, 11361), c)

def gc.n2017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2017(U32.is_lt(c, 11369), c)
    case False{}:
      gc.n2018(U32.is_lt(c, 11371), c)

def gc.n2020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2020(U32.is_lt(c, 11373), c)
    case False{}:
      gc.n2021(U32.is_lt(c, 11378), c)

def gc.n2023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2019(U32.is_lt(c, 11370), c)
    case False{}:
      gc.n2022(U32.is_lt(c, 11377), c)

def gc.n2024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lm"

def gc.n2026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2024(U32.is_lt(c, 11381), c)
    case False{}:
      gc.n2025(U32.is_lt(c, 11388), c)

def gc.n2027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2027(U32.is_lt(c, 11393), c)
    case False{}:
      gc.n2028(U32.is_lt(c, 11395), c)

def gc.n2030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2026(U32.is_lt(c, 11382), c)
    case False{}:
      gc.n2029(U32.is_lt(c, 11394), c)

def gc.n2031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2023(U32.is_lt(c, 11372), c)
    case False{}:
      gc.n2030(U32.is_lt(c, 11390), c)

def gc.n2032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2016(U32.is_lt(c, 11126), c)
    case False{}:
      gc.n2031(U32.is_lt(c, 11379), c)

def gc.n2033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2033(U32.is_lt(c, 11397), c)
    case False{}:
      gc.n2034(U32.is_lt(c, 11399), c)

def gc.n2036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2036(U32.is_lt(c, 11401), c)
    case False{}:
      gc.n2037(U32.is_lt(c, 11403), c)

def gc.n2039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2035(U32.is_lt(c, 11398), c)
    case False{}:
      gc.n2038(U32.is_lt(c, 11402), c)

def gc.n2040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2040(U32.is_lt(c, 11405), c)
    case False{}:
      gc.n2041(U32.is_lt(c, 11407), c)

def gc.n2043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2043(U32.is_lt(c, 11409), c)
    case False{}:
      gc.n2044(U32.is_lt(c, 11411), c)

def gc.n2046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2042(U32.is_lt(c, 11406), c)
    case False{}:
      gc.n2045(U32.is_lt(c, 11410), c)

def gc.n2047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2039(U32.is_lt(c, 11400), c)
    case False{}:
      gc.n2046(U32.is_lt(c, 11408), c)

def gc.n2048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2048(U32.is_lt(c, 11413), c)
    case False{}:
      gc.n2049(U32.is_lt(c, 11415), c)

def gc.n2051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2051(U32.is_lt(c, 11417), c)
    case False{}:
      gc.n2052(U32.is_lt(c, 11419), c)

def gc.n2054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2050(U32.is_lt(c, 11414), c)
    case False{}:
      gc.n2053(U32.is_lt(c, 11418), c)

def gc.n2055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2055(U32.is_lt(c, 11421), c)
    case False{}:
      gc.n2056(U32.is_lt(c, 11423), c)

def gc.n2058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n2059(U32.is_lt(c, 11428), c)

def gc.n2061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2058(U32.is_lt(c, 11425), c)
    case False{}:
      gc.n2060(U32.is_lt(c, 11427), c)

def gc.n2062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2057(U32.is_lt(c, 11422), c)
    case False{}:
      gc.n2061(U32.is_lt(c, 11426), c)

def gc.n2063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2054(U32.is_lt(c, 11416), c)
    case False{}:
      gc.n2062(U32.is_lt(c, 11424), c)

def gc.n2064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2047(U32.is_lt(c, 11404), c)
    case False{}:
      gc.n2063(U32.is_lt(c, 11420), c)

def gc.n2065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2032(U32.is_lt(c, 11368), c)
    case False{}:
      gc.n2064(U32.is_lt(c, 11412), c)

def gc.n2066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2001(U32.is_lt(c, 10223), c)
    case False{}:
      gc.n2065(U32.is_lt(c, 11396), c)

def gc.n2067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1937(U32.is_lt(c, 8510), c)
    case False{}:
      gc.n2066(U32.is_lt(c, 10749), c)

def gc.n2068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1809(U32.is_lt(c, 7893), c)
    case False{}:
      gc.n2067(U32.is_lt(c, 9728), c)

def gc.n2069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1551(U32.is_lt(c, 6086), c)
    case False{}:
      gc.n2068(U32.is_lt(c, 8262), c)

def gc.n2070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n1034(U32.is_lt(c, 1219), c)
    case False{}:
      gc.n2069(U32.is_lt(c, 7756), c)

def gc.n2071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2071(U32.is_lt(c, 11430), c)
    case False{}:
      gc.n2072(U32.is_lt(c, 11432), c)

def gc.n2074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2074(U32.is_lt(c, 11434), c)
    case False{}:
      gc.n2075(U32.is_lt(c, 11436), c)

def gc.n2077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2073(U32.is_lt(c, 11431), c)
    case False{}:
      gc.n2076(U32.is_lt(c, 11435), c)

def gc.n2078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2078(U32.is_lt(c, 11438), c)
    case False{}:
      gc.n2079(U32.is_lt(c, 11440), c)

def gc.n2081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2081(U32.is_lt(c, 11442), c)
    case False{}:
      gc.n2082(U32.is_lt(c, 11444), c)

def gc.n2084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2080(U32.is_lt(c, 11439), c)
    case False{}:
      gc.n2083(U32.is_lt(c, 11443), c)

def gc.n2085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2077(U32.is_lt(c, 11433), c)
    case False{}:
      gc.n2084(U32.is_lt(c, 11441), c)

def gc.n2086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2086(U32.is_lt(c, 11446), c)
    case False{}:
      gc.n2087(U32.is_lt(c, 11448), c)

def gc.n2089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2089(U32.is_lt(c, 11450), c)
    case False{}:
      gc.n2090(U32.is_lt(c, 11452), c)

def gc.n2092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2088(U32.is_lt(c, 11447), c)
    case False{}:
      gc.n2091(U32.is_lt(c, 11451), c)

def gc.n2093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2093(U32.is_lt(c, 11454), c)
    case False{}:
      gc.n2094(U32.is_lt(c, 11456), c)

def gc.n2096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2096(U32.is_lt(c, 11458), c)
    case False{}:
      gc.n2097(U32.is_lt(c, 11460), c)

def gc.n2099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2095(U32.is_lt(c, 11455), c)
    case False{}:
      gc.n2098(U32.is_lt(c, 11459), c)

def gc.n2100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2092(U32.is_lt(c, 11449), c)
    case False{}:
      gc.n2099(U32.is_lt(c, 11457), c)

def gc.n2101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2085(U32.is_lt(c, 11437), c)
    case False{}:
      gc.n2100(U32.is_lt(c, 11453), c)

def gc.n2102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2102(U32.is_lt(c, 11462), c)
    case False{}:
      gc.n2103(U32.is_lt(c, 11464), c)

def gc.n2105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2105(U32.is_lt(c, 11466), c)
    case False{}:
      gc.n2106(U32.is_lt(c, 11468), c)

def gc.n2108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2104(U32.is_lt(c, 11463), c)
    case False{}:
      gc.n2107(U32.is_lt(c, 11467), c)

def gc.n2109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2109(U32.is_lt(c, 11470), c)
    case False{}:
      gc.n2110(U32.is_lt(c, 11472), c)

def gc.n2112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2112(U32.is_lt(c, 11474), c)
    case False{}:
      gc.n2113(U32.is_lt(c, 11476), c)

def gc.n2115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2111(U32.is_lt(c, 11471), c)
    case False{}:
      gc.n2114(U32.is_lt(c, 11475), c)

def gc.n2116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2108(U32.is_lt(c, 11465), c)
    case False{}:
      gc.n2115(U32.is_lt(c, 11473), c)

def gc.n2117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2117(U32.is_lt(c, 11478), c)
    case False{}:
      gc.n2118(U32.is_lt(c, 11480), c)

def gc.n2120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2120(U32.is_lt(c, 11482), c)
    case False{}:
      gc.n2121(U32.is_lt(c, 11484), c)

def gc.n2123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2119(U32.is_lt(c, 11479), c)
    case False{}:
      gc.n2122(U32.is_lt(c, 11483), c)

def gc.n2124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2124(U32.is_lt(c, 11486), c)
    case False{}:
      gc.n2125(U32.is_lt(c, 11488), c)

def gc.n2127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "So"

def gc.n2129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2127(U32.is_lt(c, 11490), c)
    case False{}:
      gc.n2128(U32.is_lt(c, 11493), c)

def gc.n2130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2126(U32.is_lt(c, 11487), c)
    case False{}:
      gc.n2129(U32.is_lt(c, 11491), c)

def gc.n2131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2123(U32.is_lt(c, 11481), c)
    case False{}:
      gc.n2130(U32.is_lt(c, 11489), c)

def gc.n2132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2116(U32.is_lt(c, 11469), c)
    case False{}:
      gc.n2131(U32.is_lt(c, 11485), c)

def gc.n2133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2101(U32.is_lt(c, 11445), c)
    case False{}:
      gc.n2132(U32.is_lt(c, 11477), c)

def gc.n2134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2134(U32.is_lt(c, 11500), c)
    case False{}:
      gc.n2135(U32.is_lt(c, 11502), c)

def gc.n2137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lu"

def gc.n2138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2137(U32.is_lt(c, 11506), c)
    case False{}:
      gc.n2138(U32.is_lt(c, 11508), c)

def gc.n2140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2136(U32.is_lt(c, 11501), c)
    case False{}:
      gc.n2139(U32.is_lt(c, 11507), c)

def gc.n2141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "No"

def gc.n2142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ll"

def gc.n2143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2141(U32.is_lt(c, 11517), c)
    case False{}:
      gc.n2142(U32.is_lt(c, 11520), c)

def gc.n2144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n2145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n2146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2144(U32.is_lt(c, 11559), c)
    case False{}:
      gc.n2145(U32.is_lt(c, 11565), c)

def gc.n2147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2143(U32.is_lt(c, 11518), c)
    case False{}:
      gc.n2146(U32.is_lt(c, 11560), c)

def gc.n2148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2140(U32.is_lt(c, 11503), c)
    case False{}:
      gc.n2147(U32.is_lt(c, 11558), c)

def gc.n2149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n2151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2149(U32.is_lt(c, 11568), c)
    case False{}:
      gc.n2150(U32.is_lt(c, 11631), c)

def gc.n2152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n2153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2152(U32.is_lt(c, 11633), c)
    case False{}:
      gc.n2153(U32.is_lt(c, 11648), c)

def gc.n2155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2151(U32.is_lt(c, 11624), c)
    case False{}:
      gc.n2154(U32.is_lt(c, 11647), c)

def gc.n2156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2156(U32.is_lt(c, 11680), c)
    case False{}:
      gc.n2157(U32.is_lt(c, 11688), c)

def gc.n2159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2159(U32.is_lt(c, 11696), c)
    case False{}:
      gc.n2160(U32.is_lt(c, 11704), c)

def gc.n2162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2158(U32.is_lt(c, 11687), c)
    case False{}:
      gc.n2161(U32.is_lt(c, 11703), c)

def gc.n2163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2155(U32.is_lt(c, 11632), c)
    case False{}:
      gc.n2162(U32.is_lt(c, 11695), c)

def gc.n2164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2148(U32.is_lt(c, 11513), c)
    case False{}:
      gc.n2163(U32.is_lt(c, 11671), c)

def gc.n2165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2165(U32.is_lt(c, 11712), c)
    case False{}:
      gc.n2166(U32.is_lt(c, 11720), c)

def gc.n2168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2168(U32.is_lt(c, 11728), c)
    case False{}:
      gc.n2169(U32.is_lt(c, 11736), c)

def gc.n2171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2167(U32.is_lt(c, 11719), c)
    case False{}:
      gc.n2170(U32.is_lt(c, 11735), c)

def gc.n2172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n2173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pi"

def gc.n2174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2172(U32.is_lt(c, 11744), c)
    case False{}:
      gc.n2173(U32.is_lt(c, 11778), c)

def gc.n2175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pf"
    case False{}:
      "Pi"

def gc.n2176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pf"
    case False{}:
      "Po"

def gc.n2177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2175(U32.is_lt(c, 11780), c)
    case False{}:
      gc.n2176(U32.is_lt(c, 11782), c)

def gc.n2178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2174(U32.is_lt(c, 11776), c)
    case False{}:
      gc.n2177(U32.is_lt(c, 11781), c)

def gc.n2179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2171(U32.is_lt(c, 11727), c)
    case False{}:
      gc.n2178(U32.is_lt(c, 11779), c)

def gc.n2180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pi"
    case False{}:
      "Pf"

def gc.n2181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pi"

def gc.n2182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2180(U32.is_lt(c, 11786), c)
    case False{}:
      gc.n2181(U32.is_lt(c, 11788), c)

def gc.n2183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pf"
    case False{}:
      "Po"

def gc.n2184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Po"

def gc.n2185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2183(U32.is_lt(c, 11790), c)
    case False{}:
      gc.n2184(U32.is_lt(c, 11800), c)

def gc.n2186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2182(U32.is_lt(c, 11787), c)
    case False{}:
      gc.n2185(U32.is_lt(c, 11799), c)

def gc.n2187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Po"

def gc.n2188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pi"
    case False{}:
      "Pf"

def gc.n2189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2187(U32.is_lt(c, 11803), c)
    case False{}:
      gc.n2188(U32.is_lt(c, 11805), c)

def gc.n2190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pi"

def gc.n2191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pf"
    case False{}:
      gc.n2191(U32.is_lt(c, 11811), c)

def gc.n2193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2190(U32.is_lt(c, 11808), c)
    case False{}:
      gc.n2192(U32.is_lt(c, 11810), c)

def gc.n2194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2189(U32.is_lt(c, 11804), c)
    case False{}:
      gc.n2193(U32.is_lt(c, 11809), c)

def gc.n2195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2186(U32.is_lt(c, 11789), c)
    case False{}:
      gc.n2194(U32.is_lt(c, 11806), c)

def gc.n2196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2179(U32.is_lt(c, 11743), c)
    case False{}:
      gc.n2195(U32.is_lt(c, 11802), c)

def gc.n2197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2164(U32.is_lt(c, 11566), c)
    case False{}:
      gc.n2196(U32.is_lt(c, 11785), c)

def gc.n2198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2133(U32.is_lt(c, 11461), c)
    case False{}:
      gc.n2197(U32.is_lt(c, 11711), c)

def gc.n2199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2199(U32.is_lt(c, 11813), c)
    case False{}:
      gc.n2200(U32.is_lt(c, 11815), c)

def gc.n2202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lm"

def gc.n2204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2202(U32.is_lt(c, 11817), c)
    case False{}:
      gc.n2203(U32.is_lt(c, 11823), c)

def gc.n2205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2201(U32.is_lt(c, 11814), c)
    case False{}:
      gc.n2204(U32.is_lt(c, 11818), c)

def gc.n2206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n2207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n2208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2206(U32.is_lt(c, 11834), c)
    case False{}:
      gc.n2207(U32.is_lt(c, 11840), c)

def gc.n2209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ps"

def gc.n2210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n2211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2209(U32.is_lt(c, 11842), c)
    case False{}:
      gc.n2210(U32.is_lt(c, 11856), c)

def gc.n2212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2208(U32.is_lt(c, 11836), c)
    case False{}:
      gc.n2211(U32.is_lt(c, 11843), c)

def gc.n2213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2205(U32.is_lt(c, 11816), c)
    case False{}:
      gc.n2212(U32.is_lt(c, 11841), c)

def gc.n2214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ps"

def gc.n2215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2214(U32.is_lt(c, 11861), c)
    case False{}:
      gc.n2215(U32.is_lt(c, 11863), c)

def gc.n2217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2217(U32.is_lt(c, 11865), c)
    case False{}:
      gc.n2218(U32.is_lt(c, 11867), c)

def gc.n2220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2216(U32.is_lt(c, 11862), c)
    case False{}:
      gc.n2219(U32.is_lt(c, 11866), c)

def gc.n2221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Pd"

def gc.n2222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n2223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2221(U32.is_lt(c, 11869), c)
    case False{}:
      gc.n2222(U32.is_lt(c, 11904), c)

def gc.n2224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n2225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n2226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2224(U32.is_lt(c, 11931), c)
    case False{}:
      gc.n2225(U32.is_lt(c, 12032), c)

def gc.n2227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2223(U32.is_lt(c, 11870), c)
    case False{}:
      gc.n2226(U32.is_lt(c, 12020), c)

def gc.n2228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2220(U32.is_lt(c, 11864), c)
    case False{}:
      gc.n2227(U32.is_lt(c, 11930), c)

def gc.n2229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2213(U32.is_lt(c, 11824), c)
    case False{}:
      gc.n2228(U32.is_lt(c, 11868), c)

def gc.n2230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n2231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Zs"
    case False{}:
      "Po"

def gc.n2232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2230(U32.is_lt(c, 12272), c)
    case False{}:
      gc.n2231(U32.is_lt(c, 12289), c)

def gc.n2233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lm"

def gc.n2234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Nl"

def gc.n2235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2233(U32.is_lt(c, 12293), c)
    case False{}:
      gc.n2234(U32.is_lt(c, 12295), c)

def gc.n2236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2232(U32.is_lt(c, 12288), c)
    case False{}:
      gc.n2235(U32.is_lt(c, 12294), c)

def gc.n2237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2237(U32.is_lt(c, 12297), c)
    case False{}:
      gc.n2238(U32.is_lt(c, 12299), c)

def gc.n2240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2240(U32.is_lt(c, 12301), c)
    case False{}:
      gc.n2241(U32.is_lt(c, 12303), c)

def gc.n2243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2239(U32.is_lt(c, 12298), c)
    case False{}:
      gc.n2242(U32.is_lt(c, 12302), c)

def gc.n2244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2236(U32.is_lt(c, 12292), c)
    case False{}:
      gc.n2243(U32.is_lt(c, 12300), c)

def gc.n2245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Ps"

def gc.n2247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2245(U32.is_lt(c, 12305), c)
    case False{}:
      gc.n2246(U32.is_lt(c, 12308), c)

def gc.n2248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2248(U32.is_lt(c, 12310), c)
    case False{}:
      gc.n2249(U32.is_lt(c, 12312), c)

def gc.n2251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2247(U32.is_lt(c, 12306), c)
    case False{}:
      gc.n2250(U32.is_lt(c, 12311), c)

def gc.n2252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Pd"

def gc.n2254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2252(U32.is_lt(c, 12314), c)
    case False{}:
      gc.n2253(U32.is_lt(c, 12316), c)

def gc.n2255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Mn"

def gc.n2257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      gc.n2256(U32.is_lt(c, 12330), c)

def gc.n2258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2255(U32.is_lt(c, 12318), c)
    case False{}:
      gc.n2257(U32.is_lt(c, 12321), c)

def gc.n2259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2254(U32.is_lt(c, 12315), c)
    case False{}:
      gc.n2258(U32.is_lt(c, 12320), c)

def gc.n2260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2251(U32.is_lt(c, 12309), c)
    case False{}:
      gc.n2259(U32.is_lt(c, 12317), c)

def gc.n2261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2244(U32.is_lt(c, 12296), c)
    case False{}:
      gc.n2260(U32.is_lt(c, 12313), c)

def gc.n2262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2229(U32.is_lt(c, 11858), c)
    case False{}:
      gc.n2261(U32.is_lt(c, 12304), c)

def gc.n2263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Pd"

def gc.n2264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "So"

def gc.n2265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2263(U32.is_lt(c, 12336), c)
    case False{}:
      gc.n2264(U32.is_lt(c, 12342), c)

def gc.n2266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Lm"

def gc.n2267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n2268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2266(U32.is_lt(c, 12347), c)
    case False{}:
      gc.n2267(U32.is_lt(c, 12349), c)

def gc.n2269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2265(U32.is_lt(c, 12337), c)
    case False{}:
      gc.n2268(U32.is_lt(c, 12348), c)

def gc.n2270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2270(U32.is_lt(c, 12352), c)
    case False{}:
      gc.n2271(U32.is_lt(c, 12439), c)

def gc.n2273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Sk"

def gc.n2274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n2275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2273(U32.is_lt(c, 12443), c)
    case False{}:
      gc.n2274(U32.is_lt(c, 12447), c)

def gc.n2276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2272(U32.is_lt(c, 12353), c)
    case False{}:
      gc.n2275(U32.is_lt(c, 12445), c)

def gc.n2277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2269(U32.is_lt(c, 12344), c)
    case False{}:
      gc.n2276(U32.is_lt(c, 12441), c)

def gc.n2278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Lo"

def gc.n2279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lm"

def gc.n2280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2278(U32.is_lt(c, 12449), c)
    case False{}:
      gc.n2279(U32.is_lt(c, 12540), c)

def gc.n2281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2281(U32.is_lt(c, 12544), c)
    case False{}:
      gc.n2282(U32.is_lt(c, 12592), c)

def gc.n2284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2280(U32.is_lt(c, 12539), c)
    case False{}:
      gc.n2283(U32.is_lt(c, 12549), c)

def gc.n2285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "No"

def gc.n2287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2285(U32.is_lt(c, 12687), c)
    case False{}:
      gc.n2286(U32.is_lt(c, 12690), c)

def gc.n2288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n2289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2288(U32.is_lt(c, 12704), c)
    case False{}:
      gc.n2289(U32.is_lt(c, 12774), c)

def gc.n2291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2287(U32.is_lt(c, 12688), c)
    case False{}:
      gc.n2290(U32.is_lt(c, 12736), c)

def gc.n2292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2284(U32.is_lt(c, 12543), c)
    case False{}:
      gc.n2291(U32.is_lt(c, 12694), c)

def gc.n2293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2277(U32.is_lt(c, 12350), c)
    case False{}:
      gc.n2292(U32.is_lt(c, 12593), c)

def gc.n2294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n2295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2294(U32.is_lt(c, 12784), c)
    case False{}:
      gc.n2295(U32.is_lt(c, 12831), c)

def gc.n2297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n2298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n2299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2297(U32.is_lt(c, 12842), c)
    case False{}:
      gc.n2298(U32.is_lt(c, 12880), c)

def gc.n2300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2296(U32.is_lt(c, 12800), c)
    case False{}:
      gc.n2299(U32.is_lt(c, 12872), c)

def gc.n2301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n2302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n2303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2301(U32.is_lt(c, 12896), c)
    case False{}:
      gc.n2302(U32.is_lt(c, 12938), c)

def gc.n2304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n2305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n2306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2304(U32.is_lt(c, 12992), c)
    case False{}:
      gc.n2305(U32.is_lt(c, 19904), c)

def gc.n2307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2303(U32.is_lt(c, 12928), c)
    case False{}:
      gc.n2306(U32.is_lt(c, 13312), c)

def gc.n2308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2300(U32.is_lt(c, 12832), c)
    case False{}:
      gc.n2307(U32.is_lt(c, 12977), c)

def gc.n2309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n2310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2309(U32.is_lt(c, 40981), c)
    case False{}:
      gc.n2310(U32.is_lt(c, 42125), c)

def gc.n2312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n2314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2312(U32.is_lt(c, 42183), c)
    case False{}:
      gc.n2313(U32.is_lt(c, 42232), c)

def gc.n2315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2311(U32.is_lt(c, 40982), c)
    case False{}:
      gc.n2314(U32.is_lt(c, 42192), c)

def gc.n2316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n2317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Po"

def gc.n2318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2316(U32.is_lt(c, 42240), c)
    case False{}:
      gc.n2317(U32.is_lt(c, 42509), c)

def gc.n2319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Nd"

def gc.n2320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n2321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n2320(U32.is_lt(c, 42560), c)

def gc.n2322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2319(U32.is_lt(c, 42528), c)
    case False{}:
      gc.n2321(U32.is_lt(c, 42540), c)

def gc.n2323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2318(U32.is_lt(c, 42508), c)
    case False{}:
      gc.n2322(U32.is_lt(c, 42538), c)

def gc.n2324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2315(U32.is_lt(c, 42128), c)
    case False{}:
      gc.n2323(U32.is_lt(c, 42512), c)

def gc.n2325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2308(U32.is_lt(c, 12881), c)
    case False{}:
      gc.n2324(U32.is_lt(c, 42238), c)

def gc.n2326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2293(U32.is_lt(c, 12448), c)
    case False{}:
      gc.n2325(U32.is_lt(c, 19968), c)

def gc.n2327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2262(U32.is_lt(c, 12246), c)
    case False{}:
      gc.n2326(U32.is_lt(c, 12783), c)

def gc.n2328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2198(U32.is_lt(c, 11499), c)
    case False{}:
      gc.n2327(U32.is_lt(c, 12334), c)

def gc.n2329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2329(U32.is_lt(c, 42562), c)
    case False{}:
      gc.n2330(U32.is_lt(c, 42564), c)

def gc.n2332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2332(U32.is_lt(c, 42566), c)
    case False{}:
      gc.n2333(U32.is_lt(c, 42568), c)

def gc.n2335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2331(U32.is_lt(c, 42563), c)
    case False{}:
      gc.n2334(U32.is_lt(c, 42567), c)

def gc.n2336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2336(U32.is_lt(c, 42570), c)
    case False{}:
      gc.n2337(U32.is_lt(c, 42572), c)

def gc.n2339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2339(U32.is_lt(c, 42574), c)
    case False{}:
      gc.n2340(U32.is_lt(c, 42576), c)

def gc.n2342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2338(U32.is_lt(c, 42571), c)
    case False{}:
      gc.n2341(U32.is_lt(c, 42575), c)

def gc.n2343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2335(U32.is_lt(c, 42565), c)
    case False{}:
      gc.n2342(U32.is_lt(c, 42573), c)

def gc.n2344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2344(U32.is_lt(c, 42578), c)
    case False{}:
      gc.n2345(U32.is_lt(c, 42580), c)

def gc.n2347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2347(U32.is_lt(c, 42582), c)
    case False{}:
      gc.n2348(U32.is_lt(c, 42584), c)

def gc.n2350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2346(U32.is_lt(c, 42579), c)
    case False{}:
      gc.n2349(U32.is_lt(c, 42583), c)

def gc.n2351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2351(U32.is_lt(c, 42586), c)
    case False{}:
      gc.n2352(U32.is_lt(c, 42588), c)

def gc.n2354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2354(U32.is_lt(c, 42590), c)
    case False{}:
      gc.n2355(U32.is_lt(c, 42592), c)

def gc.n2357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2353(U32.is_lt(c, 42587), c)
    case False{}:
      gc.n2356(U32.is_lt(c, 42591), c)

def gc.n2358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2350(U32.is_lt(c, 42581), c)
    case False{}:
      gc.n2357(U32.is_lt(c, 42589), c)

def gc.n2359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2343(U32.is_lt(c, 42569), c)
    case False{}:
      gc.n2358(U32.is_lt(c, 42585), c)

def gc.n2360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2360(U32.is_lt(c, 42594), c)
    case False{}:
      gc.n2361(U32.is_lt(c, 42596), c)

def gc.n2363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2363(U32.is_lt(c, 42598), c)
    case False{}:
      gc.n2364(U32.is_lt(c, 42600), c)

def gc.n2366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2362(U32.is_lt(c, 42595), c)
    case False{}:
      gc.n2365(U32.is_lt(c, 42599), c)

def gc.n2367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2367(U32.is_lt(c, 42602), c)
    case False{}:
      gc.n2368(U32.is_lt(c, 42604), c)

def gc.n2370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n2371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Me"

def gc.n2372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2370(U32.is_lt(c, 42606), c)
    case False{}:
      gc.n2371(U32.is_lt(c, 42608), c)

def gc.n2373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2369(U32.is_lt(c, 42603), c)
    case False{}:
      gc.n2372(U32.is_lt(c, 42607), c)

def gc.n2374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2366(U32.is_lt(c, 42597), c)
    case False{}:
      gc.n2373(U32.is_lt(c, 42605), c)

def gc.n2375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n2376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lm"

def gc.n2377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2375(U32.is_lt(c, 42612), c)
    case False{}:
      gc.n2376(U32.is_lt(c, 42623), c)

def gc.n2378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2378(U32.is_lt(c, 42625), c)
    case False{}:
      gc.n2379(U32.is_lt(c, 42627), c)

def gc.n2381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2377(U32.is_lt(c, 42622), c)
    case False{}:
      gc.n2380(U32.is_lt(c, 42626), c)

def gc.n2382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2382(U32.is_lt(c, 42629), c)
    case False{}:
      gc.n2383(U32.is_lt(c, 42631), c)

def gc.n2385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2385(U32.is_lt(c, 42633), c)
    case False{}:
      gc.n2386(U32.is_lt(c, 42635), c)

def gc.n2388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2384(U32.is_lt(c, 42630), c)
    case False{}:
      gc.n2387(U32.is_lt(c, 42634), c)

def gc.n2389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2381(U32.is_lt(c, 42624), c)
    case False{}:
      gc.n2388(U32.is_lt(c, 42632), c)

def gc.n2390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2374(U32.is_lt(c, 42601), c)
    case False{}:
      gc.n2389(U32.is_lt(c, 42628), c)

def gc.n2391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2359(U32.is_lt(c, 42577), c)
    case False{}:
      gc.n2390(U32.is_lt(c, 42611), c)

def gc.n2392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2392(U32.is_lt(c, 42637), c)
    case False{}:
      gc.n2393(U32.is_lt(c, 42639), c)

def gc.n2395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2395(U32.is_lt(c, 42641), c)
    case False{}:
      gc.n2396(U32.is_lt(c, 42643), c)

def gc.n2398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2394(U32.is_lt(c, 42638), c)
    case False{}:
      gc.n2397(U32.is_lt(c, 42642), c)

def gc.n2399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2399(U32.is_lt(c, 42645), c)
    case False{}:
      gc.n2400(U32.is_lt(c, 42647), c)

def gc.n2402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2402(U32.is_lt(c, 42649), c)
    case False{}:
      gc.n2403(U32.is_lt(c, 42651), c)

def gc.n2405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2401(U32.is_lt(c, 42646), c)
    case False{}:
      gc.n2404(U32.is_lt(c, 42650), c)

def gc.n2406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2398(U32.is_lt(c, 42640), c)
    case False{}:
      gc.n2405(U32.is_lt(c, 42648), c)

def gc.n2407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Mn"

def gc.n2408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Nl"

def gc.n2409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2407(U32.is_lt(c, 42654), c)
    case False{}:
      gc.n2408(U32.is_lt(c, 42726), c)

def gc.n2410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n2411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sk"

def gc.n2412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2410(U32.is_lt(c, 42738), c)
    case False{}:
      gc.n2411(U32.is_lt(c, 42752), c)

def gc.n2413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2409(U32.is_lt(c, 42656), c)
    case False{}:
      gc.n2412(U32.is_lt(c, 42744), c)

def gc.n2414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Sk"

def gc.n2415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2414(U32.is_lt(c, 42784), c)
    case False{}:
      gc.n2415(U32.is_lt(c, 42787), c)

def gc.n2417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2417(U32.is_lt(c, 42789), c)
    case False{}:
      gc.n2418(U32.is_lt(c, 42791), c)

def gc.n2420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2416(U32.is_lt(c, 42786), c)
    case False{}:
      gc.n2419(U32.is_lt(c, 42790), c)

def gc.n2421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2413(U32.is_lt(c, 42736), c)
    case False{}:
      gc.n2420(U32.is_lt(c, 42788), c)

def gc.n2422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2406(U32.is_lt(c, 42644), c)
    case False{}:
      gc.n2421(U32.is_lt(c, 42775), c)

def gc.n2423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2423(U32.is_lt(c, 42793), c)
    case False{}:
      gc.n2424(U32.is_lt(c, 42795), c)

def gc.n2426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2426(U32.is_lt(c, 42797), c)
    case False{}:
      gc.n2427(U32.is_lt(c, 42799), c)

def gc.n2429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2425(U32.is_lt(c, 42794), c)
    case False{}:
      gc.n2428(U32.is_lt(c, 42798), c)

def gc.n2430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2430(U32.is_lt(c, 42803), c)
    case False{}:
      gc.n2431(U32.is_lt(c, 42805), c)

def gc.n2433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2433(U32.is_lt(c, 42807), c)
    case False{}:
      gc.n2434(U32.is_lt(c, 42809), c)

def gc.n2436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2432(U32.is_lt(c, 42804), c)
    case False{}:
      gc.n2435(U32.is_lt(c, 42808), c)

def gc.n2437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2429(U32.is_lt(c, 42796), c)
    case False{}:
      gc.n2436(U32.is_lt(c, 42806), c)

def gc.n2438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2438(U32.is_lt(c, 42811), c)
    case False{}:
      gc.n2439(U32.is_lt(c, 42813), c)

def gc.n2441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2441(U32.is_lt(c, 42815), c)
    case False{}:
      gc.n2442(U32.is_lt(c, 42817), c)

def gc.n2444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2440(U32.is_lt(c, 42812), c)
    case False{}:
      gc.n2443(U32.is_lt(c, 42816), c)

def gc.n2445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2445(U32.is_lt(c, 42819), c)
    case False{}:
      gc.n2446(U32.is_lt(c, 42821), c)

def gc.n2448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n2449(U32.is_lt(c, 42826), c)

def gc.n2451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2448(U32.is_lt(c, 42823), c)
    case False{}:
      gc.n2450(U32.is_lt(c, 42825), c)

def gc.n2452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2447(U32.is_lt(c, 42820), c)
    case False{}:
      gc.n2451(U32.is_lt(c, 42824), c)

def gc.n2453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2444(U32.is_lt(c, 42814), c)
    case False{}:
      gc.n2452(U32.is_lt(c, 42822), c)

def gc.n2454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2437(U32.is_lt(c, 42802), c)
    case False{}:
      gc.n2453(U32.is_lt(c, 42818), c)

def gc.n2455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2422(U32.is_lt(c, 42652), c)
    case False{}:
      gc.n2454(U32.is_lt(c, 42810), c)

def gc.n2456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2391(U32.is_lt(c, 42593), c)
    case False{}:
      gc.n2455(U32.is_lt(c, 42792), c)

def gc.n2457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2457(U32.is_lt(c, 42828), c)
    case False{}:
      gc.n2458(U32.is_lt(c, 42830), c)

def gc.n2460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2460(U32.is_lt(c, 42832), c)
    case False{}:
      gc.n2461(U32.is_lt(c, 42834), c)

def gc.n2463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2459(U32.is_lt(c, 42829), c)
    case False{}:
      gc.n2462(U32.is_lt(c, 42833), c)

def gc.n2464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2464(U32.is_lt(c, 42836), c)
    case False{}:
      gc.n2465(U32.is_lt(c, 42838), c)

def gc.n2467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2467(U32.is_lt(c, 42840), c)
    case False{}:
      gc.n2468(U32.is_lt(c, 42842), c)

def gc.n2470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2466(U32.is_lt(c, 42837), c)
    case False{}:
      gc.n2469(U32.is_lt(c, 42841), c)

def gc.n2471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2463(U32.is_lt(c, 42831), c)
    case False{}:
      gc.n2470(U32.is_lt(c, 42839), c)

def gc.n2472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2472(U32.is_lt(c, 42844), c)
    case False{}:
      gc.n2473(U32.is_lt(c, 42846), c)

def gc.n2475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2475(U32.is_lt(c, 42848), c)
    case False{}:
      gc.n2476(U32.is_lt(c, 42850), c)

def gc.n2478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2474(U32.is_lt(c, 42845), c)
    case False{}:
      gc.n2477(U32.is_lt(c, 42849), c)

def gc.n2479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2479(U32.is_lt(c, 42852), c)
    case False{}:
      gc.n2480(U32.is_lt(c, 42854), c)

def gc.n2482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2482(U32.is_lt(c, 42856), c)
    case False{}:
      gc.n2483(U32.is_lt(c, 42858), c)

def gc.n2485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2481(U32.is_lt(c, 42853), c)
    case False{}:
      gc.n2484(U32.is_lt(c, 42857), c)

def gc.n2486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2478(U32.is_lt(c, 42847), c)
    case False{}:
      gc.n2485(U32.is_lt(c, 42855), c)

def gc.n2487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2471(U32.is_lt(c, 42835), c)
    case False{}:
      gc.n2486(U32.is_lt(c, 42851), c)

def gc.n2488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2488(U32.is_lt(c, 42860), c)
    case False{}:
      gc.n2489(U32.is_lt(c, 42862), c)

def gc.n2491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lm"

def gc.n2492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2491(U32.is_lt(c, 42864), c)
    case False{}:
      gc.n2492(U32.is_lt(c, 42873), c)

def gc.n2494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2490(U32.is_lt(c, 42861), c)
    case False{}:
      gc.n2493(U32.is_lt(c, 42865), c)

def gc.n2495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2495(U32.is_lt(c, 42875), c)
    case False{}:
      gc.n2496(U32.is_lt(c, 42877), c)

def gc.n2498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2498(U32.is_lt(c, 42880), c)
    case False{}:
      gc.n2499(U32.is_lt(c, 42882), c)

def gc.n2501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2497(U32.is_lt(c, 42876), c)
    case False{}:
      gc.n2500(U32.is_lt(c, 42881), c)

def gc.n2502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2494(U32.is_lt(c, 42863), c)
    case False{}:
      gc.n2501(U32.is_lt(c, 42879), c)

def gc.n2503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2503(U32.is_lt(c, 42884), c)
    case False{}:
      gc.n2504(U32.is_lt(c, 42886), c)

def gc.n2506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lm"

def gc.n2507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lu"

def gc.n2508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2506(U32.is_lt(c, 42888), c)
    case False{}:
      gc.n2507(U32.is_lt(c, 42891), c)

def gc.n2509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2505(U32.is_lt(c, 42885), c)
    case False{}:
      gc.n2508(U32.is_lt(c, 42889), c)

def gc.n2510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n2512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2510(U32.is_lt(c, 42893), c)
    case False{}:
      gc.n2511(U32.is_lt(c, 42895), c)

def gc.n2513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n2514(U32.is_lt(c, 42902), c)

def gc.n2516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2513(U32.is_lt(c, 42897), c)
    case False{}:
      gc.n2515(U32.is_lt(c, 42899), c)

def gc.n2517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2512(U32.is_lt(c, 42894), c)
    case False{}:
      gc.n2516(U32.is_lt(c, 42898), c)

def gc.n2518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2509(U32.is_lt(c, 42887), c)
    case False{}:
      gc.n2517(U32.is_lt(c, 42896), c)

def gc.n2519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2502(U32.is_lt(c, 42874), c)
    case False{}:
      gc.n2518(U32.is_lt(c, 42892), c)

def gc.n2520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2487(U32.is_lt(c, 42843), c)
    case False{}:
      gc.n2519(U32.is_lt(c, 42883), c)

def gc.n2521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2521(U32.is_lt(c, 42904), c)
    case False{}:
      gc.n2522(U32.is_lt(c, 42906), c)

def gc.n2524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2524(U32.is_lt(c, 42908), c)
    case False{}:
      gc.n2525(U32.is_lt(c, 42910), c)

def gc.n2527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2523(U32.is_lt(c, 42905), c)
    case False{}:
      gc.n2526(U32.is_lt(c, 42909), c)

def gc.n2528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2528(U32.is_lt(c, 42912), c)
    case False{}:
      gc.n2529(U32.is_lt(c, 42914), c)

def gc.n2531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2531(U32.is_lt(c, 42916), c)
    case False{}:
      gc.n2532(U32.is_lt(c, 42918), c)

def gc.n2534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2530(U32.is_lt(c, 42913), c)
    case False{}:
      gc.n2533(U32.is_lt(c, 42917), c)

def gc.n2535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2527(U32.is_lt(c, 42907), c)
    case False{}:
      gc.n2534(U32.is_lt(c, 42915), c)

def gc.n2536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2536(U32.is_lt(c, 42920), c)
    case False{}:
      gc.n2537(U32.is_lt(c, 42922), c)

def gc.n2539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2539(U32.is_lt(c, 42928), c)
    case False{}:
      gc.n2540(U32.is_lt(c, 42934), c)

def gc.n2542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2538(U32.is_lt(c, 42921), c)
    case False{}:
      gc.n2541(U32.is_lt(c, 42933), c)

def gc.n2543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2543(U32.is_lt(c, 42936), c)
    case False{}:
      gc.n2544(U32.is_lt(c, 42938), c)

def gc.n2546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2546(U32.is_lt(c, 42940), c)
    case False{}:
      gc.n2547(U32.is_lt(c, 42942), c)

def gc.n2549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2545(U32.is_lt(c, 42937), c)
    case False{}:
      gc.n2548(U32.is_lt(c, 42941), c)

def gc.n2550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2542(U32.is_lt(c, 42927), c)
    case False{}:
      gc.n2549(U32.is_lt(c, 42939), c)

def gc.n2551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2535(U32.is_lt(c, 42911), c)
    case False{}:
      gc.n2550(U32.is_lt(c, 42935), c)

def gc.n2552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2552(U32.is_lt(c, 42944), c)
    case False{}:
      gc.n2553(U32.is_lt(c, 42946), c)

def gc.n2555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2555(U32.is_lt(c, 42948), c)
    case False{}:
      gc.n2556(U32.is_lt(c, 42953), c)

def gc.n2558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2554(U32.is_lt(c, 42945), c)
    case False{}:
      gc.n2557(U32.is_lt(c, 42952), c)

def gc.n2559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2559(U32.is_lt(c, 42955), c)
    case False{}:
      gc.n2560(U32.is_lt(c, 42958), c)

def gc.n2562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2562(U32.is_lt(c, 42960), c)
    case False{}:
      gc.n2563(U32.is_lt(c, 42962), c)

def gc.n2565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2561(U32.is_lt(c, 42957), c)
    case False{}:
      gc.n2564(U32.is_lt(c, 42961), c)

def gc.n2566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2558(U32.is_lt(c, 42947), c)
    case False{}:
      gc.n2565(U32.is_lt(c, 42959), c)

def gc.n2567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2567(U32.is_lt(c, 42964), c)
    case False{}:
      gc.n2568(U32.is_lt(c, 42966), c)

def gc.n2570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2570(U32.is_lt(c, 42968), c)
    case False{}:
      gc.n2571(U32.is_lt(c, 42970), c)

def gc.n2573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2569(U32.is_lt(c, 42965), c)
    case False{}:
      gc.n2572(U32.is_lt(c, 42969), c)

def gc.n2574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n2575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n2576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2574(U32.is_lt(c, 42972), c)
    case False{}:
      gc.n2575(U32.is_lt(c, 42993), c)

def gc.n2577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Ll"

def gc.n2579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n2578(U32.is_lt(c, 43002), c)

def gc.n2580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2577(U32.is_lt(c, 42998), c)
    case False{}:
      gc.n2579(U32.is_lt(c, 43000), c)

def gc.n2581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2576(U32.is_lt(c, 42973), c)
    case False{}:
      gc.n2580(U32.is_lt(c, 42999), c)

def gc.n2582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2573(U32.is_lt(c, 42967), c)
    case False{}:
      gc.n2581(U32.is_lt(c, 42997), c)

def gc.n2583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2566(U32.is_lt(c, 42954), c)
    case False{}:
      gc.n2582(U32.is_lt(c, 42971), c)

def gc.n2584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2551(U32.is_lt(c, 42919), c)
    case False{}:
      gc.n2583(U32.is_lt(c, 42963), c)

def gc.n2585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2520(U32.is_lt(c, 42859), c)
    case False{}:
      gc.n2584(U32.is_lt(c, 42943), c)

def gc.n2586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2456(U32.is_lt(c, 42636), c)
    case False{}:
      gc.n2585(U32.is_lt(c, 42903), c)

def gc.n2587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2328(U32.is_lt(c, 11812), c)
    case False{}:
      gc.n2586(U32.is_lt(c, 42827), c)

def gc.n2588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2588(U32.is_lt(c, 43010), c)
    case False{}:
      gc.n2589(U32.is_lt(c, 43014), c)

def gc.n2591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n2593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2591(U32.is_lt(c, 43019), c)
    case False{}:
      gc.n2592(U32.is_lt(c, 43043), c)

def gc.n2594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2590(U32.is_lt(c, 43011), c)
    case False{}:
      gc.n2593(U32.is_lt(c, 43020), c)

def gc.n2595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n2597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2595(U32.is_lt(c, 43047), c)
    case False{}:
      gc.n2596(U32.is_lt(c, 43052), c)

def gc.n2598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n2599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sc"

def gc.n2600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2598(U32.is_lt(c, 43056), c)
    case False{}:
      gc.n2599(U32.is_lt(c, 43064), c)

def gc.n2601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2597(U32.is_lt(c, 43048), c)
    case False{}:
      gc.n2600(U32.is_lt(c, 43062), c)

def gc.n2602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2594(U32.is_lt(c, 43015), c)
    case False{}:
      gc.n2601(U32.is_lt(c, 43053), c)

def gc.n2603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n2605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2603(U32.is_lt(c, 43066), c)
    case False{}:
      gc.n2604(U32.is_lt(c, 43124), c)

def gc.n2606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n2607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n2608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2606(U32.is_lt(c, 43136), c)
    case False{}:
      gc.n2607(U32.is_lt(c, 43188), c)

def gc.n2609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2605(U32.is_lt(c, 43072), c)
    case False{}:
      gc.n2608(U32.is_lt(c, 43138), c)

def gc.n2610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n2611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n2612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2610(U32.is_lt(c, 43206), c)
    case False{}:
      gc.n2611(U32.is_lt(c, 43216), c)

def gc.n2613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n2614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n2615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2613(U32.is_lt(c, 43232), c)
    case False{}:
      gc.n2614(U32.is_lt(c, 43256), c)

def gc.n2616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2612(U32.is_lt(c, 43214), c)
    case False{}:
      gc.n2615(U32.is_lt(c, 43250), c)

def gc.n2617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2609(U32.is_lt(c, 43128), c)
    case False{}:
      gc.n2616(U32.is_lt(c, 43226), c)

def gc.n2618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2602(U32.is_lt(c, 43045), c)
    case False{}:
      gc.n2617(U32.is_lt(c, 43204), c)

def gc.n2619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n2620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2619(U32.is_lt(c, 43260), c)
    case False{}:
      gc.n2620(U32.is_lt(c, 43263), c)

def gc.n2622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n2623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n2624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2622(U32.is_lt(c, 43274), c)
    case False{}:
      gc.n2623(U32.is_lt(c, 43310), c)

def gc.n2625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2621(U32.is_lt(c, 43261), c)
    case False{}:
      gc.n2624(U32.is_lt(c, 43302), c)

def gc.n2626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n2628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2626(U32.is_lt(c, 43335), c)
    case False{}:
      gc.n2627(U32.is_lt(c, 43348), c)

def gc.n2629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n2630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n2631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2629(U32.is_lt(c, 43360), c)
    case False{}:
      gc.n2630(U32.is_lt(c, 43392), c)

def gc.n2632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2628(U32.is_lt(c, 43346), c)
    case False{}:
      gc.n2631(U32.is_lt(c, 43389), c)

def gc.n2633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2625(U32.is_lt(c, 43264), c)
    case False{}:
      gc.n2632(U32.is_lt(c, 43359), c)

def gc.n2634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n2635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2634(U32.is_lt(c, 43396), c)
    case False{}:
      gc.n2635(U32.is_lt(c, 43444), c)

def gc.n2637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2637(U32.is_lt(c, 43450), c)
    case False{}:
      gc.n2638(U32.is_lt(c, 43454), c)

def gc.n2640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2636(U32.is_lt(c, 43443), c)
    case False{}:
      gc.n2639(U32.is_lt(c, 43452), c)

def gc.n2641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n2642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Nd"

def gc.n2643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2641(U32.is_lt(c, 43470), c)
    case False{}:
      gc.n2642(U32.is_lt(c, 43472), c)

def gc.n2644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n2645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2644(U32.is_lt(c, 43486), c)
    case False{}:
      gc.n2645(U32.is_lt(c, 43493), c)

def gc.n2647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2643(U32.is_lt(c, 43471), c)
    case False{}:
      gc.n2646(U32.is_lt(c, 43488), c)

def gc.n2648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2640(U32.is_lt(c, 43446), c)
    case False{}:
      gc.n2647(U32.is_lt(c, 43482), c)

def gc.n2649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2633(U32.is_lt(c, 43312), c)
    case False{}:
      gc.n2648(U32.is_lt(c, 43457), c)

def gc.n2650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2618(U32.is_lt(c, 43065), c)
    case False{}:
      gc.n2649(U32.is_lt(c, 43395), c)

def gc.n2651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n2652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Lo"

def gc.n2653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2651(U32.is_lt(c, 43495), c)
    case False{}:
      gc.n2652(U32.is_lt(c, 43514), c)

def gc.n2654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2654(U32.is_lt(c, 43520), c)
    case False{}:
      gc.n2655(U32.is_lt(c, 43567), c)

def gc.n2657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2653(U32.is_lt(c, 43504), c)
    case False{}:
      gc.n2656(U32.is_lt(c, 43561), c)

def gc.n2658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n2660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2658(U32.is_lt(c, 43571), c)
    case False{}:
      gc.n2659(U32.is_lt(c, 43575), c)

def gc.n2661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2661(U32.is_lt(c, 43587), c)
    case False{}:
      gc.n2662(U32.is_lt(c, 43596), c)

def gc.n2664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2660(U32.is_lt(c, 43573), c)
    case False{}:
      gc.n2663(U32.is_lt(c, 43588), c)

def gc.n2665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2657(U32.is_lt(c, 43519), c)
    case False{}:
      gc.n2664(U32.is_lt(c, 43584), c)

def gc.n2666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n2667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n2668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2666(U32.is_lt(c, 43598), c)
    case False{}:
      gc.n2667(U32.is_lt(c, 43610), c)

def gc.n2669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n2670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n2671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2669(U32.is_lt(c, 43616), c)
    case False{}:
      gc.n2670(U32.is_lt(c, 43633), c)

def gc.n2672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2668(U32.is_lt(c, 43600), c)
    case False{}:
      gc.n2671(U32.is_lt(c, 43632), c)

def gc.n2673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n2674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n2675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2673(U32.is_lt(c, 43642), c)
    case False{}:
      gc.n2674(U32.is_lt(c, 43644), c)

def gc.n2676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n2677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2676(U32.is_lt(c, 43646), c)
    case False{}:
      gc.n2677(U32.is_lt(c, 43697), c)

def gc.n2679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2675(U32.is_lt(c, 43643), c)
    case False{}:
      gc.n2678(U32.is_lt(c, 43696), c)

def gc.n2680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2672(U32.is_lt(c, 43612), c)
    case False{}:
      gc.n2679(U32.is_lt(c, 43645), c)

def gc.n2681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2665(U32.is_lt(c, 43569), c)
    case False{}:
      gc.n2680(U32.is_lt(c, 43639), c)

def gc.n2682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2682(U32.is_lt(c, 43701), c)
    case False{}:
      gc.n2683(U32.is_lt(c, 43705), c)

def gc.n2685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2685(U32.is_lt(c, 43712), c)
    case False{}:
      gc.n2686(U32.is_lt(c, 43714), c)

def gc.n2688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2684(U32.is_lt(c, 43703), c)
    case False{}:
      gc.n2687(U32.is_lt(c, 43713), c)

def gc.n2689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Po"

def gc.n2691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2689(U32.is_lt(c, 43739), c)
    case False{}:
      gc.n2690(U32.is_lt(c, 43742), c)

def gc.n2692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n2693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n2694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2692(U32.is_lt(c, 43755), c)
    case False{}:
      gc.n2693(U32.is_lt(c, 43758), c)

def gc.n2695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2691(U32.is_lt(c, 43741), c)
    case False{}:
      gc.n2694(U32.is_lt(c, 43756), c)

def gc.n2696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2688(U32.is_lt(c, 43710), c)
    case False{}:
      gc.n2695(U32.is_lt(c, 43744), c)

def gc.n2697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n2698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Mc"

def gc.n2699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2697(U32.is_lt(c, 43762), c)
    case False{}:
      gc.n2698(U32.is_lt(c, 43765), c)

def gc.n2700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n2701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2700(U32.is_lt(c, 43767), c)
    case False{}:
      gc.n2701(U32.is_lt(c, 43783), c)

def gc.n2703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2699(U32.is_lt(c, 43763), c)
    case False{}:
      gc.n2702(U32.is_lt(c, 43777), c)

def gc.n2704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2704(U32.is_lt(c, 43791), c)
    case False{}:
      gc.n2705(U32.is_lt(c, 43799), c)

def gc.n2707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n2709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n2708(U32.is_lt(c, 43824), c)

def gc.n2710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2707(U32.is_lt(c, 43815), c)
    case False{}:
      gc.n2709(U32.is_lt(c, 43823), c)

def gc.n2711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2706(U32.is_lt(c, 43793), c)
    case False{}:
      gc.n2710(U32.is_lt(c, 43816), c)

def gc.n2712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2703(U32.is_lt(c, 43766), c)
    case False{}:
      gc.n2711(U32.is_lt(c, 43808), c)

def gc.n2713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2696(U32.is_lt(c, 43715), c)
    case False{}:
      gc.n2712(U32.is_lt(c, 43785), c)

def gc.n2714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2681(U32.is_lt(c, 43597), c)
    case False{}:
      gc.n2713(U32.is_lt(c, 43760), c)

def gc.n2715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2650(U32.is_lt(c, 43259), c)
    case False{}:
      gc.n2714(U32.is_lt(c, 43698), c)

def gc.n2716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Lm"

def gc.n2717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lm"

def gc.n2718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2716(U32.is_lt(c, 43868), c)
    case False{}:
      gc.n2717(U32.is_lt(c, 43881), c)

def gc.n2719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Cn"

def gc.n2720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n2721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2719(U32.is_lt(c, 43884), c)
    case False{}:
      gc.n2720(U32.is_lt(c, 43968), c)

def gc.n2722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2718(U32.is_lt(c, 43872), c)
    case False{}:
      gc.n2721(U32.is_lt(c, 43888), c)

def gc.n2723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n2724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n2725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2723(U32.is_lt(c, 44005), c)
    case False{}:
      gc.n2724(U32.is_lt(c, 44008), c)

def gc.n2726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Po"

def gc.n2727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n2728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2726(U32.is_lt(c, 44011), c)
    case False{}:
      gc.n2727(U32.is_lt(c, 44013), c)

def gc.n2729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2725(U32.is_lt(c, 44006), c)
    case False{}:
      gc.n2728(U32.is_lt(c, 44012), c)

def gc.n2730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2722(U32.is_lt(c, 43882), c)
    case False{}:
      gc.n2729(U32.is_lt(c, 44009), c)

def gc.n2731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n2732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2731(U32.is_lt(c, 44016), c)
    case False{}:
      gc.n2732(U32.is_lt(c, 44032), c)

def gc.n2734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2734(U32.is_lt(c, 55216), c)
    case False{}:
      gc.n2735(U32.is_lt(c, 55243), c)

def gc.n2737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2733(U32.is_lt(c, 44026), c)
    case False{}:
      gc.n2736(U32.is_lt(c, 55239), c)

def gc.n2738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Cs"

def gc.n2739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Co"
    case False{}:
      "Lo"

def gc.n2740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2738(U32.is_lt(c, 55296), c)
    case False{}:
      gc.n2739(U32.is_lt(c, 63744), c)

def gc.n2741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n2743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2741(U32.is_lt(c, 64112), c)
    case False{}:
      gc.n2742(U32.is_lt(c, 64256), c)

def gc.n2744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2740(U32.is_lt(c, 57344), c)
    case False{}:
      gc.n2743(U32.is_lt(c, 64218), c)

def gc.n2745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2737(U32.is_lt(c, 55204), c)
    case False{}:
      gc.n2744(U32.is_lt(c, 64110), c)

def gc.n2746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2730(U32.is_lt(c, 44003), c)
    case False{}:
      gc.n2745(U32.is_lt(c, 55292), c)

def gc.n2747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n2748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2747(U32.is_lt(c, 64275), c)
    case False{}:
      gc.n2748(U32.is_lt(c, 64285), c)

def gc.n2750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n2751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Lo"

def gc.n2752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2750(U32.is_lt(c, 64287), c)
    case False{}:
      gc.n2751(U32.is_lt(c, 64298), c)

def gc.n2753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2749(U32.is_lt(c, 64280), c)
    case False{}:
      gc.n2752(U32.is_lt(c, 64297), c)

def gc.n2754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2754(U32.is_lt(c, 64312), c)
    case False{}:
      gc.n2755(U32.is_lt(c, 64318), c)

def gc.n2757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2757(U32.is_lt(c, 64320), c)
    case False{}:
      gc.n2758(U32.is_lt(c, 64323), c)

def gc.n2760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2756(U32.is_lt(c, 64317), c)
    case False{}:
      gc.n2759(U32.is_lt(c, 64322), c)

def gc.n2761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2753(U32.is_lt(c, 64286), c)
    case False{}:
      gc.n2760(U32.is_lt(c, 64319), c)

def gc.n2762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "So"

def gc.n2764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2762(U32.is_lt(c, 64326), c)
    case False{}:
      gc.n2763(U32.is_lt(c, 64451), c)

def gc.n2765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Pe"

def gc.n2766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "So"

def gc.n2767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2765(U32.is_lt(c, 64830), c)
    case False{}:
      gc.n2766(U32.is_lt(c, 64832), c)

def gc.n2768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2764(U32.is_lt(c, 64434), c)
    case False{}:
      gc.n2767(U32.is_lt(c, 64831), c)

def gc.n2769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n2770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n2771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2769(U32.is_lt(c, 64912), c)
    case False{}:
      gc.n2770(U32.is_lt(c, 64968), c)

def gc.n2772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n2774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      gc.n2773(U32.is_lt(c, 65024), c)

def gc.n2775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2772(U32.is_lt(c, 65008), c)
    case False{}:
      gc.n2774(U32.is_lt(c, 65021), c)

def gc.n2776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2771(U32.is_lt(c, 64914), c)
    case False{}:
      gc.n2775(U32.is_lt(c, 65020), c)

def gc.n2777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2768(U32.is_lt(c, 64467), c)
    case False{}:
      gc.n2776(U32.is_lt(c, 64976), c)

def gc.n2778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2761(U32.is_lt(c, 64311), c)
    case False{}:
      gc.n2777(U32.is_lt(c, 64848), c)

def gc.n2779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2746(U32.is_lt(c, 44014), c)
    case False{}:
      gc.n2778(U32.is_lt(c, 64325), c)

def gc.n2780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ps"

def gc.n2781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Po"

def gc.n2782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2780(U32.is_lt(c, 65047), c)
    case False{}:
      gc.n2781(U32.is_lt(c, 65049), c)

def gc.n2783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n2784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n2785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2783(U32.is_lt(c, 65056), c)
    case False{}:
      gc.n2784(U32.is_lt(c, 65073), c)

def gc.n2786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2782(U32.is_lt(c, 65048), c)
    case False{}:
      gc.n2785(U32.is_lt(c, 65072), c)

def gc.n2787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pc"
    case False{}:
      "Ps"

def gc.n2788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2787(U32.is_lt(c, 65077), c)
    case False{}:
      gc.n2788(U32.is_lt(c, 65079), c)

def gc.n2790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2790(U32.is_lt(c, 65081), c)
    case False{}:
      gc.n2791(U32.is_lt(c, 65083), c)

def gc.n2793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2789(U32.is_lt(c, 65078), c)
    case False{}:
      gc.n2792(U32.is_lt(c, 65082), c)

def gc.n2794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2786(U32.is_lt(c, 65050), c)
    case False{}:
      gc.n2793(U32.is_lt(c, 65080), c)

def gc.n2795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2795(U32.is_lt(c, 65085), c)
    case False{}:
      gc.n2796(U32.is_lt(c, 65087), c)

def gc.n2798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Ps"

def gc.n2800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2798(U32.is_lt(c, 65089), c)
    case False{}:
      gc.n2799(U32.is_lt(c, 65091), c)

def gc.n2801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2797(U32.is_lt(c, 65086), c)
    case False{}:
      gc.n2800(U32.is_lt(c, 65090), c)

def gc.n2802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Po"

def gc.n2803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2802(U32.is_lt(c, 65093), c)
    case False{}:
      gc.n2803(U32.is_lt(c, 65096), c)

def gc.n2805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pc"

def gc.n2806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n2807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2805(U32.is_lt(c, 65101), c)
    case False{}:
      gc.n2806(U32.is_lt(c, 65107), c)

def gc.n2808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2804(U32.is_lt(c, 65095), c)
    case False{}:
      gc.n2807(U32.is_lt(c, 65104), c)

def gc.n2809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2801(U32.is_lt(c, 65088), c)
    case False{}:
      gc.n2808(U32.is_lt(c, 65097), c)

def gc.n2810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2794(U32.is_lt(c, 65075), c)
    case False{}:
      gc.n2809(U32.is_lt(c, 65092), c)

def gc.n2811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pd"

def gc.n2812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2811(U32.is_lt(c, 65112), c)
    case False{}:
      gc.n2812(U32.is_lt(c, 65114), c)

def gc.n2814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2814(U32.is_lt(c, 65116), c)
    case False{}:
      gc.n2815(U32.is_lt(c, 65118), c)

def gc.n2817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2813(U32.is_lt(c, 65113), c)
    case False{}:
      gc.n2816(U32.is_lt(c, 65117), c)

def gc.n2818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sm"

def gc.n2819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Sm"

def gc.n2820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2818(U32.is_lt(c, 65122), c)
    case False{}:
      gc.n2819(U32.is_lt(c, 65124), c)

def gc.n2821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n2822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Po"

def gc.n2823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2821(U32.is_lt(c, 65128), c)
    case False{}:
      gc.n2822(U32.is_lt(c, 65130), c)

def gc.n2824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2820(U32.is_lt(c, 65123), c)
    case False{}:
      gc.n2823(U32.is_lt(c, 65129), c)

def gc.n2825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2817(U32.is_lt(c, 65115), c)
    case False{}:
      gc.n2824(U32.is_lt(c, 65127), c)

def gc.n2826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2826(U32.is_lt(c, 65136), c)
    case False{}:
      gc.n2827(U32.is_lt(c, 65142), c)

def gc.n2829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Cf"

def gc.n2830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n2831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2829(U32.is_lt(c, 65279), c)
    case False{}:
      gc.n2830(U32.is_lt(c, 65281), c)

def gc.n2832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2828(U32.is_lt(c, 65141), c)
    case False{}:
      gc.n2831(U32.is_lt(c, 65280), c)

def gc.n2833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Po"

def gc.n2834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2833(U32.is_lt(c, 65285), c)
    case False{}:
      gc.n2834(U32.is_lt(c, 65289), c)

def gc.n2836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Sm"

def gc.n2837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Po"

def gc.n2838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      gc.n2837(U32.is_lt(c, 65294), c)

def gc.n2839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2836(U32.is_lt(c, 65291), c)
    case False{}:
      gc.n2838(U32.is_lt(c, 65293), c)

def gc.n2840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2835(U32.is_lt(c, 65288), c)
    case False{}:
      gc.n2839(U32.is_lt(c, 65292), c)

def gc.n2841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2832(U32.is_lt(c, 65277), c)
    case False{}:
      gc.n2840(U32.is_lt(c, 65290), c)

def gc.n2842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2825(U32.is_lt(c, 65119), c)
    case False{}:
      gc.n2841(U32.is_lt(c, 65284), c)

def gc.n2843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2810(U32.is_lt(c, 65084), c)
    case False{}:
      gc.n2842(U32.is_lt(c, 65132), c)

def gc.n2844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2779(U32.is_lt(c, 64263), c)
    case False{}:
      gc.n2843(U32.is_lt(c, 65108), c)

def gc.n2845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2715(U32.is_lt(c, 43494), c)
    case False{}:
      gc.n2844(U32.is_lt(c, 65040), c)

def gc.n2846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n2847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Po"

def gc.n2848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2846(U32.is_lt(c, 65306), c)
    case False{}:
      gc.n2847(U32.is_lt(c, 65311), c)

def gc.n2849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ps"

def gc.n2850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Pe"

def gc.n2851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2849(U32.is_lt(c, 65339), c)
    case False{}:
      gc.n2850(U32.is_lt(c, 65341), c)

def gc.n2852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2848(U32.is_lt(c, 65308), c)
    case False{}:
      gc.n2851(U32.is_lt(c, 65340), c)

def gc.n2853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Pc"

def gc.n2854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "Ll"

def gc.n2855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2853(U32.is_lt(c, 65343), c)
    case False{}:
      gc.n2854(U32.is_lt(c, 65345), c)

def gc.n2856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Sm"

def gc.n2857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Sm"

def gc.n2858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2856(U32.is_lt(c, 65372), c)
    case False{}:
      gc.n2857(U32.is_lt(c, 65374), c)

def gc.n2859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2855(U32.is_lt(c, 65344), c)
    case False{}:
      gc.n2858(U32.is_lt(c, 65373), c)

def gc.n2860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2852(U32.is_lt(c, 65313), c)
    case False{}:
      gc.n2859(U32.is_lt(c, 65371), c)

def gc.n2861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ps"
    case False{}:
      "Pe"

def gc.n2862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Ps"

def gc.n2863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2861(U32.is_lt(c, 65376), c)
    case False{}:
      gc.n2862(U32.is_lt(c, 65378), c)

def gc.n2864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pe"
    case False{}:
      "Po"

def gc.n2865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n2866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2864(U32.is_lt(c, 65380), c)
    case False{}:
      gc.n2865(U32.is_lt(c, 65392), c)

def gc.n2867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2863(U32.is_lt(c, 65377), c)
    case False{}:
      gc.n2866(U32.is_lt(c, 65382), c)

def gc.n2868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n2869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2868(U32.is_lt(c, 65438), c)
    case False{}:
      gc.n2869(U32.is_lt(c, 65471), c)

def gc.n2871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2871(U32.is_lt(c, 65480), c)
    case False{}:
      gc.n2872(U32.is_lt(c, 65488), c)

def gc.n2874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2870(U32.is_lt(c, 65440), c)
    case False{}:
      gc.n2873(U32.is_lt(c, 65482), c)

def gc.n2875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2867(U32.is_lt(c, 65379), c)
    case False{}:
      gc.n2874(U32.is_lt(c, 65474), c)

def gc.n2876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2860(U32.is_lt(c, 65342), c)
    case False{}:
      gc.n2875(U32.is_lt(c, 65393), c)

def gc.n2877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2877(U32.is_lt(c, 65496), c)
    case False{}:
      gc.n2878(U32.is_lt(c, 65501), c)

def gc.n2880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Sm"

def gc.n2881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sk"
    case False{}:
      "So"

def gc.n2882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2880(U32.is_lt(c, 65506), c)
    case False{}:
      gc.n2881(U32.is_lt(c, 65508), c)

def gc.n2883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2879(U32.is_lt(c, 65498), c)
    case False{}:
      gc.n2882(U32.is_lt(c, 65507), c)

def gc.n2884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Cn"

def gc.n2885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sm"

def gc.n2886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2884(U32.is_lt(c, 65511), c)
    case False{}:
      gc.n2885(U32.is_lt(c, 65513), c)

def gc.n2887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "So"

def gc.n2889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2887(U32.is_lt(c, 65519), c)
    case False{}:
      gc.n2888(U32.is_lt(c, 65532), c)

def gc.n2890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2886(U32.is_lt(c, 65512), c)
    case False{}:
      gc.n2889(U32.is_lt(c, 65529), c)

def gc.n2891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2883(U32.is_lt(c, 65504), c)
    case False{}:
      gc.n2890(U32.is_lt(c, 65517), c)

def gc.n2892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2892(U32.is_lt(c, 65536), c)
    case False{}:
      gc.n2893(U32.is_lt(c, 65549), c)

def gc.n2895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2895(U32.is_lt(c, 65576), c)
    case False{}:
      gc.n2896(U32.is_lt(c, 65596), c)

def gc.n2898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2894(U32.is_lt(c, 65548), c)
    case False{}:
      gc.n2897(U32.is_lt(c, 65595), c)

def gc.n2899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2899(U32.is_lt(c, 65599), c)
    case False{}:
      gc.n2900(U32.is_lt(c, 65616), c)

def gc.n2902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n2904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2902(U32.is_lt(c, 65664), c)
    case False{}:
      gc.n2903(U32.is_lt(c, 65792), c)

def gc.n2905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2901(U32.is_lt(c, 65614), c)
    case False{}:
      gc.n2904(U32.is_lt(c, 65787), c)

def gc.n2906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2898(U32.is_lt(c, 65575), c)
    case False{}:
      gc.n2905(U32.is_lt(c, 65630), c)

def gc.n2907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2891(U32.is_lt(c, 65509), c)
    case False{}:
      gc.n2906(U32.is_lt(c, 65598), c)

def gc.n2908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2876(U32.is_lt(c, 65375), c)
    case False{}:
      gc.n2907(U32.is_lt(c, 65534), c)

def gc.n2909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n2910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n2911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2909(U32.is_lt(c, 65799), c)
    case False{}:
      gc.n2910(U32.is_lt(c, 65847), c)

def gc.n2912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "No"

def gc.n2913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "No"

def gc.n2914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2912(U32.is_lt(c, 65909), c)
    case False{}:
      gc.n2913(U32.is_lt(c, 65930), c)

def gc.n2915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2911(U32.is_lt(c, 65844), c)
    case False{}:
      gc.n2914(U32.is_lt(c, 65913), c)

def gc.n2916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2916(U32.is_lt(c, 65935), c)
    case False{}:
      gc.n2917(U32.is_lt(c, 65949), c)

def gc.n2919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n2920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n2921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2919(U32.is_lt(c, 65953), c)
    case False{}:
      gc.n2920(U32.is_lt(c, 66045), c)

def gc.n2922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2918(U32.is_lt(c, 65936), c)
    case False{}:
      gc.n2921(U32.is_lt(c, 66000), c)

def gc.n2923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2915(U32.is_lt(c, 65856), c)
    case False{}:
      gc.n2922(U32.is_lt(c, 65952), c)

def gc.n2924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2924(U32.is_lt(c, 66176), c)
    case False{}:
      gc.n2925(U32.is_lt(c, 66208), c)

def gc.n2927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n2928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n2929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2927(U32.is_lt(c, 66272), c)
    case False{}:
      gc.n2928(U32.is_lt(c, 66300), c)

def gc.n2930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2926(U32.is_lt(c, 66205), c)
    case False{}:
      gc.n2929(U32.is_lt(c, 66273), c)

def gc.n2931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "No"

def gc.n2932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2931(U32.is_lt(c, 66336), c)
    case False{}:
      gc.n2932(U32.is_lt(c, 66349), c)

def gc.n2934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Lo"

def gc.n2935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Cn"

def gc.n2936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2934(U32.is_lt(c, 66370), c)
    case False{}:
      gc.n2935(U32.is_lt(c, 66379), c)

def gc.n2937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2933(U32.is_lt(c, 66340), c)
    case False{}:
      gc.n2936(U32.is_lt(c, 66378), c)

def gc.n2938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2930(U32.is_lt(c, 66257), c)
    case False{}:
      gc.n2937(U32.is_lt(c, 66369), c)

def gc.n2939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2923(U32.is_lt(c, 65932), c)
    case False{}:
      gc.n2938(U32.is_lt(c, 66304), c)

def gc.n2940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n2941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n2942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2940(U32.is_lt(c, 66422), c)
    case False{}:
      gc.n2941(U32.is_lt(c, 66432), c)

def gc.n2943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n2944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2943(U32.is_lt(c, 66463), c)
    case False{}:
      gc.n2944(U32.is_lt(c, 66500), c)

def gc.n2946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2942(U32.is_lt(c, 66427), c)
    case False{}:
      gc.n2945(U32.is_lt(c, 66464), c)

def gc.n2947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n2948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Cn"

def gc.n2949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2947(U32.is_lt(c, 66512), c)
    case False{}:
      gc.n2948(U32.is_lt(c, 66518), c)

def gc.n2950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n2951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2950(U32.is_lt(c, 66600), c)
    case False{}:
      gc.n2951(U32.is_lt(c, 66718), c)

def gc.n2953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2949(U32.is_lt(c, 66513), c)
    case False{}:
      gc.n2952(U32.is_lt(c, 66640), c)

def gc.n2954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2946(U32.is_lt(c, 66462), c)
    case False{}:
      gc.n2953(U32.is_lt(c, 66560), c)

def gc.n2955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n2956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n2957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2955(U32.is_lt(c, 66730), c)
    case False{}:
      gc.n2956(U32.is_lt(c, 66772), c)

def gc.n2958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2958(U32.is_lt(c, 66812), c)
    case False{}:
      gc.n2959(U32.is_lt(c, 66856), c)

def gc.n2961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2957(U32.is_lt(c, 66736), c)
    case False{}:
      gc.n2960(U32.is_lt(c, 66816), c)

def gc.n2962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lu"

def gc.n2964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2962(U32.is_lt(c, 66916), c)
    case False{}:
      gc.n2963(U32.is_lt(c, 66928), c)

def gc.n2965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n2966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n2967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n2966(U32.is_lt(c, 66963), c)

def gc.n2968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2965(U32.is_lt(c, 66940), c)
    case False{}:
      gc.n2967(U32.is_lt(c, 66956), c)

def gc.n2969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2964(U32.is_lt(c, 66927), c)
    case False{}:
      gc.n2968(U32.is_lt(c, 66955), c)

def gc.n2970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2961(U32.is_lt(c, 66776), c)
    case False{}:
      gc.n2969(U32.is_lt(c, 66939), c)

def gc.n2971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2954(U32.is_lt(c, 66504), c)
    case False{}:
      gc.n2970(U32.is_lt(c, 66864), c)

def gc.n2972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2939(U32.is_lt(c, 66046), c)
    case False{}:
      gc.n2971(U32.is_lt(c, 66720), c)

def gc.n2973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2908(U32.is_lt(c, 65490), c)
    case False{}:
      gc.n2972(U32.is_lt(c, 66384), c)

def gc.n2974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n2975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2974(U32.is_lt(c, 66966), c)
    case False{}:
      gc.n2975(U32.is_lt(c, 66978), c)

def gc.n2977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2977(U32.is_lt(c, 66994), c)
    case False{}:
      gc.n2978(U32.is_lt(c, 67002), c)

def gc.n2980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2976(U32.is_lt(c, 66967), c)
    case False{}:
      gc.n2979(U32.is_lt(c, 66995), c)

def gc.n2981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n2982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2981(U32.is_lt(c, 67005), c)
    case False{}:
      gc.n2982(U32.is_lt(c, 67060), c)

def gc.n2984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2984(U32.is_lt(c, 67383), c)
    case False{}:
      gc.n2985(U32.is_lt(c, 67414), c)

def gc.n2987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2983(U32.is_lt(c, 67008), c)
    case False{}:
      gc.n2986(U32.is_lt(c, 67392), c)

def gc.n2988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2980(U32.is_lt(c, 66979), c)
    case False{}:
      gc.n2987(U32.is_lt(c, 67072), c)

def gc.n2989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n2991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2989(U32.is_lt(c, 67432), c)
    case False{}:
      gc.n2990(U32.is_lt(c, 67462), c)

def gc.n2992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n2993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n2994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2992(U32.is_lt(c, 67505), c)
    case False{}:
      gc.n2993(U32.is_lt(c, 67515), c)

def gc.n2995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2991(U32.is_lt(c, 67456), c)
    case False{}:
      gc.n2994(U32.is_lt(c, 67506), c)

def gc.n2996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n2998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2996(U32.is_lt(c, 67590), c)
    case False{}:
      gc.n2997(U32.is_lt(c, 67593), c)

def gc.n2999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2999(U32.is_lt(c, 67638), c)
    case False{}:
      gc.n3000(U32.is_lt(c, 67641), c)

def gc.n3002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2998(U32.is_lt(c, 67592), c)
    case False{}:
      gc.n3001(U32.is_lt(c, 67639), c)

def gc.n3003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2995(U32.is_lt(c, 67463), c)
    case False{}:
      gc.n3002(U32.is_lt(c, 67594), c)

def gc.n3004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2988(U32.is_lt(c, 67003), c)
    case False{}:
      gc.n3003(U32.is_lt(c, 67584), c)

def gc.n3005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3005(U32.is_lt(c, 67645), c)
    case False{}:
      gc.n3006(U32.is_lt(c, 67670), c)

def gc.n3008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "No"

def gc.n3009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n3010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3008(U32.is_lt(c, 67672), c)
    case False{}:
      gc.n3009(U32.is_lt(c, 67703), c)

def gc.n3011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3007(U32.is_lt(c, 67647), c)
    case False{}:
      gc.n3010(U32.is_lt(c, 67680), c)

def gc.n3012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Lo"

def gc.n3013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3012(U32.is_lt(c, 67712), c)
    case False{}:
      gc.n3013(U32.is_lt(c, 67751), c)

def gc.n3015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3015(U32.is_lt(c, 67808), c)
    case False{}:
      gc.n3016(U32.is_lt(c, 67828), c)

def gc.n3018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3014(U32.is_lt(c, 67743), c)
    case False{}:
      gc.n3017(U32.is_lt(c, 67827), c)

def gc.n3019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3011(U32.is_lt(c, 67671), c)
    case False{}:
      gc.n3018(U32.is_lt(c, 67760), c)

def gc.n3020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "No"

def gc.n3022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3020(U32.is_lt(c, 67835), c)
    case False{}:
      gc.n3021(U32.is_lt(c, 67862), c)

def gc.n3023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n3024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3023(U32.is_lt(c, 67871), c)
    case False{}:
      gc.n3024(U32.is_lt(c, 67898), c)

def gc.n3026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3022(U32.is_lt(c, 67840), c)
    case False{}:
      gc.n3025(U32.is_lt(c, 67872), c)

def gc.n3027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3027(U32.is_lt(c, 67904), c)
    case False{}:
      gc.n3028(U32.is_lt(c, 67968), c)

def gc.n3030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n3031(U32.is_lt(c, 68048), c)

def gc.n3033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3030(U32.is_lt(c, 68028), c)
    case False{}:
      gc.n3032(U32.is_lt(c, 68032), c)

def gc.n3034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3029(U32.is_lt(c, 67930), c)
    case False{}:
      gc.n3033(U32.is_lt(c, 68030), c)

def gc.n3035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3026(U32.is_lt(c, 67868), c)
    case False{}:
      gc.n3034(U32.is_lt(c, 68024), c)

def gc.n3036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3019(U32.is_lt(c, 67705), c)
    case False{}:
      gc.n3035(U32.is_lt(c, 67903), c)

def gc.n3037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3004(U32.is_lt(c, 67424), c)
    case False{}:
      gc.n3036(U32.is_lt(c, 67830), c)

def gc.n3038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Lo"

def gc.n3039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3038(U32.is_lt(c, 68096), c)
    case False{}:
      gc.n3039(U32.is_lt(c, 68100), c)

def gc.n3041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3041(U32.is_lt(c, 68103), c)
    case False{}:
      gc.n3042(U32.is_lt(c, 68112), c)

def gc.n3044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3040(U32.is_lt(c, 68097), c)
    case False{}:
      gc.n3043(U32.is_lt(c, 68108), c)

def gc.n3045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3045(U32.is_lt(c, 68117), c)
    case False{}:
      gc.n3046(U32.is_lt(c, 68121), c)

def gc.n3048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3048(U32.is_lt(c, 68152), c)
    case False{}:
      gc.n3049(U32.is_lt(c, 68159), c)

def gc.n3051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3047(U32.is_lt(c, 68120), c)
    case False{}:
      gc.n3050(U32.is_lt(c, 68155), c)

def gc.n3052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3044(U32.is_lt(c, 68101), c)
    case False{}:
      gc.n3051(U32.is_lt(c, 68150), c)

def gc.n3053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3053(U32.is_lt(c, 68169), c)
    case False{}:
      gc.n3054(U32.is_lt(c, 68185), c)

def gc.n3056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "No"

def gc.n3057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3056(U32.is_lt(c, 68221), c)
    case False{}:
      gc.n3057(U32.is_lt(c, 68224), c)

def gc.n3059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3055(U32.is_lt(c, 68176), c)
    case False{}:
      gc.n3058(U32.is_lt(c, 68223), c)

def gc.n3060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n3062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3060(U32.is_lt(c, 68256), c)
    case False{}:
      gc.n3061(U32.is_lt(c, 68296), c)

def gc.n3063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3063(U32.is_lt(c, 68325), c)
    case False{}:
      gc.n3064(U32.is_lt(c, 68331), c)

def gc.n3066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3062(U32.is_lt(c, 68288), c)
    case False{}:
      gc.n3065(U32.is_lt(c, 68327), c)

def gc.n3067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3059(U32.is_lt(c, 68192), c)
    case False{}:
      gc.n3066(U32.is_lt(c, 68297), c)

def gc.n3068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3052(U32.is_lt(c, 68116), c)
    case False{}:
      gc.n3067(U32.is_lt(c, 68253), c)

def gc.n3069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3069(U32.is_lt(c, 68343), c)
    case False{}:
      gc.n3070(U32.is_lt(c, 68406), c)

def gc.n3072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3072(U32.is_lt(c, 68416), c)
    case False{}:
      gc.n3073(U32.is_lt(c, 68440), c)

def gc.n3075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3071(U32.is_lt(c, 68352), c)
    case False{}:
      gc.n3074(U32.is_lt(c, 68438), c)

def gc.n3076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Lo"

def gc.n3078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3076(U32.is_lt(c, 68467), c)
    case False{}:
      gc.n3077(U32.is_lt(c, 68480), c)

def gc.n3079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n3080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3079(U32.is_lt(c, 68505), c)
    case False{}:
      gc.n3080(U32.is_lt(c, 68521), c)

def gc.n3082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3078(U32.is_lt(c, 68472), c)
    case False{}:
      gc.n3081(U32.is_lt(c, 68509), c)

def gc.n3083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3075(U32.is_lt(c, 68409), c)
    case False{}:
      gc.n3082(U32.is_lt(c, 68498), c)

def gc.n3084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3084(U32.is_lt(c, 68608), c)
    case False{}:
      gc.n3085(U32.is_lt(c, 68736), c)

def gc.n3087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3087(U32.is_lt(c, 68800), c)
    case False{}:
      gc.n3088(U32.is_lt(c, 68858), c)

def gc.n3090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3086(U32.is_lt(c, 68681), c)
    case False{}:
      gc.n3089(U32.is_lt(c, 68851), c)

def gc.n3091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3091(U32.is_lt(c, 68900), c)
    case False{}:
      gc.n3092(U32.is_lt(c, 68912), c)

def gc.n3094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n3096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n3095(U32.is_lt(c, 68943), c)

def gc.n3097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3094(U32.is_lt(c, 68928), c)
    case False{}:
      gc.n3096(U32.is_lt(c, 68942), c)

def gc.n3098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3093(U32.is_lt(c, 68904), c)
    case False{}:
      gc.n3097(U32.is_lt(c, 68938), c)

def gc.n3099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3090(U32.is_lt(c, 68787), c)
    case False{}:
      gc.n3098(U32.is_lt(c, 68922), c)

def gc.n3100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3083(U32.is_lt(c, 68448), c)
    case False{}:
      gc.n3099(U32.is_lt(c, 68864), c)

def gc.n3101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3068(U32.is_lt(c, 68160), c)
    case False{}:
      gc.n3100(U32.is_lt(c, 68528), c)

def gc.n3102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3037(U32.is_lt(c, 67644), c)
    case False{}:
      gc.n3101(U32.is_lt(c, 68336), c)

def gc.n3103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2973(U32.is_lt(c, 65795), c)
    case False{}:
      gc.n3102(U32.is_lt(c, 68050), c)

def gc.n3104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2845(U32.is_lt(c, 43867), c)
    case False{}:
      gc.n3103(U32.is_lt(c, 66964), c)

def gc.n3105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2587(U32.is_lt(c, 42561), c)
    case False{}:
      gc.n3104(U32.is_lt(c, 65296), c)

def gc.n3106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Pd"

def gc.n3108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3106(U32.is_lt(c, 68966), c)
    case False{}:
      gc.n3107(U32.is_lt(c, 68974), c)

def gc.n3109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Ll"

def gc.n3110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sm"

def gc.n3111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3109(U32.is_lt(c, 68976), c)
    case False{}:
      gc.n3110(U32.is_lt(c, 69006), c)

def gc.n3112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3108(U32.is_lt(c, 68969), c)
    case False{}:
      gc.n3111(U32.is_lt(c, 68998), c)

def gc.n3113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3113(U32.is_lt(c, 69216), c)
    case False{}:
      gc.n3114(U32.is_lt(c, 69248), c)

def gc.n3116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Pd"
    case False{}:
      "Cn"

def gc.n3118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3116(U32.is_lt(c, 69291), c)
    case False{}:
      gc.n3117(U32.is_lt(c, 69294), c)

def gc.n3119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3115(U32.is_lt(c, 69247), c)
    case False{}:
      gc.n3118(U32.is_lt(c, 69293), c)

def gc.n3120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3112(U32.is_lt(c, 68975), c)
    case False{}:
      gc.n3119(U32.is_lt(c, 69290), c)

def gc.n3121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n3123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3121(U32.is_lt(c, 69298), c)
    case False{}:
      gc.n3122(U32.is_lt(c, 69317), c)

def gc.n3124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n3126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3124(U32.is_lt(c, 69320), c)
    case False{}:
      gc.n3125(U32.is_lt(c, 69329), c)

def gc.n3127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3123(U32.is_lt(c, 69314), c)
    case False{}:
      gc.n3126(U32.is_lt(c, 69328), c)

def gc.n3128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "No"

def gc.n3130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3128(U32.is_lt(c, 69370), c)
    case False{}:
      gc.n3129(U32.is_lt(c, 69405), c)

def gc.n3131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3131(U32.is_lt(c, 69416), c)
    case False{}:
      gc.n3132(U32.is_lt(c, 69446), c)

def gc.n3134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3130(U32.is_lt(c, 69376), c)
    case False{}:
      gc.n3133(U32.is_lt(c, 69424), c)

def gc.n3135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3127(U32.is_lt(c, 69318), c)
    case False{}:
      gc.n3134(U32.is_lt(c, 69415), c)

def gc.n3136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3120(U32.is_lt(c, 69008), c)
    case False{}:
      gc.n3135(U32.is_lt(c, 69337), c)

def gc.n3137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Po"

def gc.n3138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3137(U32.is_lt(c, 69461), c)
    case False{}:
      gc.n3138(U32.is_lt(c, 69488), c)

def gc.n3140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3140(U32.is_lt(c, 69510), c)
    case False{}:
      gc.n3141(U32.is_lt(c, 69552), c)

def gc.n3143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3139(U32.is_lt(c, 69466), c)
    case False{}:
      gc.n3142(U32.is_lt(c, 69514), c)

def gc.n3144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3144(U32.is_lt(c, 69580), c)
    case False{}:
      gc.n3145(U32.is_lt(c, 69623), c)

def gc.n3147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3147(U32.is_lt(c, 69633), c)
    case False{}:
      gc.n3148(U32.is_lt(c, 69635), c)

def gc.n3150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3146(U32.is_lt(c, 69600), c)
    case False{}:
      gc.n3149(U32.is_lt(c, 69634), c)

def gc.n3151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3143(U32.is_lt(c, 69506), c)
    case False{}:
      gc.n3150(U32.is_lt(c, 69632), c)

def gc.n3152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3152(U32.is_lt(c, 69703), c)
    case False{}:
      gc.n3153(U32.is_lt(c, 69714), c)

def gc.n3155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Mn"

def gc.n3156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3155(U32.is_lt(c, 69744), c)
    case False{}:
      gc.n3156(U32.is_lt(c, 69747), c)

def gc.n3158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3154(U32.is_lt(c, 69710), c)
    case False{}:
      gc.n3157(U32.is_lt(c, 69745), c)

def gc.n3159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3159(U32.is_lt(c, 69750), c)
    case False{}:
      gc.n3160(U32.is_lt(c, 69762), c)

def gc.n3162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3162(U32.is_lt(c, 69808), c)
    case False{}:
      gc.n3163(U32.is_lt(c, 69815), c)

def gc.n3165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3161(U32.is_lt(c, 69759), c)
    case False{}:
      gc.n3164(U32.is_lt(c, 69811), c)

def gc.n3166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3158(U32.is_lt(c, 69734), c)
    case False{}:
      gc.n3165(U32.is_lt(c, 69763), c)

def gc.n3167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3151(U32.is_lt(c, 69573), c)
    case False{}:
      gc.n3166(U32.is_lt(c, 69749), c)

def gc.n3168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3136(U32.is_lt(c, 69296), c)
    case False{}:
      gc.n3167(U32.is_lt(c, 69688), c)

def gc.n3169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Po"

def gc.n3171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3169(U32.is_lt(c, 69819), c)
    case False{}:
      gc.n3170(U32.is_lt(c, 69822), c)

def gc.n3172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cf"
    case False{}:
      "Cn"

def gc.n3174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3172(U32.is_lt(c, 69827), c)
    case False{}:
      gc.n3173(U32.is_lt(c, 69838), c)

def gc.n3175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3171(U32.is_lt(c, 69821), c)
    case False{}:
      gc.n3174(U32.is_lt(c, 69837), c)

def gc.n3176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3176(U32.is_lt(c, 69865), c)
    case False{}:
      gc.n3177(U32.is_lt(c, 69882), c)

def gc.n3179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3179(U32.is_lt(c, 69891), c)
    case False{}:
      gc.n3180(U32.is_lt(c, 69932), c)

def gc.n3182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3178(U32.is_lt(c, 69872), c)
    case False{}:
      gc.n3181(U32.is_lt(c, 69927), c)

def gc.n3183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3175(U32.is_lt(c, 69826), c)
    case False{}:
      gc.n3182(U32.is_lt(c, 69888), c)

def gc.n3184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Po"

def gc.n3186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3184(U32.is_lt(c, 69941), c)
    case False{}:
      gc.n3185(U32.is_lt(c, 69952), c)

def gc.n3187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3187(U32.is_lt(c, 69957), c)
    case False{}:
      gc.n3188(U32.is_lt(c, 69960), c)

def gc.n3190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3186(U32.is_lt(c, 69942), c)
    case False{}:
      gc.n3189(U32.is_lt(c, 69959), c)

def gc.n3191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3191(U32.is_lt(c, 70003), c)
    case False{}:
      gc.n3192(U32.is_lt(c, 70006), c)

def gc.n3194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3194(U32.is_lt(c, 70016), c)
    case False{}:
      gc.n3195(U32.is_lt(c, 70019), c)

def gc.n3197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3193(U32.is_lt(c, 70004), c)
    case False{}:
      gc.n3196(U32.is_lt(c, 70018), c)

def gc.n3198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3190(U32.is_lt(c, 69956), c)
    case False{}:
      gc.n3197(U32.is_lt(c, 70007), c)

def gc.n3199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3183(U32.is_lt(c, 69840), c)
    case False{}:
      gc.n3198(U32.is_lt(c, 69968), c)

def gc.n3200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3200(U32.is_lt(c, 70070), c)
    case False{}:
      gc.n3201(U32.is_lt(c, 70081), c)

def gc.n3203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n3204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mc"

def gc.n3205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3203(U32.is_lt(c, 70089), c)
    case False{}:
      gc.n3204(U32.is_lt(c, 70094), c)

def gc.n3206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3202(U32.is_lt(c, 70079), c)
    case False{}:
      gc.n3205(U32.is_lt(c, 70093), c)

def gc.n3207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Nd"

def gc.n3208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n3209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3207(U32.is_lt(c, 70096), c)
    case False{}:
      gc.n3208(U32.is_lt(c, 70107), c)

def gc.n3210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n3211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3210(U32.is_lt(c, 70109), c)
    case False{}:
      gc.n3211(U32.is_lt(c, 70113), c)

def gc.n3213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3209(U32.is_lt(c, 70106), c)
    case False{}:
      gc.n3212(U32.is_lt(c, 70112), c)

def gc.n3214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3206(U32.is_lt(c, 70085), c)
    case False{}:
      gc.n3213(U32.is_lt(c, 70108), c)

def gc.n3215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3215(U32.is_lt(c, 70144), c)
    case False{}:
      gc.n3216(U32.is_lt(c, 70163), c)

def gc.n3218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3218(U32.is_lt(c, 70191), c)
    case False{}:
      gc.n3219(U32.is_lt(c, 70196), c)

def gc.n3221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3217(U32.is_lt(c, 70162), c)
    case False{}:
      gc.n3220(U32.is_lt(c, 70194), c)

def gc.n3222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n3224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3222(U32.is_lt(c, 70198), c)
    case False{}:
      gc.n3223(U32.is_lt(c, 70206), c)

def gc.n3225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n3226(U32.is_lt(c, 70279), c)

def gc.n3228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3225(U32.is_lt(c, 70209), c)
    case False{}:
      gc.n3227(U32.is_lt(c, 70272), c)

def gc.n3229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3224(U32.is_lt(c, 70200), c)
    case False{}:
      gc.n3228(U32.is_lt(c, 70210), c)

def gc.n3230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3221(U32.is_lt(c, 70188), c)
    case False{}:
      gc.n3229(U32.is_lt(c, 70207), c)

def gc.n3231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3214(U32.is_lt(c, 70095), c)
    case False{}:
      gc.n3230(U32.is_lt(c, 70197), c)

def gc.n3232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3199(U32.is_lt(c, 69933), c)
    case False{}:
      gc.n3231(U32.is_lt(c, 70133), c)

def gc.n3233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3168(U32.is_lt(c, 69457), c)
    case False{}:
      gc.n3232(U32.is_lt(c, 70067), c)

def gc.n3234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3234(U32.is_lt(c, 70281), c)
    case False{}:
      gc.n3235(U32.is_lt(c, 70286), c)

def gc.n3237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n3239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3237(U32.is_lt(c, 70302), c)
    case False{}:
      gc.n3238(U32.is_lt(c, 70313), c)

def gc.n3240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3236(U32.is_lt(c, 70282), c)
    case False{}:
      gc.n3239(U32.is_lt(c, 70303), c)

def gc.n3241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3241(U32.is_lt(c, 70320), c)
    case False{}:
      gc.n3242(U32.is_lt(c, 70368), c)

def gc.n3244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3244(U32.is_lt(c, 70379), c)
    case False{}:
      gc.n3245(U32.is_lt(c, 70394), c)

def gc.n3247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3243(U32.is_lt(c, 70367), c)
    case False{}:
      gc.n3246(U32.is_lt(c, 70384), c)

def gc.n3248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3240(U32.is_lt(c, 70287), c)
    case False{}:
      gc.n3247(U32.is_lt(c, 70371), c)

def gc.n3249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3249(U32.is_lt(c, 70402), c)
    case False{}:
      gc.n3250(U32.is_lt(c, 70405), c)

def gc.n3252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3252(U32.is_lt(c, 70415), c)
    case False{}:
      gc.n3253(U32.is_lt(c, 70419), c)

def gc.n3255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3251(U32.is_lt(c, 70404), c)
    case False{}:
      gc.n3254(U32.is_lt(c, 70417), c)

def gc.n3256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3256(U32.is_lt(c, 70442), c)
    case False{}:
      gc.n3257(U32.is_lt(c, 70450), c)

def gc.n3259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3259(U32.is_lt(c, 70453), c)
    case False{}:
      gc.n3260(U32.is_lt(c, 70459), c)

def gc.n3262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3258(U32.is_lt(c, 70449), c)
    case False{}:
      gc.n3261(U32.is_lt(c, 70458), c)

def gc.n3263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3255(U32.is_lt(c, 70413), c)
    case False{}:
      gc.n3262(U32.is_lt(c, 70452), c)

def gc.n3264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3248(U32.is_lt(c, 70314), c)
    case False{}:
      gc.n3263(U32.is_lt(c, 70441), c)

def gc.n3265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3265(U32.is_lt(c, 70462), c)
    case False{}:
      gc.n3266(U32.is_lt(c, 70465), c)

def gc.n3268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3268(U32.is_lt(c, 70471), c)
    case False{}:
      gc.n3269(U32.is_lt(c, 70475), c)

def gc.n3271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3267(U32.is_lt(c, 70464), c)
    case False{}:
      gc.n3270(U32.is_lt(c, 70473), c)

def gc.n3272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3272(U32.is_lt(c, 70480), c)
    case False{}:
      gc.n3273(U32.is_lt(c, 70487), c)

def gc.n3275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3275(U32.is_lt(c, 70493), c)
    case False{}:
      gc.n3276(U32.is_lt(c, 70500), c)

def gc.n3278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3274(U32.is_lt(c, 70481), c)
    case False{}:
      gc.n3277(U32.is_lt(c, 70498), c)

def gc.n3279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3271(U32.is_lt(c, 70469), c)
    case False{}:
      gc.n3278(U32.is_lt(c, 70488), c)

def gc.n3280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3280(U32.is_lt(c, 70509), c)
    case False{}:
      gc.n3281(U32.is_lt(c, 70517), c)

def gc.n3283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3283(U32.is_lt(c, 70538), c)
    case False{}:
      gc.n3284(U32.is_lt(c, 70540), c)

def gc.n3286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3282(U32.is_lt(c, 70512), c)
    case False{}:
      gc.n3285(U32.is_lt(c, 70539), c)

def gc.n3287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3287(U32.is_lt(c, 70543), c)
    case False{}:
      gc.n3288(U32.is_lt(c, 70582), c)

def gc.n3290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      gc.n3291(U32.is_lt(c, 70594), c)

def gc.n3293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3290(U32.is_lt(c, 70584), c)
    case False{}:
      gc.n3292(U32.is_lt(c, 70593), c)

def gc.n3294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3289(U32.is_lt(c, 70544), c)
    case False{}:
      gc.n3293(U32.is_lt(c, 70587), c)

def gc.n3295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3286(U32.is_lt(c, 70528), c)
    case False{}:
      gc.n3294(U32.is_lt(c, 70583), c)

def gc.n3296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3279(U32.is_lt(c, 70478), c)
    case False{}:
      gc.n3295(U32.is_lt(c, 70542), c)

def gc.n3297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3264(U32.is_lt(c, 70400), c)
    case False{}:
      gc.n3296(U32.is_lt(c, 70502), c)

def gc.n3298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3298(U32.is_lt(c, 70597), c)
    case False{}:
      gc.n3299(U32.is_lt(c, 70599), c)

def gc.n3301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3301(U32.is_lt(c, 70604), c)
    case False{}:
      gc.n3302(U32.is_lt(c, 70607), c)

def gc.n3304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3300(U32.is_lt(c, 70598), c)
    case False{}:
      gc.n3303(U32.is_lt(c, 70606), c)

def gc.n3305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3305(U32.is_lt(c, 70609), c)
    case False{}:
      gc.n3306(U32.is_lt(c, 70611), c)

def gc.n3308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3308(U32.is_lt(c, 70614), c)
    case False{}:
      gc.n3309(U32.is_lt(c, 70617), c)

def gc.n3311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3307(U32.is_lt(c, 70610), c)
    case False{}:
      gc.n3310(U32.is_lt(c, 70615), c)

def gc.n3312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3304(U32.is_lt(c, 70603), c)
    case False{}:
      gc.n3311(U32.is_lt(c, 70612), c)

def gc.n3313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3313(U32.is_lt(c, 70627), c)
    case False{}:
      gc.n3314(U32.is_lt(c, 70709), c)

def gc.n3316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3316(U32.is_lt(c, 70720), c)
    case False{}:
      gc.n3317(U32.is_lt(c, 70725), c)

def gc.n3319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3315(U32.is_lt(c, 70656), c)
    case False{}:
      gc.n3318(U32.is_lt(c, 70722), c)

def gc.n3320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n3322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3320(U32.is_lt(c, 70727), c)
    case False{}:
      gc.n3321(U32.is_lt(c, 70736), c)

def gc.n3323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Mn"

def gc.n3325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3323(U32.is_lt(c, 70748), c)
    case False{}:
      gc.n3324(U32.is_lt(c, 70750), c)

def gc.n3326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3322(U32.is_lt(c, 70731), c)
    case False{}:
      gc.n3325(U32.is_lt(c, 70749), c)

def gc.n3327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3319(U32.is_lt(c, 70712), c)
    case False{}:
      gc.n3326(U32.is_lt(c, 70746), c)

def gc.n3328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3312(U32.is_lt(c, 70608), c)
    case False{}:
      gc.n3327(U32.is_lt(c, 70726), c)

def gc.n3329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3329(U32.is_lt(c, 70754), c)
    case False{}:
      gc.n3330(U32.is_lt(c, 70832), c)

def gc.n3332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3332(U32.is_lt(c, 70841), c)
    case False{}:
      gc.n3333(U32.is_lt(c, 70843), c)

def gc.n3335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3331(U32.is_lt(c, 70784), c)
    case False{}:
      gc.n3334(U32.is_lt(c, 70842), c)

def gc.n3336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3336(U32.is_lt(c, 70849), c)
    case False{}:
      gc.n3337(U32.is_lt(c, 70852), c)

def gc.n3339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3339(U32.is_lt(c, 70855), c)
    case False{}:
      gc.n3340(U32.is_lt(c, 70864), c)

def gc.n3342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3338(U32.is_lt(c, 70850), c)
    case False{}:
      gc.n3341(U32.is_lt(c, 70856), c)

def gc.n3343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3335(U32.is_lt(c, 70835), c)
    case False{}:
      gc.n3342(U32.is_lt(c, 70854), c)

def gc.n3344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3344(U32.is_lt(c, 71040), c)
    case False{}:
      gc.n3345(U32.is_lt(c, 71090), c)

def gc.n3347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3347(U32.is_lt(c, 71096), c)
    case False{}:
      gc.n3348(U32.is_lt(c, 71102), c)

def gc.n3350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3346(U32.is_lt(c, 71087), c)
    case False{}:
      gc.n3349(U32.is_lt(c, 71100), c)

def gc.n3351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3351(U32.is_lt(c, 71105), c)
    case False{}:
      gc.n3352(U32.is_lt(c, 71132), c)

def gc.n3354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      gc.n3355(U32.is_lt(c, 71227), c)

def gc.n3357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3354(U32.is_lt(c, 71168), c)
    case False{}:
      gc.n3356(U32.is_lt(c, 71219), c)

def gc.n3358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3353(U32.is_lt(c, 71128), c)
    case False{}:
      gc.n3357(U32.is_lt(c, 71216), c)

def gc.n3359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3350(U32.is_lt(c, 71094), c)
    case False{}:
      gc.n3358(U32.is_lt(c, 71134), c)

def gc.n3360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3343(U32.is_lt(c, 70847), c)
    case False{}:
      gc.n3359(U32.is_lt(c, 71103), c)

def gc.n3361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3328(U32.is_lt(c, 70625), c)
    case False{}:
      gc.n3360(U32.is_lt(c, 70874), c)

def gc.n3362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3297(U32.is_lt(c, 70461), c)
    case False{}:
      gc.n3361(U32.is_lt(c, 70751), c)

def gc.n3363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3233(U32.is_lt(c, 69817), c)
    case False{}:
      gc.n3362(U32.is_lt(c, 70595), c)

def gc.n3364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3364(U32.is_lt(c, 71230), c)
    case False{}:
      gc.n3365(U32.is_lt(c, 71233), c)

def gc.n3367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3367(U32.is_lt(c, 71237), c)
    case False{}:
      gc.n3368(U32.is_lt(c, 71258), c)

def gc.n3370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3366(U32.is_lt(c, 71231), c)
    case False{}:
      gc.n3369(U32.is_lt(c, 71248), c)

def gc.n3371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3371(U32.is_lt(c, 71277), c)
    case False{}:
      gc.n3372(U32.is_lt(c, 71339), c)

def gc.n3374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3374(U32.is_lt(c, 71341), c)
    case False{}:
      gc.n3375(U32.is_lt(c, 71344), c)

def gc.n3377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3373(U32.is_lt(c, 71296), c)
    case False{}:
      gc.n3376(U32.is_lt(c, 71342), c)

def gc.n3378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3370(U32.is_lt(c, 71236), c)
    case False{}:
      gc.n3377(U32.is_lt(c, 71340), c)

def gc.n3379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n3381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3379(U32.is_lt(c, 71351), c)
    case False{}:
      gc.n3380(U32.is_lt(c, 71353), c)

def gc.n3382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3382(U32.is_lt(c, 71360), c)
    case False{}:
      gc.n3383(U32.is_lt(c, 71376), c)

def gc.n3385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3381(U32.is_lt(c, 71352), c)
    case False{}:
      gc.n3384(U32.is_lt(c, 71370), c)

def gc.n3386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3386(U32.is_lt(c, 71424), c)
    case False{}:
      gc.n3387(U32.is_lt(c, 71453), c)

def gc.n3389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3389(U32.is_lt(c, 71455), c)
    case False{}:
      gc.n3390(U32.is_lt(c, 71458), c)

def gc.n3392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3388(U32.is_lt(c, 71451), c)
    case False{}:
      gc.n3391(U32.is_lt(c, 71456), c)

def gc.n3393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3385(U32.is_lt(c, 71354), c)
    case False{}:
      gc.n3392(U32.is_lt(c, 71454), c)

def gc.n3394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3378(U32.is_lt(c, 71264), c)
    case False{}:
      gc.n3393(U32.is_lt(c, 71396), c)

def gc.n3395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3395(U32.is_lt(c, 71463), c)
    case False{}:
      gc.n3396(U32.is_lt(c, 71472), c)

def gc.n3398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Po"

def gc.n3399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lo"

def gc.n3400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3398(U32.is_lt(c, 71484), c)
    case False{}:
      gc.n3399(U32.is_lt(c, 71488), c)

def gc.n3401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3397(U32.is_lt(c, 71468), c)
    case False{}:
      gc.n3400(U32.is_lt(c, 71487), c)

def gc.n3402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3402(U32.is_lt(c, 71680), c)
    case False{}:
      gc.n3403(U32.is_lt(c, 71727), c)

def gc.n3405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3405(U32.is_lt(c, 71737), c)
    case False{}:
      gc.n3406(U32.is_lt(c, 71740), c)

def gc.n3408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3404(U32.is_lt(c, 71724), c)
    case False{}:
      gc.n3407(U32.is_lt(c, 71739), c)

def gc.n3409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3401(U32.is_lt(c, 71482), c)
    case False{}:
      gc.n3408(U32.is_lt(c, 71736), c)

def gc.n3410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "No"

def gc.n3412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3410(U32.is_lt(c, 71872), c)
    case False{}:
      gc.n3411(U32.is_lt(c, 71914), c)

def gc.n3413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3413(U32.is_lt(c, 71935), c)
    case False{}:
      gc.n3414(U32.is_lt(c, 71945), c)

def gc.n3416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3412(U32.is_lt(c, 71904), c)
    case False{}:
      gc.n3415(U32.is_lt(c, 71943), c)

def gc.n3417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3417(U32.is_lt(c, 71948), c)
    case False{}:
      gc.n3418(U32.is_lt(c, 71957), c)

def gc.n3420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3420(U32.is_lt(c, 71960), c)
    case False{}:
      gc.n3421(U32.is_lt(c, 71990), c)

def gc.n3423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3419(U32.is_lt(c, 71956), c)
    case False{}:
      gc.n3422(U32.is_lt(c, 71984), c)

def gc.n3424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3416(U32.is_lt(c, 71923), c)
    case False{}:
      gc.n3423(U32.is_lt(c, 71959), c)

def gc.n3425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3409(U32.is_lt(c, 71495), c)
    case False{}:
      gc.n3424(U32.is_lt(c, 71946), c)

def gc.n3426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3394(U32.is_lt(c, 71350), c)
    case False{}:
      gc.n3425(U32.is_lt(c, 71840), c)

def gc.n3427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3427(U32.is_lt(c, 71993), c)
    case False{}:
      gc.n3428(U32.is_lt(c, 71997), c)

def gc.n3430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3430(U32.is_lt(c, 71999), c)
    case False{}:
      gc.n3431(U32.is_lt(c, 72001), c)

def gc.n3433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3429(U32.is_lt(c, 71995), c)
    case False{}:
      gc.n3432(U32.is_lt(c, 72000), c)

def gc.n3434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3434(U32.is_lt(c, 72003), c)
    case False{}:
      gc.n3435(U32.is_lt(c, 72007), c)

def gc.n3437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3437(U32.is_lt(c, 72026), c)
    case False{}:
      gc.n3438(U32.is_lt(c, 72104), c)

def gc.n3440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3436(U32.is_lt(c, 72004), c)
    case False{}:
      gc.n3439(U32.is_lt(c, 72096), c)

def gc.n3441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3433(U32.is_lt(c, 71998), c)
    case False{}:
      gc.n3440(U32.is_lt(c, 72016), c)

def gc.n3442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mc"

def gc.n3443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3442(U32.is_lt(c, 72145), c)
    case False{}:
      gc.n3443(U32.is_lt(c, 72152), c)

def gc.n3445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3445(U32.is_lt(c, 72156), c)
    case False{}:
      gc.n3446(U32.is_lt(c, 72161), c)

def gc.n3448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3444(U32.is_lt(c, 72148), c)
    case False{}:
      gc.n3447(U32.is_lt(c, 72160), c)

def gc.n3449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3449(U32.is_lt(c, 72163), c)
    case False{}:
      gc.n3450(U32.is_lt(c, 72165), c)

def gc.n3452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3452(U32.is_lt(c, 72193), c)
    case False{}:
      gc.n3453(U32.is_lt(c, 72243), c)

def gc.n3455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3451(U32.is_lt(c, 72164), c)
    case False{}:
      gc.n3454(U32.is_lt(c, 72203), c)

def gc.n3456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3448(U32.is_lt(c, 72154), c)
    case False{}:
      gc.n3455(U32.is_lt(c, 72192), c)

def gc.n3457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3441(U32.is_lt(c, 72002), c)
    case False{}:
      gc.n3456(U32.is_lt(c, 72162), c)

def gc.n3458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3458(U32.is_lt(c, 72250), c)
    case False{}:
      gc.n3459(U32.is_lt(c, 72255), c)

def gc.n3461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3461(U32.is_lt(c, 72264), c)
    case False{}:
      gc.n3462(U32.is_lt(c, 72273), c)

def gc.n3464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3460(U32.is_lt(c, 72251), c)
    case False{}:
      gc.n3463(U32.is_lt(c, 72272), c)

def gc.n3465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3465(U32.is_lt(c, 72281), c)
    case False{}:
      gc.n3466(U32.is_lt(c, 72330), c)

def gc.n3468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3468(U32.is_lt(c, 72344), c)
    case False{}:
      gc.n3469(U32.is_lt(c, 72349), c)

def gc.n3471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3467(U32.is_lt(c, 72284), c)
    case False{}:
      gc.n3470(U32.is_lt(c, 72346), c)

def gc.n3472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3464(U32.is_lt(c, 72263), c)
    case False{}:
      gc.n3471(U32.is_lt(c, 72343), c)

def gc.n3473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3473(U32.is_lt(c, 72355), c)
    case False{}:
      gc.n3474(U32.is_lt(c, 72441), c)

def gc.n3476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3476(U32.is_lt(c, 72458), c)
    case False{}:
      gc.n3477(U32.is_lt(c, 72545), c)

def gc.n3479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3475(U32.is_lt(c, 72368), c)
    case False{}:
      gc.n3478(U32.is_lt(c, 72544), c)

def gc.n3480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3480(U32.is_lt(c, 72549), c)
    case False{}:
      gc.n3481(U32.is_lt(c, 72551), c)

def gc.n3483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      gc.n3484(U32.is_lt(c, 72688), c)

def gc.n3486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3483(U32.is_lt(c, 72640), c)
    case False{}:
      gc.n3485(U32.is_lt(c, 72674), c)

def gc.n3487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3482(U32.is_lt(c, 72550), c)
    case False{}:
      gc.n3486(U32.is_lt(c, 72673), c)

def gc.n3488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3479(U32.is_lt(c, 72448), c)
    case False{}:
      gc.n3487(U32.is_lt(c, 72552), c)

def gc.n3489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3472(U32.is_lt(c, 72279), c)
    case False{}:
      gc.n3488(U32.is_lt(c, 72546), c)

def gc.n3490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3457(U32.is_lt(c, 72106), c)
    case False{}:
      gc.n3489(U32.is_lt(c, 72350), c)

def gc.n3491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3426(U32.is_lt(c, 71462), c)
    case False{}:
      gc.n3490(U32.is_lt(c, 72249), c)

def gc.n3492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3492(U32.is_lt(c, 72704), c)
    case False{}:
      gc.n3493(U32.is_lt(c, 72714), c)

def gc.n3495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3495(U32.is_lt(c, 72752), c)
    case False{}:
      gc.n3496(U32.is_lt(c, 72760), c)

def gc.n3498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3494(U32.is_lt(c, 72713), c)
    case False{}:
      gc.n3497(U32.is_lt(c, 72759), c)

def gc.n3499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Po"

def gc.n3501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3499(U32.is_lt(c, 72767), c)
    case False{}:
      gc.n3500(U32.is_lt(c, 72769), c)

def gc.n3502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3502(U32.is_lt(c, 72784), c)
    case False{}:
      gc.n3503(U32.is_lt(c, 72813), c)

def gc.n3505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3501(U32.is_lt(c, 72768), c)
    case False{}:
      gc.n3504(U32.is_lt(c, 72794), c)

def gc.n3506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3498(U32.is_lt(c, 72751), c)
    case False{}:
      gc.n3505(U32.is_lt(c, 72774), c)

def gc.n3507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3507(U32.is_lt(c, 72818), c)
    case False{}:
      gc.n3508(U32.is_lt(c, 72850), c)

def gc.n3510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3510(U32.is_lt(c, 72873), c)
    case False{}:
      gc.n3511(U32.is_lt(c, 72881), c)

def gc.n3513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3509(U32.is_lt(c, 72848), c)
    case False{}:
      gc.n3512(U32.is_lt(c, 72874), c)

def gc.n3514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3514(U32.is_lt(c, 72884), c)
    case False{}:
      gc.n3515(U32.is_lt(c, 72887), c)

def gc.n3517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3517(U32.is_lt(c, 72967), c)
    case False{}:
      gc.n3518(U32.is_lt(c, 72970), c)

def gc.n3520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3516(U32.is_lt(c, 72885), c)
    case False{}:
      gc.n3519(U32.is_lt(c, 72968), c)

def gc.n3521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3513(U32.is_lt(c, 72872), c)
    case False{}:
      gc.n3520(U32.is_lt(c, 72960), c)

def gc.n3522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3506(U32.is_lt(c, 72766), c)
    case False{}:
      gc.n3521(U32.is_lt(c, 72882), c)

def gc.n3523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3523(U32.is_lt(c, 73009), c)
    case False{}:
      gc.n3524(U32.is_lt(c, 73018), c)

def gc.n3526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3526(U32.is_lt(c, 73020), c)
    case False{}:
      gc.n3527(U32.is_lt(c, 73023), c)

def gc.n3529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3525(U32.is_lt(c, 73015), c)
    case False{}:
      gc.n3528(U32.is_lt(c, 73022), c)

def gc.n3530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3530(U32.is_lt(c, 73031), c)
    case False{}:
      gc.n3531(U32.is_lt(c, 73040), c)

def gc.n3533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3533(U32.is_lt(c, 73056), c)
    case False{}:
      gc.n3534(U32.is_lt(c, 73063), c)

def gc.n3536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3532(U32.is_lt(c, 73032), c)
    case False{}:
      gc.n3535(U32.is_lt(c, 73062), c)

def gc.n3537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3529(U32.is_lt(c, 73019), c)
    case False{}:
      gc.n3536(U32.is_lt(c, 73050), c)

def gc.n3538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3538(U32.is_lt(c, 73066), c)
    case False{}:
      gc.n3539(U32.is_lt(c, 73103), c)

def gc.n3541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3541(U32.is_lt(c, 73106), c)
    case False{}:
      gc.n3542(U32.is_lt(c, 73109), c)

def gc.n3544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3540(U32.is_lt(c, 73098), c)
    case False{}:
      gc.n3543(U32.is_lt(c, 73107), c)

def gc.n3545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3545(U32.is_lt(c, 73111), c)
    case False{}:
      gc.n3546(U32.is_lt(c, 73113), c)

def gc.n3548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Lo"

def gc.n3550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n3549(U32.is_lt(c, 73178), c)

def gc.n3551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3548(U32.is_lt(c, 73130), c)
    case False{}:
      gc.n3550(U32.is_lt(c, 73177), c)

def gc.n3552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3547(U32.is_lt(c, 73112), c)
    case False{}:
      gc.n3551(U32.is_lt(c, 73136), c)

def gc.n3553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3544(U32.is_lt(c, 73104), c)
    case False{}:
      gc.n3552(U32.is_lt(c, 73120), c)

def gc.n3554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3537(U32.is_lt(c, 73030), c)
    case False{}:
      gc.n3553(U32.is_lt(c, 73110), c)

def gc.n3555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3522(U32.is_lt(c, 72816), c)
    case False{}:
      gc.n3554(U32.is_lt(c, 73065), c)

def gc.n3556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3556(U32.is_lt(c, 73184), c)
    case False{}:
      gc.n3557(U32.is_lt(c, 73440), c)

def gc.n3559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3559(U32.is_lt(c, 73461), c)
    case False{}:
      gc.n3560(U32.is_lt(c, 73465), c)

def gc.n3562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3558(U32.is_lt(c, 73194), c)
    case False{}:
      gc.n3561(U32.is_lt(c, 73463), c)

def gc.n3563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lo"

def gc.n3565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3563(U32.is_lt(c, 73474), c)
    case False{}:
      gc.n3564(U32.is_lt(c, 73476), c)

def gc.n3566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3566(U32.is_lt(c, 73490), c)
    case False{}:
      gc.n3567(U32.is_lt(c, 73526), c)

def gc.n3569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3565(U32.is_lt(c, 73475), c)
    case False{}:
      gc.n3568(U32.is_lt(c, 73524), c)

def gc.n3570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3562(U32.is_lt(c, 73459), c)
    case False{}:
      gc.n3569(U32.is_lt(c, 73489), c)

def gc.n3571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mc"

def gc.n3572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Mc"

def gc.n3573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3571(U32.is_lt(c, 73534), c)
    case False{}:
      gc.n3572(U32.is_lt(c, 73537), c)

def gc.n3574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Mn"

def gc.n3576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3574(U32.is_lt(c, 73539), c)
    case False{}:
      gc.n3575(U32.is_lt(c, 73562), c)

def gc.n3577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3573(U32.is_lt(c, 73536), c)
    case False{}:
      gc.n3576(U32.is_lt(c, 73552), c)

def gc.n3578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3578(U32.is_lt(c, 73648), c)
    case False{}:
      gc.n3579(U32.is_lt(c, 73664), c)

def gc.n3581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sc"

def gc.n3582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3581(U32.is_lt(c, 73693), c)
    case False{}:
      gc.n3582(U32.is_lt(c, 73714), c)

def gc.n3584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3580(U32.is_lt(c, 73649), c)
    case False{}:
      gc.n3583(U32.is_lt(c, 73697), c)

def gc.n3585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3577(U32.is_lt(c, 73538), c)
    case False{}:
      gc.n3584(U32.is_lt(c, 73685), c)

def gc.n3586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3570(U32.is_lt(c, 73472), c)
    case False{}:
      gc.n3585(U32.is_lt(c, 73563), c)

def gc.n3587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lo"

def gc.n3588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nl"

def gc.n3589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3587(U32.is_lt(c, 73728), c)
    case False{}:
      gc.n3588(U32.is_lt(c, 74752), c)

def gc.n3590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n3591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3590(U32.is_lt(c, 74864), c)
    case False{}:
      gc.n3591(U32.is_lt(c, 74880), c)

def gc.n3593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3589(U32.is_lt(c, 74650), c)
    case False{}:
      gc.n3592(U32.is_lt(c, 74869), c)

def gc.n3594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3594(U32.is_lt(c, 77712), c)
    case False{}:
      gc.n3595(U32.is_lt(c, 77811), c)

def gc.n3597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cf"

def gc.n3598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3597(U32.is_lt(c, 78896), c)
    case False{}:
      gc.n3598(U32.is_lt(c, 78913), c)

def gc.n3600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3596(U32.is_lt(c, 77809), c)
    case False{}:
      gc.n3599(U32.is_lt(c, 78912), c)

def gc.n3601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3593(U32.is_lt(c, 74863), c)
    case False{}:
      gc.n3600(U32.is_lt(c, 77824), c)

def gc.n3602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3602(U32.is_lt(c, 78934), c)
    case False{}:
      gc.n3603(U32.is_lt(c, 82939), c)

def gc.n3605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3605(U32.is_lt(c, 83527), c)
    case False{}:
      gc.n3606(U32.is_lt(c, 90398), c)

def gc.n3608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3604(U32.is_lt(c, 78944), c)
    case False{}:
      gc.n3607(U32.is_lt(c, 90368), c)

def gc.n3609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Mn"

def gc.n3610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3609(U32.is_lt(c, 90413), c)
    case False{}:
      gc.n3610(U32.is_lt(c, 90426), c)

def gc.n3612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n3613(U32.is_lt(c, 92768), c)

def gc.n3615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3612(U32.is_lt(c, 92729), c)
    case False{}:
      gc.n3614(U32.is_lt(c, 92767), c)

def gc.n3616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3611(U32.is_lt(c, 90416), c)
    case False{}:
      gc.n3615(U32.is_lt(c, 92736), c)

def gc.n3617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3608(U32.is_lt(c, 82944), c)
    case False{}:
      gc.n3616(U32.is_lt(c, 92160), c)

def gc.n3618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3601(U32.is_lt(c, 75076), c)
    case False{}:
      gc.n3617(U32.is_lt(c, 90410), c)

def gc.n3619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3586(U32.is_lt(c, 73531), c)
    case False{}:
      gc.n3618(U32.is_lt(c, 78919), c)

def gc.n3620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3555(U32.is_lt(c, 72971), c)
    case False{}:
      gc.n3619(U32.is_lt(c, 73727), c)

def gc.n3621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3491(U32.is_lt(c, 71991), c)
    case False{}:
      gc.n3620(U32.is_lt(c, 73180), c)

def gc.n3622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3363(U32.is_lt(c, 70280), c)
    case False{}:
      gc.n3621(U32.is_lt(c, 72698), c)

def gc.n3623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Po"

def gc.n3624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3623(U32.is_lt(c, 92782), c)
    case False{}:
      gc.n3624(U32.is_lt(c, 92863), c)

def gc.n3626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3626(U32.is_lt(c, 92874), c)
    case False{}:
      gc.n3627(U32.is_lt(c, 92910), c)

def gc.n3629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3625(U32.is_lt(c, 92784), c)
    case False{}:
      gc.n3628(U32.is_lt(c, 92880), c)

def gc.n3630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3630(U32.is_lt(c, 92917), c)
    case False{}:
      gc.n3631(U32.is_lt(c, 92928), c)

def gc.n3633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Po"

def gc.n3634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Lm"

def gc.n3635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3633(U32.is_lt(c, 92983), c)
    case False{}:
      gc.n3634(U32.is_lt(c, 92992), c)

def gc.n3636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3632(U32.is_lt(c, 92918), c)
    case False{}:
      gc.n3635(U32.is_lt(c, 92988), c)

def gc.n3637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3629(U32.is_lt(c, 92864), c)
    case False{}:
      gc.n3636(U32.is_lt(c, 92976), c)

def gc.n3638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "So"

def gc.n3639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Nd"

def gc.n3640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3638(U32.is_lt(c, 92997), c)
    case False{}:
      gc.n3639(U32.is_lt(c, 93008), c)

def gc.n3641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n3642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3641(U32.is_lt(c, 93019), c)
    case False{}:
      gc.n3642(U32.is_lt(c, 93027), c)

def gc.n3644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3640(U32.is_lt(c, 92998), c)
    case False{}:
      gc.n3643(U32.is_lt(c, 93026), c)

def gc.n3645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n3647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3645(U32.is_lt(c, 93053), c)
    case False{}:
      gc.n3646(U32.is_lt(c, 93504), c)

def gc.n3648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n3649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Nd"

def gc.n3650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3648(U32.is_lt(c, 93547), c)
    case False{}:
      gc.n3649(U32.is_lt(c, 93552), c)

def gc.n3651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3647(U32.is_lt(c, 93072), c)
    case False{}:
      gc.n3650(U32.is_lt(c, 93549), c)

def gc.n3652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3644(U32.is_lt(c, 93018), c)
    case False{}:
      gc.n3651(U32.is_lt(c, 93507), c)

def gc.n3653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3637(U32.is_lt(c, 92912), c)
    case False{}:
      gc.n3652(U32.is_lt(c, 93048), c)

def gc.n3654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "No"

def gc.n3656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3654(U32.is_lt(c, 93760), c)
    case False{}:
      gc.n3655(U32.is_lt(c, 93824), c)

def gc.n3657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3657(U32.is_lt(c, 93851), c)
    case False{}:
      gc.n3658(U32.is_lt(c, 93881), c)

def gc.n3660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3656(U32.is_lt(c, 93792), c)
    case False{}:
      gc.n3659(U32.is_lt(c, 93856), c)

def gc.n3661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n3662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3661(U32.is_lt(c, 93908), c)
    case False{}:
      gc.n3662(U32.is_lt(c, 94027), c)

def gc.n3664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cn"

def gc.n3666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3664(U32.is_lt(c, 94032), c)
    case False{}:
      gc.n3665(U32.is_lt(c, 94088), c)

def gc.n3667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3663(U32.is_lt(c, 93952), c)
    case False{}:
      gc.n3666(U32.is_lt(c, 94033), c)

def gc.n3668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3660(U32.is_lt(c, 93847), c)
    case False{}:
      gc.n3667(U32.is_lt(c, 94031), c)

def gc.n3669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lm"

def gc.n3670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n3671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3669(U32.is_lt(c, 94099), c)
    case False{}:
      gc.n3670(U32.is_lt(c, 94176), c)

def gc.n3672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Lm"

def gc.n3673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3672(U32.is_lt(c, 94179), c)
    case False{}:
      gc.n3673(U32.is_lt(c, 94181), c)

def gc.n3675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3671(U32.is_lt(c, 94112), c)
    case False{}:
      gc.n3674(U32.is_lt(c, 94180), c)

def gc.n3676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Lm"

def gc.n3677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nl"
    case False{}:
      "Cn"

def gc.n3678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3676(U32.is_lt(c, 94194), c)
    case False{}:
      gc.n3677(U32.is_lt(c, 94199), c)

def gc.n3679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3679(U32.is_lt(c, 101590), c)
    case False{}:
      gc.n3680(U32.is_lt(c, 101663), c)

def gc.n3682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3678(U32.is_lt(c, 94196), c)
    case False{}:
      gc.n3681(U32.is_lt(c, 101631), c)

def gc.n3683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3675(U32.is_lt(c, 94178), c)
    case False{}:
      gc.n3682(U32.is_lt(c, 94208), c)

def gc.n3684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3668(U32.is_lt(c, 93883), c)
    case False{}:
      gc.n3683(U32.is_lt(c, 94192), c)

def gc.n3685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3653(U32.is_lt(c, 92996), c)
    case False{}:
      gc.n3684(U32.is_lt(c, 94095), c)

def gc.n3686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3686(U32.is_lt(c, 101875), c)
    case False{}:
      gc.n3687(U32.is_lt(c, 110580), c)

def gc.n3689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3689(U32.is_lt(c, 110588), c)
    case False{}:
      gc.n3690(U32.is_lt(c, 110591), c)

def gc.n3692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3688(U32.is_lt(c, 110576), c)
    case False{}:
      gc.n3691(U32.is_lt(c, 110589), c)

def gc.n3693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3693(U32.is_lt(c, 110883), c)
    case False{}:
      gc.n3694(U32.is_lt(c, 110899), c)

def gc.n3696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3696(U32.is_lt(c, 110931), c)
    case False{}:
      gc.n3697(U32.is_lt(c, 110934), c)

def gc.n3699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3695(U32.is_lt(c, 110898), c)
    case False{}:
      gc.n3698(U32.is_lt(c, 110933), c)

def gc.n3700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3692(U32.is_lt(c, 110581), c)
    case False{}:
      gc.n3699(U32.is_lt(c, 110928), c)

def gc.n3701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3701(U32.is_lt(c, 110952), c)
    case False{}:
      gc.n3702(U32.is_lt(c, 111356), c)

def gc.n3704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3704(U32.is_lt(c, 113771), c)
    case False{}:
      gc.n3705(U32.is_lt(c, 113789), c)

def gc.n3707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3703(U32.is_lt(c, 110960), c)
    case False{}:
      gc.n3706(U32.is_lt(c, 113776), c)

def gc.n3708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3708(U32.is_lt(c, 113801), c)
    case False{}:
      gc.n3709(U32.is_lt(c, 113818), c)

def gc.n3711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n3712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cf"

def gc.n3713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3711(U32.is_lt(c, 113821), c)
    case False{}:
      gc.n3712(U32.is_lt(c, 113824), c)

def gc.n3714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3710(U32.is_lt(c, 113808), c)
    case False{}:
      gc.n3713(U32.is_lt(c, 113823), c)

def gc.n3715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3707(U32.is_lt(c, 113664), c)
    case False{}:
      gc.n3714(U32.is_lt(c, 113820), c)

def gc.n3716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3700(U32.is_lt(c, 110592), c)
    case False{}:
      gc.n3715(U32.is_lt(c, 113792), c)

def gc.n3717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n3718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "So"

def gc.n3719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3717(U32.is_lt(c, 117760), c)
    case False{}:
      gc.n3718(U32.is_lt(c, 118010), c)

def gc.n3720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n3721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n3722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3720(U32.is_lt(c, 118016), c)
    case False{}:
      gc.n3721(U32.is_lt(c, 118458), c)

def gc.n3723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3719(U32.is_lt(c, 118000), c)
    case False{}:
      gc.n3722(U32.is_lt(c, 118452), c)

def gc.n3724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n3725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Cn"

def gc.n3726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3724(U32.is_lt(c, 118496), c)
    case False{}:
      gc.n3725(U32.is_lt(c, 118513), c)

def gc.n3727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3727(U32.is_lt(c, 118574), c)
    case False{}:
      gc.n3728(U32.is_lt(c, 118599), c)

def gc.n3730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3726(U32.is_lt(c, 118512), c)
    case False{}:
      gc.n3729(U32.is_lt(c, 118576), c)

def gc.n3731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3723(U32.is_lt(c, 118013), c)
    case False{}:
      gc.n3730(U32.is_lt(c, 118528), c)

def gc.n3732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3732(U32.is_lt(c, 118724), c)
    case False{}:
      gc.n3733(U32.is_lt(c, 119030), c)

def gc.n3735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mc"

def gc.n3737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3735(U32.is_lt(c, 119079), c)
    case False{}:
      gc.n3736(U32.is_lt(c, 119141), c)

def gc.n3738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3734(U32.is_lt(c, 118784), c)
    case False{}:
      gc.n3737(U32.is_lt(c, 119081), c)

def gc.n3739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mc"
    case False{}:
      "Cf"

def gc.n3741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3739(U32.is_lt(c, 119146), c)
    case False{}:
      gc.n3740(U32.is_lt(c, 119155), c)

def gc.n3742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n3744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      gc.n3743(U32.is_lt(c, 119210), c)

def gc.n3745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3742(U32.is_lt(c, 119171), c)
    case False{}:
      gc.n3744(U32.is_lt(c, 119180), c)

def gc.n3746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3741(U32.is_lt(c, 119149), c)
    case False{}:
      gc.n3745(U32.is_lt(c, 119173), c)

def gc.n3747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3738(U32.is_lt(c, 119040), c)
    case False{}:
      gc.n3746(U32.is_lt(c, 119163), c)

def gc.n3748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3731(U32.is_lt(c, 118481), c)
    case False{}:
      gc.n3747(U32.is_lt(c, 119143), c)

def gc.n3749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3716(U32.is_lt(c, 110948), c)
    case False{}:
      gc.n3748(U32.is_lt(c, 118608), c)

def gc.n3750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3685(U32.is_lt(c, 93562), c)
    case False{}:
      gc.n3749(U32.is_lt(c, 113828), c)

def gc.n3751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Mn"

def gc.n3753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3751(U32.is_lt(c, 119275), c)
    case False{}:
      gc.n3752(U32.is_lt(c, 119362), c)

def gc.n3754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3754(U32.is_lt(c, 119366), c)
    case False{}:
      gc.n3755(U32.is_lt(c, 119508), c)

def gc.n3757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3753(U32.is_lt(c, 119296), c)
    case False{}:
      gc.n3756(U32.is_lt(c, 119488), c)

def gc.n3758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n3760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3758(U32.is_lt(c, 119540), c)
    case False{}:
      gc.n3759(U32.is_lt(c, 119639), c)

def gc.n3761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3761(U32.is_lt(c, 119673), c)
    case False{}:
      gc.n3762(U32.is_lt(c, 119834), c)

def gc.n3764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3760(U32.is_lt(c, 119552), c)
    case False{}:
      gc.n3763(U32.is_lt(c, 119808), c)

def gc.n3765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3757(U32.is_lt(c, 119365), c)
    case False{}:
      gc.n3764(U32.is_lt(c, 119648), c)

def gc.n3766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3766(U32.is_lt(c, 119886), c)
    case False{}:
      gc.n3767(U32.is_lt(c, 119894), c)

def gc.n3769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3769(U32.is_lt(c, 119938), c)
    case False{}:
      gc.n3770(U32.is_lt(c, 119965), c)

def gc.n3772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3768(U32.is_lt(c, 119893), c)
    case False{}:
      gc.n3771(U32.is_lt(c, 119964), c)

def gc.n3773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3773(U32.is_lt(c, 119968), c)
    case False{}:
      gc.n3774(U32.is_lt(c, 119971), c)

def gc.n3776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3776(U32.is_lt(c, 119975), c)
    case False{}:
      gc.n3777(U32.is_lt(c, 119981), c)

def gc.n3779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3775(U32.is_lt(c, 119970), c)
    case False{}:
      gc.n3778(U32.is_lt(c, 119977), c)

def gc.n3780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3772(U32.is_lt(c, 119912), c)
    case False{}:
      gc.n3779(U32.is_lt(c, 119973), c)

def gc.n3781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3765(U32.is_lt(c, 119520), c)
    case False{}:
      gc.n3780(U32.is_lt(c, 119966), c)

def gc.n3782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3782(U32.is_lt(c, 119990), c)
    case False{}:
      gc.n3783(U32.is_lt(c, 119995), c)

def gc.n3785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3785(U32.is_lt(c, 119997), c)
    case False{}:
      gc.n3786(U32.is_lt(c, 120005), c)

def gc.n3788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3784(U32.is_lt(c, 119994), c)
    case False{}:
      gc.n3787(U32.is_lt(c, 120004), c)

def gc.n3789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Ll"

def gc.n3790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3789(U32.is_lt(c, 120042), c)
    case False{}:
      gc.n3790(U32.is_lt(c, 120070), c)

def gc.n3792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3792(U32.is_lt(c, 120075), c)
    case False{}:
      gc.n3793(U32.is_lt(c, 120085), c)

def gc.n3795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3791(U32.is_lt(c, 120068), c)
    case False{}:
      gc.n3794(U32.is_lt(c, 120077), c)

def gc.n3796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3788(U32.is_lt(c, 119996), c)
    case False{}:
      gc.n3795(U32.is_lt(c, 120071), c)

def gc.n3797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Cn"

def gc.n3798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3797(U32.is_lt(c, 120093), c)
    case False{}:
      gc.n3798(U32.is_lt(c, 120120), c)

def gc.n3800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3800(U32.is_lt(c, 120123), c)
    case False{}:
      gc.n3801(U32.is_lt(c, 120128), c)

def gc.n3803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3799(U32.is_lt(c, 120094), c)
    case False{}:
      gc.n3802(U32.is_lt(c, 120127), c)

def gc.n3804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3804(U32.is_lt(c, 120134), c)
    case False{}:
      gc.n3805(U32.is_lt(c, 120138), c)

def gc.n3807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Ll"

def gc.n3808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      gc.n3808(U32.is_lt(c, 120224), c)

def gc.n3810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3807(U32.is_lt(c, 120146), c)
    case False{}:
      gc.n3809(U32.is_lt(c, 120198), c)

def gc.n3811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3806(U32.is_lt(c, 120135), c)
    case False{}:
      gc.n3810(U32.is_lt(c, 120172), c)

def gc.n3812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3803(U32.is_lt(c, 120122), c)
    case False{}:
      gc.n3811(U32.is_lt(c, 120145), c)

def gc.n3813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3796(U32.is_lt(c, 120016), c)
    case False{}:
      gc.n3812(U32.is_lt(c, 120133), c)

def gc.n3814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3781(U32.is_lt(c, 119860), c)
    case False{}:
      gc.n3813(U32.is_lt(c, 120086), c)

def gc.n3815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3815(U32.is_lt(c, 120276), c)
    case False{}:
      gc.n3816(U32.is_lt(c, 120328), c)

def gc.n3818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3818(U32.is_lt(c, 120380), c)
    case False{}:
      gc.n3819(U32.is_lt(c, 120432), c)

def gc.n3821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3817(U32.is_lt(c, 120302), c)
    case False{}:
      gc.n3820(U32.is_lt(c, 120406), c)

def gc.n3822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n3823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Sm"

def gc.n3824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3822(U32.is_lt(c, 120486), c)
    case False{}:
      gc.n3823(U32.is_lt(c, 120513), c)

def gc.n3825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Sm"

def gc.n3826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3825(U32.is_lt(c, 120539), c)
    case False{}:
      gc.n3826(U32.is_lt(c, 120546), c)

def gc.n3828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3824(U32.is_lt(c, 120488), c)
    case False{}:
      gc.n3827(U32.is_lt(c, 120540), c)

def gc.n3829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3821(U32.is_lt(c, 120354), c)
    case False{}:
      gc.n3828(U32.is_lt(c, 120514), c)

def gc.n3830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ll"

def gc.n3831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ll"

def gc.n3832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3830(U32.is_lt(c, 120572), c)
    case False{}:
      gc.n3831(U32.is_lt(c, 120598), c)

def gc.n3833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Sm"

def gc.n3834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Sm"

def gc.n3835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3833(U32.is_lt(c, 120629), c)
    case False{}:
      gc.n3834(U32.is_lt(c, 120655), c)

def gc.n3836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3832(U32.is_lt(c, 120597), c)
    case False{}:
      gc.n3835(U32.is_lt(c, 120630), c)

def gc.n3837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ll"

def gc.n3839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3837(U32.is_lt(c, 120662), c)
    case False{}:
      gc.n3838(U32.is_lt(c, 120688), c)

def gc.n3840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sm"
    case False{}:
      "Ll"

def gc.n3841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lu"
    case False{}:
      "Sm"

def gc.n3842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3840(U32.is_lt(c, 120714), c)
    case False{}:
      gc.n3841(U32.is_lt(c, 120745), c)

def gc.n3843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3839(U32.is_lt(c, 120687), c)
    case False{}:
      gc.n3842(U32.is_lt(c, 120720), c)

def gc.n3844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3836(U32.is_lt(c, 120604), c)
    case False{}:
      gc.n3843(U32.is_lt(c, 120713), c)

def gc.n3845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3829(U32.is_lt(c, 120458), c)
    case False{}:
      gc.n3844(U32.is_lt(c, 120656), c)

def gc.n3846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Sm"

def gc.n3847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lu"

def gc.n3848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3846(U32.is_lt(c, 120771), c)
    case False{}:
      gc.n3847(U32.is_lt(c, 120778), c)

def gc.n3849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n3850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "So"

def gc.n3851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3849(U32.is_lt(c, 120780), c)
    case False{}:
      gc.n3850(U32.is_lt(c, 120832), c)

def gc.n3852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3848(U32.is_lt(c, 120772), c)
    case False{}:
      gc.n3851(U32.is_lt(c, 120782), c)

def gc.n3853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3853(U32.is_lt(c, 121399), c)
    case False{}:
      gc.n3854(U32.is_lt(c, 121453), c)

def gc.n3856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "So"

def gc.n3858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3856(U32.is_lt(c, 121462), c)
    case False{}:
      gc.n3857(U32.is_lt(c, 121477), c)

def gc.n3859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3855(U32.is_lt(c, 121403), c)
    case False{}:
      gc.n3858(U32.is_lt(c, 121476), c)

def gc.n3860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3852(U32.is_lt(c, 120779), c)
    case False{}:
      gc.n3859(U32.is_lt(c, 121461), c)

def gc.n3861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3861(U32.is_lt(c, 121484), c)
    case False{}:
      gc.n3862(U32.is_lt(c, 121504), c)

def gc.n3864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Lo"

def gc.n3866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3864(U32.is_lt(c, 121520), c)
    case False{}:
      gc.n3865(U32.is_lt(c, 122634), c)

def gc.n3867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3863(U32.is_lt(c, 121499), c)
    case False{}:
      gc.n3866(U32.is_lt(c, 122624), c)

def gc.n3868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n3869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Cn"

def gc.n3870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3868(U32.is_lt(c, 122655), c)
    case False{}:
      gc.n3869(U32.is_lt(c, 122667), c)

def gc.n3871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      gc.n3872(U32.is_lt(c, 122907), c)

def gc.n3874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3871(U32.is_lt(c, 122887), c)
    case False{}:
      gc.n3873(U32.is_lt(c, 122905), c)

def gc.n3875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3870(U32.is_lt(c, 122661), c)
    case False{}:
      gc.n3874(U32.is_lt(c, 122888), c)

def gc.n3876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3867(U32.is_lt(c, 121505), c)
    case False{}:
      gc.n3875(U32.is_lt(c, 122880), c)

def gc.n3877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3860(U32.is_lt(c, 121344), c)
    case False{}:
      gc.n3876(U32.is_lt(c, 122635), c)

def gc.n3878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3845(U32.is_lt(c, 120571), c)
    case False{}:
      gc.n3877(U32.is_lt(c, 121479), c)

def gc.n3879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3814(U32.is_lt(c, 119982), c)
    case False{}:
      gc.n3878(U32.is_lt(c, 120746), c)

def gc.n3880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3750(U32.is_lt(c, 101760), c)
    case False{}:
      gc.n3879(U32.is_lt(c, 120250), c)

def gc.n3881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3881(U32.is_lt(c, 122915), c)
    case False{}:
      gc.n3882(U32.is_lt(c, 122918), c)

def gc.n3884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lm"

def gc.n3885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3884(U32.is_lt(c, 122928), c)
    case False{}:
      gc.n3885(U32.is_lt(c, 123023), c)

def gc.n3887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3883(U32.is_lt(c, 122917), c)
    case False{}:
      gc.n3886(U32.is_lt(c, 122990), c)

def gc.n3888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n3890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3888(U32.is_lt(c, 123136), c)
    case False{}:
      gc.n3889(U32.is_lt(c, 123184), c)

def gc.n3891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3891(U32.is_lt(c, 123198), c)
    case False{}:
      gc.n3892(U32.is_lt(c, 123210), c)

def gc.n3894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3890(U32.is_lt(c, 123181), c)
    case False{}:
      gc.n3893(U32.is_lt(c, 123200), c)

def gc.n3895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3887(U32.is_lt(c, 122923), c)
    case False{}:
      gc.n3894(U32.is_lt(c, 123191), c)

def gc.n3896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "So"

def gc.n3897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3896(U32.is_lt(c, 123215), c)
    case False{}:
      gc.n3897(U32.is_lt(c, 123536), c)

def gc.n3899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Cn"

def gc.n3900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3899(U32.is_lt(c, 123567), c)
    case False{}:
      gc.n3900(U32.is_lt(c, 123628), c)

def gc.n3902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3898(U32.is_lt(c, 123216), c)
    case False{}:
      gc.n3901(U32.is_lt(c, 123584), c)

def gc.n3903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Sc"
    case False{}:
      "Cn"

def gc.n3905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3903(U32.is_lt(c, 123642), c)
    case False{}:
      gc.n3904(U32.is_lt(c, 123648), c)

def gc.n3906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Lm"

def gc.n3907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Nd"

def gc.n3908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3906(U32.is_lt(c, 124139), c)
    case False{}:
      gc.n3907(U32.is_lt(c, 124144), c)

def gc.n3909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3905(U32.is_lt(c, 123647), c)
    case False{}:
      gc.n3908(U32.is_lt(c, 124140), c)

def gc.n3910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3902(U32.is_lt(c, 123566), c)
    case False{}:
      gc.n3909(U32.is_lt(c, 124112), c)

def gc.n3911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3895(U32.is_lt(c, 123024), c)
    case False{}:
      gc.n3910(U32.is_lt(c, 123632), c)

def gc.n3912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Mn"
    case False{}:
      "Lo"

def gc.n3914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3912(U32.is_lt(c, 124368), c)
    case False{}:
      gc.n3913(U32.is_lt(c, 124400), c)

def gc.n3915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3915(U32.is_lt(c, 124411), c)
    case False{}:
      gc.n3916(U32.is_lt(c, 124416), c)

def gc.n3918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3914(U32.is_lt(c, 124398), c)
    case False{}:
      gc.n3917(U32.is_lt(c, 124415), c)

def gc.n3919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3919(U32.is_lt(c, 124639), c)
    case False{}:
      gc.n3920(U32.is_lt(c, 124643), c)

def gc.n3922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3922(U32.is_lt(c, 124646), c)
    case False{}:
      gc.n3923(U32.is_lt(c, 124654), c)

def gc.n3925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3921(U32.is_lt(c, 124640), c)
    case False{}:
      gc.n3924(U32.is_lt(c, 124647), c)

def gc.n3926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3918(U32.is_lt(c, 124401), c)
    case False{}:
      gc.n3925(U32.is_lt(c, 124644), c)

def gc.n3927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Mn"

def gc.n3928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n3929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3927(U32.is_lt(c, 124661), c)
    case False{}:
      gc.n3928(U32.is_lt(c, 124670), c)

def gc.n3930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3930(U32.is_lt(c, 124672), c)
    case False{}:
      gc.n3931(U32.is_lt(c, 124903), c)

def gc.n3933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3929(U32.is_lt(c, 124662), c)
    case False{}:
      gc.n3932(U32.is_lt(c, 124896), c)

def gc.n3934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3934(U32.is_lt(c, 124908), c)
    case False{}:
      gc.n3935(U32.is_lt(c, 124911), c)

def gc.n3937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3937(U32.is_lt(c, 124927), c)
    case False{}:
      gc.n3938(U32.is_lt(c, 125125), c)

def gc.n3940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3936(U32.is_lt(c, 124909), c)
    case False{}:
      gc.n3939(U32.is_lt(c, 124928), c)

def gc.n3941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3933(U32.is_lt(c, 124671), c)
    case False{}:
      gc.n3940(U32.is_lt(c, 124912), c)

def gc.n3942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3926(U32.is_lt(c, 124608), c)
    case False{}:
      gc.n3941(U32.is_lt(c, 124904), c)

def gc.n3943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3911(U32.is_lt(c, 123214), c)
    case False{}:
      gc.n3942(U32.is_lt(c, 124656), c)

def gc.n3944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Mn"

def gc.n3945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lu"

def gc.n3946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3944(U32.is_lt(c, 125136), c)
    case False{}:
      gc.n3945(U32.is_lt(c, 125184), c)

def gc.n3947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Ll"
    case False{}:
      "Mn"

def gc.n3948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lm"
    case False{}:
      "Cn"

def gc.n3949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3947(U32.is_lt(c, 125252), c)
    case False{}:
      gc.n3948(U32.is_lt(c, 125260), c)

def gc.n3950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3946(U32.is_lt(c, 125143), c)
    case False{}:
      gc.n3949(U32.is_lt(c, 125259), c)

def gc.n3951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "Cn"

def gc.n3952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Po"
    case False{}:
      "Cn"

def gc.n3953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3951(U32.is_lt(c, 125274), c)
    case False{}:
      gc.n3952(U32.is_lt(c, 125280), c)

def gc.n3954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n3955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Sc"

def gc.n3956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3954(U32.is_lt(c, 126124), c)
    case False{}:
      gc.n3955(U32.is_lt(c, 126128), c)

def gc.n3957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3953(U32.is_lt(c, 125278), c)
    case False{}:
      gc.n3956(U32.is_lt(c, 126125), c)

def gc.n3958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3950(U32.is_lt(c, 125218), c)
    case False{}:
      gc.n3957(U32.is_lt(c, 126065), c)

def gc.n3959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "So"

def gc.n3961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3959(U32.is_lt(c, 126133), c)
    case False{}:
      gc.n3960(U32.is_lt(c, 126254), c)

def gc.n3962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "No"
    case False{}:
      "Cn"

def gc.n3963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3962(U32.is_lt(c, 126270), c)
    case False{}:
      gc.n3963(U32.is_lt(c, 126468), c)

def gc.n3965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3961(U32.is_lt(c, 126209), c)
    case False{}:
      gc.n3964(U32.is_lt(c, 126464), c)

def gc.n3966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3966(U32.is_lt(c, 126496), c)
    case False{}:
      gc.n3967(U32.is_lt(c, 126499), c)

def gc.n3969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3969(U32.is_lt(c, 126501), c)
    case False{}:
      gc.n3970(U32.is_lt(c, 126504), c)

def gc.n3972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3968(U32.is_lt(c, 126497), c)
    case False{}:
      gc.n3971(U32.is_lt(c, 126503), c)

def gc.n3973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3965(U32.is_lt(c, 126255), c)
    case False{}:
      gc.n3972(U32.is_lt(c, 126500), c)

def gc.n3974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3958(U32.is_lt(c, 125264), c)
    case False{}:
      gc.n3973(U32.is_lt(c, 126469), c)

def gc.n3975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3975(U32.is_lt(c, 126515), c)
    case False{}:
      gc.n3976(U32.is_lt(c, 126520), c)

def gc.n3978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3978(U32.is_lt(c, 126522), c)
    case False{}:
      gc.n3979(U32.is_lt(c, 126524), c)

def gc.n3981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3977(U32.is_lt(c, 126516), c)
    case False{}:
      gc.n3980(U32.is_lt(c, 126523), c)

def gc.n3982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3982(U32.is_lt(c, 126531), c)
    case False{}:
      gc.n3983(U32.is_lt(c, 126536), c)

def gc.n3985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3985(U32.is_lt(c, 126538), c)
    case False{}:
      gc.n3986(U32.is_lt(c, 126540), c)

def gc.n3988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3984(U32.is_lt(c, 126535), c)
    case False{}:
      gc.n3987(U32.is_lt(c, 126539), c)

def gc.n3989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3981(U32.is_lt(c, 126521), c)
    case False{}:
      gc.n3988(U32.is_lt(c, 126537), c)

def gc.n3990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3990(U32.is_lt(c, 126544), c)
    case False{}:
      gc.n3991(U32.is_lt(c, 126547), c)

def gc.n3993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3993(U32.is_lt(c, 126549), c)
    case False{}:
      gc.n3994(U32.is_lt(c, 126552), c)

def gc.n3996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3992(U32.is_lt(c, 126545), c)
    case False{}:
      gc.n3995(U32.is_lt(c, 126551), c)

def gc.n3997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n3999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3997(U32.is_lt(c, 126554), c)
    case False{}:
      gc.n3998(U32.is_lt(c, 126556), c)

def gc.n4000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      "Cn"

def gc.n4001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Lo"
    case False{}:
      gc.n4001(U32.is_lt(c, 126561), c)

def gc.n4003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4000(U32.is_lt(c, 126558), c)
    case False{}:
      gc.n4002(U32.is_lt(c, 126560), c)

def gc.n4004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3999(U32.is_lt(c, 126555), c)
    case False{}:
      gc.n4003(U32.is_lt(c, 126559), c)

def gc.n4005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3996(U32.is_lt(c, 126548), c)
    case False{}:
      gc.n4004(U32.is_lt(c, 126557), c)

def gc.n4006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3989(U32.is_lt(c, 126530), c)
    case False{}:
      gc.n4005(U32.is_lt(c, 126553), c)

def gc.n4007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3974(U32.is_lt(c, 126129), c)
    case False{}:
      gc.n4006(U32.is_lt(c, 126541), c)

def gc.n4008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3943(U32.is_lt(c, 124154), c)
    case False{}:
      gc.n4007(U32.is_lt(c, 126505), c)

def gc.n4009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4009(U32.is_lt(c, 126564), c)
    case False{}:
      gc.n4010(U32.is_lt(c, 126567), c)

def gc.n4012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4012(U32.is_lt(c, 126572), c)
    case False{}:
      gc.n4013(U32.is_lt(c, 126580), c)

def gc.n4015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4011(U32.is_lt(c, 126565), c)
    case False{}:
      gc.n4014(U32.is_lt(c, 126579), c)

def gc.n4016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4016(U32.is_lt(c, 126585), c)
    case False{}:
      gc.n4017(U32.is_lt(c, 126590), c)

def gc.n4019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4019(U32.is_lt(c, 126592), c)
    case False{}:
      gc.n4020(U32.is_lt(c, 126603), c)

def gc.n4022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4018(U32.is_lt(c, 126589), c)
    case False{}:
      gc.n4021(U32.is_lt(c, 126602), c)

def gc.n4023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4015(U32.is_lt(c, 126571), c)
    case False{}:
      gc.n4022(U32.is_lt(c, 126591), c)

def gc.n4024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4024(U32.is_lt(c, 126625), c)
    case False{}:
      gc.n4025(U32.is_lt(c, 126629), c)

def gc.n4027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sm"

def gc.n4029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4027(U32.is_lt(c, 126635), c)
    case False{}:
      gc.n4028(U32.is_lt(c, 126704), c)

def gc.n4030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4026(U32.is_lt(c, 126628), c)
    case False{}:
      gc.n4029(U32.is_lt(c, 126652), c)

def gc.n4031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4031(U32.is_lt(c, 126976), c)
    case False{}:
      gc.n4032(U32.is_lt(c, 127024), c)

def gc.n4034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4034(U32.is_lt(c, 127136), c)
    case False{}:
      gc.n4035(U32.is_lt(c, 127153), c)

def gc.n4037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4033(U32.is_lt(c, 127020), c)
    case False{}:
      gc.n4036(U32.is_lt(c, 127151), c)

def gc.n4038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4030(U32.is_lt(c, 126634), c)
    case False{}:
      gc.n4037(U32.is_lt(c, 127124), c)

def gc.n4039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4023(U32.is_lt(c, 126584), c)
    case False{}:
      gc.n4038(U32.is_lt(c, 126706), c)

def gc.n4040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4040(U32.is_lt(c, 127169), c)
    case False{}:
      gc.n4041(U32.is_lt(c, 127185), c)

def gc.n4043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "No"

def gc.n4044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4043(U32.is_lt(c, 127232), c)
    case False{}:
      gc.n4044(U32.is_lt(c, 127406), c)

def gc.n4046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4042(U32.is_lt(c, 127184), c)
    case False{}:
      gc.n4045(U32.is_lt(c, 127245), c)

def gc.n4047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4047(U32.is_lt(c, 127491), c)
    case False{}:
      gc.n4048(U32.is_lt(c, 127548), c)

def gc.n4050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4050(U32.is_lt(c, 127561), c)
    case False{}:
      gc.n4051(U32.is_lt(c, 127570), c)

def gc.n4053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4049(U32.is_lt(c, 127504), c)
    case False{}:
      gc.n4052(U32.is_lt(c, 127568), c)

def gc.n4054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4046(U32.is_lt(c, 127222), c)
    case False{}:
      gc.n4053(U32.is_lt(c, 127552), c)

def gc.n4055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Sk"

def gc.n4057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4055(U32.is_lt(c, 127590), c)
    case False{}:
      gc.n4056(U32.is_lt(c, 127995), c)

def gc.n4058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4058(U32.is_lt(c, 128729), c)
    case False{}:
      gc.n4059(U32.is_lt(c, 128749), c)

def gc.n4061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4057(U32.is_lt(c, 127744), c)
    case False{}:
      gc.n4060(U32.is_lt(c, 128732), c)

def gc.n4062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4062(U32.is_lt(c, 128765), c)
    case False{}:
      gc.n4063(U32.is_lt(c, 128986), c)

def gc.n4065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      "Cn"

def gc.n4066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "So"
    case False{}:
      gc.n4066(U32.is_lt(c, 129024), c)

def gc.n4068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4065(U32.is_lt(c, 129004), c)
    case False{}:
      gc.n4067(U32.is_lt(c, 129009), c)

def gc.n4069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4064(U32.is_lt(c, 128768), c)
    case False{}:
      gc.n4068(U32.is_lt(c, 129008), c)

def gc.n4070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4061(U32.is_lt(c, 128000), c)
    case False{}:
      gc.n4069(U32.is_lt(c, 128992), c)

def gc.n4071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4054(U32.is_lt(c, 127462), c)
    case False{}:
      gc.n4070(U32.is_lt(c, 128752), c)

def gc.n4072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4039(U32.is_lt(c, 126620), c)
    case False{}:
      gc.n4071(U32.is_lt(c, 127584), c)

def gc.n4073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4073(U32.is_lt(c, 129040), c)
    case False{}:
      gc.n4074(U32.is_lt(c, 129104), c)

def gc.n4076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4076(U32.is_lt(c, 129120), c)
    case False{}:
      gc.n4077(U32.is_lt(c, 129168), c)

def gc.n4079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4075(U32.is_lt(c, 129096), c)
    case False{}:
      gc.n4078(U32.is_lt(c, 129160), c)

def gc.n4080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4080(U32.is_lt(c, 129200), c)
    case False{}:
      gc.n4081(U32.is_lt(c, 129216), c)

def gc.n4083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Sm"

def gc.n4084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4083(U32.is_lt(c, 129232), c)
    case False{}:
      gc.n4084(U32.is_lt(c, 129280), c)

def gc.n4086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4082(U32.is_lt(c, 129212), c)
    case False{}:
      gc.n4085(U32.is_lt(c, 129241), c)

def gc.n4087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4079(U32.is_lt(c, 129114), c)
    case False{}:
      gc.n4086(U32.is_lt(c, 129218), c)

def gc.n4088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4088(U32.is_lt(c, 129632), c)
    case False{}:
      gc.n4089(U32.is_lt(c, 129648), c)

def gc.n4091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4091(U32.is_lt(c, 129664), c)
    case False{}:
      gc.n4092(U32.is_lt(c, 129678), c)

def gc.n4094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4090(U32.is_lt(c, 129646), c)
    case False{}:
      gc.n4093(U32.is_lt(c, 129675), c)

def gc.n4095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4095(U32.is_lt(c, 129736), c)
    case False{}:
      gc.n4096(U32.is_lt(c, 129741), c)

def gc.n4098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4098(U32.is_lt(c, 129759), c)
    case False{}:
      gc.n4099(U32.is_lt(c, 129775), c)

def gc.n4101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4097(U32.is_lt(c, 129737), c)
    case False{}:
      gc.n4100(U32.is_lt(c, 129771), c)

def gc.n4102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4094(U32.is_lt(c, 129661), c)
    case False{}:
      gc.n4101(U32.is_lt(c, 129757), c)

def gc.n4103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4087(U32.is_lt(c, 129198), c)
    case False{}:
      gc.n4102(U32.is_lt(c, 129735), c)

def gc.n4104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "So"

def gc.n4106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4104(U32.is_lt(c, 129792), c)
    case False{}:
      gc.n4105(U32.is_lt(c, 129940), c)

def gc.n4107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Nd"
    case False{}:
      "So"

def gc.n4108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4107(U32.is_lt(c, 130042), c)
    case False{}:
      gc.n4108(U32.is_lt(c, 131072), c)

def gc.n4110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4106(U32.is_lt(c, 129939), c)
    case False{}:
      gc.n4109(U32.is_lt(c, 130043), c)

def gc.n4111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4111(U32.is_lt(c, 173824), c)
    case False{}:
      gc.n4112(U32.is_lt(c, 178208), c)

def gc.n4114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4114(U32.is_lt(c, 183984), c)
    case False{}:
      gc.n4115(U32.is_lt(c, 191472), c)

def gc.n4117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4113(U32.is_lt(c, 178206), c)
    case False{}:
      gc.n4116(U32.is_lt(c, 191457), c)

def gc.n4118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4110(U32.is_lt(c, 130032), c)
    case False{}:
      gc.n4117(U32.is_lt(c, 183982), c)

def gc.n4119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4119(U32.is_lt(c, 194560), c)
    case False{}:
      gc.n4120(U32.is_lt(c, 196608), c)

def gc.n4122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Lo"

def gc.n4123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Cf"

def gc.n4124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4122(U32.is_lt(c, 201552), c)
    case False{}:
      gc.n4123(U32.is_lt(c, 917505), c)

def gc.n4125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4121(U32.is_lt(c, 195102), c)
    case False{}:
      gc.n4124(U32.is_lt(c, 210042), c)

def gc.n4126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Cf"

def gc.n4127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Mn"

def gc.n4128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4126(U32.is_lt(c, 917536), c)
    case False{}:
      gc.n4127(U32.is_lt(c, 917760), c)

def gc.n4129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      "Co"

def gc.n4130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Co"
    case False{}:
      "Cn"

def gc.n4131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "Cn"
    case False{}:
      gc.n4130(U32.is_lt(c, 1114110), c)

def gc.n4132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4129(U32.is_lt(c, 983040), c)
    case False{}:
      gc.n4131(U32.is_lt(c, 1048576), c)

def gc.n4133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4128(U32.is_lt(c, 917632), c)
    case False{}:
      gc.n4132(U32.is_lt(c, 1048574), c)

def gc.n4134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4125(U32.is_lt(c, 201547), c)
    case False{}:
      gc.n4133(U32.is_lt(c, 918000), c)

def gc.n4135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4118(U32.is_lt(c, 173792), c)
    case False{}:
      gc.n4134(U32.is_lt(c, 917506), c)

def gc.n4136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4103(U32.is_lt(c, 129624), c)
    case False{}:
      gc.n4135(U32.is_lt(c, 192094), c)

def gc.n4137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4072(U32.is_lt(c, 127168), c)
    case False{}:
      gc.n4136(U32.is_lt(c, 129785), c)

def gc.n4138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n4008(U32.is_lt(c, 125127), c)
    case False{}:
      gc.n4137(U32.is_lt(c, 129036), c)

def gc.n4139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3880(U32.is_lt(c, 119214), c)
    case False{}:
      gc.n4138(U32.is_lt(c, 126563), c)

def gc.n4140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3622(U32.is_lt(c, 71229), c)
    case False{}:
      gc.n4139(U32.is_lt(c, 122914), c)

def gc.n4141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n3105(U32.is_lt(c, 43003), c)
    case False{}:
      gc.n4140(U32.is_lt(c, 92778), c)

def gc.n4142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      gc.n2070(U32.is_lt(c, 3387), c)
    case False{}:
      gc.n4141(U32.is_lt(c, 68944), c)

def gc(+c: U32) -> String:
  gc.n4142(U32.is_lt(c, 11429), c)

def ccc.n0(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n1(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      232
    case False{}:
      220

def ccc.n2(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n0(U32.is_lt(c, 768), c)
    case False{}:
      ccc.n1(U32.is_lt(c, 790), c)

def ccc.n3(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      232
    case False{}:
      216

def ccc.n4(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      202
    case False{}:
      220

def ccc.n5(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n4(U32.is_lt(c, 803), c)

def ccc.n6(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n3(U32.is_lt(c, 795), c)
    case False{}:
      ccc.n5(U32.is_lt(c, 801), c)

def ccc.n7(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n2(U32.is_lt(c, 789), c)
    case False{}:
      ccc.n6(U32.is_lt(c, 796), c)

def ccc.n8(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      202
    case False{}:
      220

def ccc.n9(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      220

def ccc.n10(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n8(U32.is_lt(c, 809), c)
    case False{}:
      ccc.n9(U32.is_lt(c, 825), c)

def ccc.n11(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      240

def ccc.n12(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n13(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n12(U32.is_lt(c, 842), c)

def ccc.n14(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n11(U32.is_lt(c, 837), c)
    case False{}:
      ccc.n13(U32.is_lt(c, 839), c)

def ccc.n15(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n10(U32.is_lt(c, 820), c)
    case False{}:
      ccc.n14(U32.is_lt(c, 838), c)

def ccc.n16(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n7(U32.is_lt(c, 794), c)
    case False{}:
      ccc.n15(U32.is_lt(c, 829), c)

def ccc.n17(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n18(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n19(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n17(U32.is_lt(c, 847), c)
    case False{}:
      ccc.n18(U32.is_lt(c, 851), c)

def ccc.n20(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      232

def ccc.n21(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      233

def ccc.n22(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n21(U32.is_lt(c, 860), c)

def ccc.n23(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n20(U32.is_lt(c, 856), c)
    case False{}:
      ccc.n22(U32.is_lt(c, 859), c)

def ccc.n24(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n19(U32.is_lt(c, 848), c)
    case False{}:
      ccc.n23(U32.is_lt(c, 857), c)

def ccc.n25(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      234
    case False{}:
      233

def ccc.n26(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      233
    case False{}:
      230

def ccc.n27(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      234
    case False{}:
      ccc.n26(U32.is_lt(c, 867), c)

def ccc.n28(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n25(U32.is_lt(c, 863), c)
    case False{}:
      ccc.n27(U32.is_lt(c, 866), c)

def ccc.n29(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n30(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n31(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n30(U32.is_lt(c, 1426), c)

def ccc.n32(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n29(U32.is_lt(c, 1155), c)
    case False{}:
      ccc.n31(U32.is_lt(c, 1425), c)

def ccc.n33(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n28(U32.is_lt(c, 864), c)
    case False{}:
      ccc.n32(U32.is_lt(c, 1160), c)

def ccc.n34(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n24(U32.is_lt(c, 855), c)
    case False{}:
      ccc.n33(U32.is_lt(c, 880), c)

def ccc.n35(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n16(U32.is_lt(c, 807), c)
    case False{}:
      ccc.n34(U32.is_lt(c, 861), c)

def ccc.n36(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n37(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      222
    case False{}:
      220

def ccc.n38(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n36(U32.is_lt(c, 1431), c)
    case False{}:
      ccc.n37(U32.is_lt(c, 1435), c)

def ccc.n39(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n40(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n41(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n40(U32.is_lt(c, 1451), c)

def ccc.n42(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n39(U32.is_lt(c, 1442), c)
    case False{}:
      ccc.n41(U32.is_lt(c, 1450), c)

def ccc.n43(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n38(U32.is_lt(c, 1434), c)
    case False{}:
      ccc.n42(U32.is_lt(c, 1448), c)

def ccc.n44(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      222
    case False{}:
      228

def ccc.n45(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      10
    case False{}:
      11

def ccc.n46(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n45(U32.is_lt(c, 1457), c)

def ccc.n47(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n44(U32.is_lt(c, 1454), c)
    case False{}:
      ccc.n46(U32.is_lt(c, 1456), c)

def ccc.n48(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def ccc.n49(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      15
    case False{}:
      16

def ccc.n50(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      14
    case False{}:
      ccc.n49(U32.is_lt(c, 1462), c)

def ccc.n51(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n48(U32.is_lt(c, 1459), c)
    case False{}:
      ccc.n50(U32.is_lt(c, 1461), c)

def ccc.n52(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n47(U32.is_lt(c, 1455), c)
    case False{}:
      ccc.n51(U32.is_lt(c, 1460), c)

def ccc.n53(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n43(U32.is_lt(c, 1436), c)
    case False{}:
      ccc.n52(U32.is_lt(c, 1458), c)

def ccc.n54(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      17
    case False{}:
      18

def ccc.n55(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      19
    case False{}:
      20

def ccc.n56(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n54(U32.is_lt(c, 1464), c)
    case False{}:
      ccc.n55(U32.is_lt(c, 1467), c)

def ccc.n57(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      21
    case False{}:
      22

def ccc.n58(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      23
    case False{}:
      0

def ccc.n59(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n58(U32.is_lt(c, 1472), c)

def ccc.n60(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n57(U32.is_lt(c, 1469), c)
    case False{}:
      ccc.n59(U32.is_lt(c, 1471), c)

def ccc.n61(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n56(U32.is_lt(c, 1465), c)
    case False{}:
      ccc.n60(U32.is_lt(c, 1470), c)

def ccc.n62(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      24
    case False{}:
      25

def ccc.n63(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n64(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n63(U32.is_lt(c, 1477), c)

def ccc.n65(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n62(U32.is_lt(c, 1474), c)
    case False{}:
      ccc.n64(U32.is_lt(c, 1476), c)

def ccc.n66(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      18

def ccc.n67(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      30

def ccc.n68(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n67(U32.is_lt(c, 1560), c)

def ccc.n69(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n66(U32.is_lt(c, 1479), c)
    case False{}:
      ccc.n68(U32.is_lt(c, 1552), c)

def ccc.n70(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n65(U32.is_lt(c, 1475), c)
    case False{}:
      ccc.n69(U32.is_lt(c, 1480), c)

def ccc.n71(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n61(U32.is_lt(c, 1468), c)
    case False{}:
      ccc.n70(U32.is_lt(c, 1478), c)

def ccc.n72(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n53(U32.is_lt(c, 1453), c)
    case False{}:
      ccc.n71(U32.is_lt(c, 1473), c)

def ccc.n73(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n35(U32.is_lt(c, 845), c)
    case False{}:
      ccc.n72(U32.is_lt(c, 1463), c)

def ccc.n74(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      31
    case False{}:
      32

def ccc.n75(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      27

def ccc.n76(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n74(U32.is_lt(c, 1562), c)
    case False{}:
      ccc.n75(U32.is_lt(c, 1611), c)

def ccc.n77(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      28
    case False{}:
      29

def ccc.n78(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      31
    case False{}:
      32

def ccc.n79(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      30
    case False{}:
      ccc.n78(U32.is_lt(c, 1616), c)

def ccc.n80(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n77(U32.is_lt(c, 1613), c)
    case False{}:
      ccc.n79(U32.is_lt(c, 1615), c)

def ccc.n81(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n76(U32.is_lt(c, 1563), c)
    case False{}:
      ccc.n80(U32.is_lt(c, 1614), c)

def ccc.n82(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      33
    case False{}:
      34

def ccc.n83(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n84(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n83(U32.is_lt(c, 1623), c)

def ccc.n85(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n82(U32.is_lt(c, 1618), c)
    case False{}:
      ccc.n84(U32.is_lt(c, 1621), c)

def ccc.n86(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n87(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      35

def ccc.n88(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n87(U32.is_lt(c, 1648), c)

def ccc.n89(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n86(U32.is_lt(c, 1629), c)
    case False{}:
      ccc.n88(U32.is_lt(c, 1632), c)

def ccc.n90(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n85(U32.is_lt(c, 1619), c)
    case False{}:
      ccc.n89(U32.is_lt(c, 1631), c)

def ccc.n91(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n81(U32.is_lt(c, 1612), c)
    case False{}:
      ccc.n90(U32.is_lt(c, 1628), c)

def ccc.n92(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n93(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n94(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n92(U32.is_lt(c, 1750), c)
    case False{}:
      ccc.n93(U32.is_lt(c, 1759), c)

def ccc.n95(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n96(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n97(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n96(U32.is_lt(c, 1769), c)

def ccc.n98(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n95(U32.is_lt(c, 1764), c)
    case False{}:
      ccc.n97(U32.is_lt(c, 1767), c)

def ccc.n99(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n94(U32.is_lt(c, 1757), c)
    case False{}:
      ccc.n98(U32.is_lt(c, 1765), c)

def ccc.n100(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n101(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      36

def ccc.n102(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n101(U32.is_lt(c, 1809), c)

def ccc.n103(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n100(U32.is_lt(c, 1771), c)
    case False{}:
      ccc.n102(U32.is_lt(c, 1774), c)

def ccc.n104(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n105(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n106(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n105(U32.is_lt(c, 1844), c)

def ccc.n107(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n104(U32.is_lt(c, 1840), c)
    case False{}:
      ccc.n106(U32.is_lt(c, 1842), c)

def ccc.n108(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n103(U32.is_lt(c, 1773), c)
    case False{}:
      ccc.n107(U32.is_lt(c, 1841), c)

def ccc.n109(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n99(U32.is_lt(c, 1763), c)
    case False{}:
      ccc.n108(U32.is_lt(c, 1810), c)

def ccc.n110(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n91(U32.is_lt(c, 1617), c)
    case False{}:
      ccc.n109(U32.is_lt(c, 1770), c)

def ccc.n111(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n112(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n113(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n111(U32.is_lt(c, 1847), c)
    case False{}:
      ccc.n112(U32.is_lt(c, 1851), c)

def ccc.n114(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n115(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n116(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n115(U32.is_lt(c, 1859), c)

def ccc.n117(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n114(U32.is_lt(c, 1854), c)
    case False{}:
      ccc.n116(U32.is_lt(c, 1858), c)

def ccc.n118(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n113(U32.is_lt(c, 1850), c)
    case False{}:
      ccc.n117(U32.is_lt(c, 1855), c)

def ccc.n119(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n120(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n121(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n120(U32.is_lt(c, 1864), c)

def ccc.n122(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n119(U32.is_lt(c, 1861), c)
    case False{}:
      ccc.n121(U32.is_lt(c, 1863), c)

def ccc.n123(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n124(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n125(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n124(U32.is_lt(c, 2035), c)

def ccc.n126(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n123(U32.is_lt(c, 1867), c)
    case False{}:
      ccc.n125(U32.is_lt(c, 2034), c)

def ccc.n127(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n122(U32.is_lt(c, 1862), c)
    case False{}:
      ccc.n126(U32.is_lt(c, 2027), c)

def ccc.n128(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n118(U32.is_lt(c, 1853), c)
    case False{}:
      ccc.n127(U32.is_lt(c, 1865), c)

def ccc.n129(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n130(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n131(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n129(U32.is_lt(c, 2045), c)
    case False{}:
      ccc.n130(U32.is_lt(c, 2070), c)

def ccc.n132(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n133(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n134(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n133(U32.is_lt(c, 2088), c)

def ccc.n135(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n132(U32.is_lt(c, 2075), c)
    case False{}:
      ccc.n134(U32.is_lt(c, 2085), c)

def ccc.n136(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n131(U32.is_lt(c, 2046), c)
    case False{}:
      ccc.n135(U32.is_lt(c, 2084), c)

def ccc.n137(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n138(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n139(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n138(U32.is_lt(c, 2199), c)

def ccc.n140(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n137(U32.is_lt(c, 2094), c)
    case False{}:
      ccc.n139(U32.is_lt(c, 2140), c)

def ccc.n141(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n142(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n143(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n142(U32.is_lt(c, 2255), c)

def ccc.n144(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n141(U32.is_lt(c, 2204), c)
    case False{}:
      ccc.n143(U32.is_lt(c, 2250), c)

def ccc.n145(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n140(U32.is_lt(c, 2137), c)
    case False{}:
      ccc.n144(U32.is_lt(c, 2208), c)

def ccc.n146(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n136(U32.is_lt(c, 2074), c)
    case False{}:
      ccc.n145(U32.is_lt(c, 2201), c)

def ccc.n147(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n128(U32.is_lt(c, 1860), c)
    case False{}:
      ccc.n146(U32.is_lt(c, 2089), c)

def ccc.n148(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n110(U32.is_lt(c, 1649), c)
    case False{}:
      ccc.n147(U32.is_lt(c, 2036), c)

def ccc.n149(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n73(U32.is_lt(c, 1430), c)
    case False{}:
      ccc.n148(U32.is_lt(c, 1845), c)

def ccc.n150(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n151(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n152(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n150(U32.is_lt(c, 2274), c)
    case False{}:
      ccc.n151(U32.is_lt(c, 2276), c)

def ccc.n153(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n154(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n155(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n154(U32.is_lt(c, 2285), c)

def ccc.n156(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n153(U32.is_lt(c, 2279), c)
    case False{}:
      ccc.n155(U32.is_lt(c, 2282), c)

def ccc.n157(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n152(U32.is_lt(c, 2275), c)
    case False{}:
      ccc.n156(U32.is_lt(c, 2281), c)

def ccc.n158(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      27
    case False{}:
      28

def ccc.n159(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n160(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      29
    case False{}:
      ccc.n159(U32.is_lt(c, 2294), c)

def ccc.n161(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n158(U32.is_lt(c, 2289), c)
    case False{}:
      ccc.n160(U32.is_lt(c, 2291), c)

def ccc.n162(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n163(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n164(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n163(U32.is_lt(c, 2364), c)

def ccc.n165(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n162(U32.is_lt(c, 2297), c)
    case False{}:
      ccc.n164(U32.is_lt(c, 2304), c)

def ccc.n166(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n161(U32.is_lt(c, 2290), c)
    case False{}:
      ccc.n165(U32.is_lt(c, 2299), c)

def ccc.n167(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n157(U32.is_lt(c, 2278), c)
    case False{}:
      ccc.n166(U32.is_lt(c, 2295), c)

def ccc.n168(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n169(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n170(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n168(U32.is_lt(c, 2381), c)
    case False{}:
      ccc.n169(U32.is_lt(c, 2385), c)

def ccc.n171(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n172(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n173(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n172(U32.is_lt(c, 2493), c)

def ccc.n174(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n171(U32.is_lt(c, 2387), c)
    case False{}:
      ccc.n173(U32.is_lt(c, 2492), c)

def ccc.n175(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n170(U32.is_lt(c, 2382), c)
    case False{}:
      ccc.n174(U32.is_lt(c, 2389), c)

def ccc.n176(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n177(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n178(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n177(U32.is_lt(c, 2620), c)

def ccc.n179(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n176(U32.is_lt(c, 2510), c)
    case False{}:
      ccc.n178(U32.is_lt(c, 2559), c)

def ccc.n180(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n181(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n182(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n181(U32.is_lt(c, 2749), c)

def ccc.n183(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n180(U32.is_lt(c, 2637), c)
    case False{}:
      ccc.n182(U32.is_lt(c, 2748), c)

def ccc.n184(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n179(U32.is_lt(c, 2558), c)
    case False{}:
      ccc.n183(U32.is_lt(c, 2638), c)

def ccc.n185(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n175(U32.is_lt(c, 2386), c)
    case False{}:
      ccc.n184(U32.is_lt(c, 2621), c)

def ccc.n186(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n167(U32.is_lt(c, 2288), c)
    case False{}:
      ccc.n185(U32.is_lt(c, 2509), c)

def ccc.n187(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n188(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n189(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n187(U32.is_lt(c, 2766), c)
    case False{}:
      ccc.n188(U32.is_lt(c, 2877), c)

def ccc.n190(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n191(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n192(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n191(U32.is_lt(c, 3132), c)

def ccc.n193(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n190(U32.is_lt(c, 2894), c)
    case False{}:
      ccc.n192(U32.is_lt(c, 3022), c)

def ccc.n194(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n189(U32.is_lt(c, 2876), c)
    case False{}:
      ccc.n193(U32.is_lt(c, 3021), c)

def ccc.n195(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n196(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      84
    case False{}:
      91

def ccc.n197(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n196(U32.is_lt(c, 3158), c)

def ccc.n198(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n195(U32.is_lt(c, 3149), c)
    case False{}:
      ccc.n197(U32.is_lt(c, 3157), c)

def ccc.n199(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n200(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n201(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n200(U32.is_lt(c, 3278), c)

def ccc.n202(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n199(U32.is_lt(c, 3260), c)
    case False{}:
      ccc.n201(U32.is_lt(c, 3277), c)

def ccc.n203(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n198(U32.is_lt(c, 3150), c)
    case False{}:
      ccc.n202(U32.is_lt(c, 3261), c)

def ccc.n204(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n194(U32.is_lt(c, 2893), c)
    case False{}:
      ccc.n203(U32.is_lt(c, 3159), c)

def ccc.n205(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n206(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n207(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n205(U32.is_lt(c, 3389), c)
    case False{}:
      ccc.n206(U32.is_lt(c, 3406), c)

def ccc.n208(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n209(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n210(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      103
    case False{}:
      ccc.n209(U32.is_lt(c, 3643), c)

def ccc.n211(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n208(U32.is_lt(c, 3531), c)
    case False{}:
      ccc.n210(U32.is_lt(c, 3642), c)

def ccc.n212(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n207(U32.is_lt(c, 3405), c)
    case False{}:
      ccc.n211(U32.is_lt(c, 3640), c)

def ccc.n213(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      107
    case False{}:
      0

def ccc.n214(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n215(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      118
    case False{}:
      ccc.n214(U32.is_lt(c, 3771), c)

def ccc.n216(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n213(U32.is_lt(c, 3660), c)
    case False{}:
      ccc.n215(U32.is_lt(c, 3770), c)

def ccc.n217(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      122
    case False{}:
      0

def ccc.n218(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n219(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n218(U32.is_lt(c, 3893), c)

def ccc.n220(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n217(U32.is_lt(c, 3788), c)
    case False{}:
      ccc.n219(U32.is_lt(c, 3866), c)

def ccc.n221(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n216(U32.is_lt(c, 3768), c)
    case False{}:
      ccc.n220(U32.is_lt(c, 3864), c)

def ccc.n222(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n212(U32.is_lt(c, 3530), c)
    case False{}:
      ccc.n221(U32.is_lt(c, 3784), c)

def ccc.n223(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n204(U32.is_lt(c, 3133), c)
    case False{}:
      ccc.n222(U32.is_lt(c, 3656), c)

def ccc.n224(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n186(U32.is_lt(c, 2365), c)
    case False{}:
      ccc.n223(U32.is_lt(c, 3387), c)

def ccc.n225(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n226(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      216

def ccc.n227(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n225(U32.is_lt(c, 3895), c)
    case False{}:
      ccc.n226(U32.is_lt(c, 3897), c)

def ccc.n228(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      129

def ccc.n229(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      132

def ccc.n230(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      130
    case False{}:
      ccc.n229(U32.is_lt(c, 3956), c)

def ccc.n231(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n228(U32.is_lt(c, 3953), c)
    case False{}:
      ccc.n230(U32.is_lt(c, 3955), c)

def ccc.n232(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n227(U32.is_lt(c, 3896), c)
    case False{}:
      ccc.n231(U32.is_lt(c, 3954), c)

def ccc.n233(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      130

def ccc.n234(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      130
    case False{}:
      0

def ccc.n235(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n234(U32.is_lt(c, 3969), c)

def ccc.n236(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n233(U32.is_lt(c, 3962), c)
    case False{}:
      ccc.n235(U32.is_lt(c, 3968), c)

def ccc.n237(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      9

def ccc.n238(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n239(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n238(U32.is_lt(c, 3976), c)

def ccc.n240(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n237(U32.is_lt(c, 3972), c)
    case False{}:
      ccc.n239(U32.is_lt(c, 3974), c)

def ccc.n241(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n236(U32.is_lt(c, 3966), c)
    case False{}:
      ccc.n240(U32.is_lt(c, 3973), c)

def ccc.n242(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n232(U32.is_lt(c, 3898), c)
    case False{}:
      ccc.n241(U32.is_lt(c, 3970), c)

def ccc.n243(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n244(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n245(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n243(U32.is_lt(c, 4039), c)
    case False{}:
      ccc.n244(U32.is_lt(c, 4152), c)

def ccc.n246(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n247(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n248(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n247(U32.is_lt(c, 4957), c)

def ccc.n249(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n246(U32.is_lt(c, 4155), c)
    case False{}:
      ccc.n248(U32.is_lt(c, 4238), c)

def ccc.n250(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n245(U32.is_lt(c, 4151), c)
    case False{}:
      ccc.n249(U32.is_lt(c, 4237), c)

def ccc.n251(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n252(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n253(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n252(U32.is_lt(c, 5941), c)

def ccc.n254(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n251(U32.is_lt(c, 5908), c)
    case False{}:
      ccc.n253(U32.is_lt(c, 5940), c)

def ccc.n255(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n256(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      228

def ccc.n257(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n256(U32.is_lt(c, 6313), c)

def ccc.n258(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n255(U32.is_lt(c, 6099), c)
    case False{}:
      ccc.n257(U32.is_lt(c, 6110), c)

def ccc.n259(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n254(U32.is_lt(c, 5910), c)
    case False{}:
      ccc.n258(U32.is_lt(c, 6109), c)

def ccc.n260(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n250(U32.is_lt(c, 4153), c)
    case False{}:
      ccc.n259(U32.is_lt(c, 6098), c)

def ccc.n261(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n242(U32.is_lt(c, 3957), c)
    case False{}:
      ccc.n260(U32.is_lt(c, 4960), c)

def ccc.n262(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      222

def ccc.n263(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n264(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n262(U32.is_lt(c, 6457), c)
    case False{}:
      ccc.n263(U32.is_lt(c, 6459), c)

def ccc.n265(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n266(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n267(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n266(U32.is_lt(c, 6752), c)

def ccc.n268(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n265(U32.is_lt(c, 6679), c)
    case False{}:
      ccc.n267(U32.is_lt(c, 6681), c)

def ccc.n269(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n264(U32.is_lt(c, 6458), c)
    case False{}:
      ccc.n268(U32.is_lt(c, 6680), c)

def ccc.n270(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n271(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n272(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n271(U32.is_lt(c, 6784), c)

def ccc.n273(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n270(U32.is_lt(c, 6773), c)
    case False{}:
      ccc.n272(U32.is_lt(c, 6783), c)

def ccc.n274(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n275(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n276(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n275(U32.is_lt(c, 6846), c)

def ccc.n277(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n274(U32.is_lt(c, 6837), c)
    case False{}:
      ccc.n276(U32.is_lt(c, 6845), c)

def ccc.n278(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n273(U32.is_lt(c, 6781), c)
    case False{}:
      ccc.n277(U32.is_lt(c, 6843), c)

def ccc.n279(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n269(U32.is_lt(c, 6460), c)
    case False{}:
      ccc.n278(U32.is_lt(c, 6832), c)

def ccc.n280(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n281(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n282(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n280(U32.is_lt(c, 6849), c)
    case False{}:
      ccc.n281(U32.is_lt(c, 6853), c)

def ccc.n283(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n284(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n285(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n284(U32.is_lt(c, 6880), c)

def ccc.n286(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n283(U32.is_lt(c, 6859), c)
    case False{}:
      ccc.n285(U32.is_lt(c, 6878), c)

def ccc.n287(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n282(U32.is_lt(c, 6851), c)
    case False{}:
      ccc.n286(U32.is_lt(c, 6877), c)

def ccc.n288(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n289(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n290(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      234
    case False{}:
      ccc.n289(U32.is_lt(c, 6964), c)

def ccc.n291(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n288(U32.is_lt(c, 6887), c)
    case False{}:
      ccc.n290(U32.is_lt(c, 6892), c)

def ccc.n292(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n293(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n294(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n293(U32.is_lt(c, 7020), c)

def ccc.n295(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n292(U32.is_lt(c, 6980), c)
    case False{}:
      ccc.n294(U32.is_lt(c, 7019), c)

def ccc.n296(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n291(U32.is_lt(c, 6891), c)
    case False{}:
      ccc.n295(U32.is_lt(c, 6981), c)

def ccc.n297(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n287(U32.is_lt(c, 6858), c)
    case False{}:
      ccc.n296(U32.is_lt(c, 6965), c)

def ccc.n298(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n279(U32.is_lt(c, 6753), c)
    case False{}:
      ccc.n297(U32.is_lt(c, 6886), c)

def ccc.n299(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n261(U32.is_lt(c, 4038), c)
    case False{}:
      ccc.n298(U32.is_lt(c, 6847), c)

def ccc.n300(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n224(U32.is_lt(c, 2765), c)
    case False{}:
      ccc.n299(U32.is_lt(c, 6314), c)

def ccc.n301(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n149(U32.is_lt(c, 1561), c)
    case False{}:
      ccc.n300(U32.is_lt(c, 3894), c)

def ccc.n302(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n303(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n304(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n302(U32.is_lt(c, 7028), c)
    case False{}:
      ccc.n303(U32.is_lt(c, 7084), c)

def ccc.n305(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n306(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n307(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n306(U32.is_lt(c, 7223), c)

def ccc.n308(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n305(U32.is_lt(c, 7143), c)
    case False{}:
      ccc.n307(U32.is_lt(c, 7156), c)

def ccc.n309(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n304(U32.is_lt(c, 7082), c)
    case False{}:
      ccc.n308(U32.is_lt(c, 7154), c)

def ccc.n310(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n311(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      1

def ccc.n312(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n310(U32.is_lt(c, 7376), c)
    case False{}:
      ccc.n311(U32.is_lt(c, 7380), c)

def ccc.n313(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n314(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n315(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n314(U32.is_lt(c, 7393), c)

def ccc.n316(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n313(U32.is_lt(c, 7386), c)
    case False{}:
      ccc.n315(U32.is_lt(c, 7392), c)

def ccc.n317(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n312(U32.is_lt(c, 7379), c)
    case False{}:
      ccc.n316(U32.is_lt(c, 7388), c)

def ccc.n318(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n309(U32.is_lt(c, 7142), c)
    case False{}:
      ccc.n317(U32.is_lt(c, 7381), c)

def ccc.n319(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      0

def ccc.n320(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n321(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n319(U32.is_lt(c, 7401), c)
    case False{}:
      ccc.n320(U32.is_lt(c, 7406), c)

def ccc.n322(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n323(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n324(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n323(U32.is_lt(c, 7616), c)

def ccc.n325(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n322(U32.is_lt(c, 7413), c)
    case False{}:
      ccc.n324(U32.is_lt(c, 7418), c)

def ccc.n326(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n321(U32.is_lt(c, 7405), c)
    case False{}:
      ccc.n325(U32.is_lt(c, 7416), c)

def ccc.n327(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n328(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      234

def ccc.n329(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n328(U32.is_lt(c, 7629), c)

def ccc.n330(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n327(U32.is_lt(c, 7619), c)
    case False{}:
      ccc.n329(U32.is_lt(c, 7627), c)

def ccc.n331(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      214
    case False{}:
      220

def ccc.n332(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      232

def ccc.n333(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      202
    case False{}:
      ccc.n332(U32.is_lt(c, 7670), c)

def ccc.n334(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n331(U32.is_lt(c, 7631), c)
    case False{}:
      ccc.n333(U32.is_lt(c, 7633), c)

def ccc.n335(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n330(U32.is_lt(c, 7626), c)
    case False{}:
      ccc.n334(U32.is_lt(c, 7632), c)

def ccc.n336(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n326(U32.is_lt(c, 7412), c)
    case False{}:
      ccc.n335(U32.is_lt(c, 7630), c)

def ccc.n337(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n318(U32.is_lt(c, 7224), c)
    case False{}:
      ccc.n336(U32.is_lt(c, 7618), c)

def ccc.n338(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      228
    case False{}:
      220

def ccc.n339(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      218
    case False{}:
      230

def ccc.n340(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n338(U32.is_lt(c, 7673), c)
    case False{}:
      ccc.n339(U32.is_lt(c, 7675), c)

def ccc.n341(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      233
    case False{}:
      220

def ccc.n342(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n343(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n342(U32.is_lt(c, 7680), c)

def ccc.n344(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n341(U32.is_lt(c, 7677), c)
    case False{}:
      ccc.n343(U32.is_lt(c, 7679), c)

def ccc.n345(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n340(U32.is_lt(c, 7674), c)
    case False{}:
      ccc.n344(U32.is_lt(c, 7678), c)

def ccc.n346(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      1

def ccc.n347(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      230

def ccc.n348(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n347(U32.is_lt(c, 8411), c)

def ccc.n349(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n346(U32.is_lt(c, 8402), c)
    case False{}:
      ccc.n348(U32.is_lt(c, 8408), c)

def ccc.n350(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n351(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      230

def ccc.n352(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n351(U32.is_lt(c, 8423), c)

def ccc.n353(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n350(U32.is_lt(c, 8417), c)
    case False{}:
      ccc.n352(U32.is_lt(c, 8421), c)

def ccc.n354(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n349(U32.is_lt(c, 8404), c)
    case False{}:
      ccc.n353(U32.is_lt(c, 8418), c)

def ccc.n355(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n345(U32.is_lt(c, 7676), c)
    case False{}:
      ccc.n354(U32.is_lt(c, 8413), c)

def ccc.n356(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n357(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      220

def ccc.n358(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n356(U32.is_lt(c, 8425), c)
    case False{}:
      ccc.n357(U32.is_lt(c, 8428), c)

def ccc.n359(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n360(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n361(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n360(U32.is_lt(c, 11647), c)

def ccc.n362(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n359(U32.is_lt(c, 8433), c)
    case False{}:
      ccc.n361(U32.is_lt(c, 11506), c)

def ccc.n363(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n358(U32.is_lt(c, 8426), c)
    case False{}:
      ccc.n362(U32.is_lt(c, 11503), c)

def ccc.n364(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n365(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      218
    case False{}:
      228

def ccc.n366(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n365(U32.is_lt(c, 12331), c)

def ccc.n367(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n364(U32.is_lt(c, 11744), c)
    case False{}:
      ccc.n366(U32.is_lt(c, 12330), c)

def ccc.n368(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      232
    case False{}:
      222

def ccc.n369(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def ccc.n370(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      224
    case False{}:
      ccc.n369(U32.is_lt(c, 12441), c)

def ccc.n371(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n368(U32.is_lt(c, 12333), c)
    case False{}:
      ccc.n370(U32.is_lt(c, 12336), c)

def ccc.n372(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n367(U32.is_lt(c, 11776), c)
    case False{}:
      ccc.n371(U32.is_lt(c, 12334), c)

def ccc.n373(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n363(U32.is_lt(c, 8432), c)
    case False{}:
      ccc.n372(U32.is_lt(c, 12332), c)

def ccc.n374(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n355(U32.is_lt(c, 8400), c)
    case False{}:
      ccc.n373(U32.is_lt(c, 11648), c)

def ccc.n375(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n337(U32.is_lt(c, 7394), c)
    case False{}:
      ccc.n374(U32.is_lt(c, 8424), c)

def ccc.n376(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n377(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n378(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n376(U32.is_lt(c, 42607), c)
    case False{}:
      ccc.n377(U32.is_lt(c, 42612), c)

def ccc.n379(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n380(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n381(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n380(U32.is_lt(c, 42738), c)

def ccc.n382(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n379(U32.is_lt(c, 42654), c)
    case False{}:
      ccc.n381(U32.is_lt(c, 42736), c)

def ccc.n383(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n378(U32.is_lt(c, 42608), c)
    case False{}:
      ccc.n382(U32.is_lt(c, 42656), c)

def ccc.n384(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n385(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n386(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n385(U32.is_lt(c, 43204), c)

def ccc.n387(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n384(U32.is_lt(c, 43015), c)
    case False{}:
      ccc.n386(U32.is_lt(c, 43053), c)

def ccc.n388(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n389(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n390(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n389(U32.is_lt(c, 43310), c)

def ccc.n391(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n388(U32.is_lt(c, 43232), c)
    case False{}:
      ccc.n390(U32.is_lt(c, 43307), c)

def ccc.n392(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n387(U32.is_lt(c, 43052), c)
    case False{}:
      ccc.n391(U32.is_lt(c, 43250), c)

def ccc.n393(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n383(U32.is_lt(c, 42622), c)
    case False{}:
      ccc.n392(U32.is_lt(c, 43205), c)

def ccc.n394(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n395(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n396(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n394(U32.is_lt(c, 43348), c)
    case False{}:
      ccc.n395(U32.is_lt(c, 43444), c)

def ccc.n397(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n398(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n399(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n398(U32.is_lt(c, 43698), c)

def ccc.n400(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n397(U32.is_lt(c, 43457), c)
    case False{}:
      ccc.n399(U32.is_lt(c, 43697), c)

def ccc.n401(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n396(U32.is_lt(c, 43443), c)
    case False{}:
      ccc.n400(U32.is_lt(c, 43696), c)

def ccc.n402(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n403(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n404(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n403(U32.is_lt(c, 43710), c)

def ccc.n405(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n402(U32.is_lt(c, 43701), c)
    case False{}:
      ccc.n404(U32.is_lt(c, 43705), c)

def ccc.n406(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n407(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n408(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n407(U32.is_lt(c, 43767), c)

def ccc.n409(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n406(U32.is_lt(c, 43713), c)
    case False{}:
      ccc.n408(U32.is_lt(c, 43766), c)

def ccc.n410(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n405(U32.is_lt(c, 43703), c)
    case False{}:
      ccc.n409(U32.is_lt(c, 43714), c)

def ccc.n411(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n401(U32.is_lt(c, 43456), c)
    case False{}:
      ccc.n410(U32.is_lt(c, 43712), c)

def ccc.n412(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n393(U32.is_lt(c, 43014), c)
    case False{}:
      ccc.n411(U32.is_lt(c, 43700), c)

def ccc.n413(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n414(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      26
    case False{}:
      0

def ccc.n415(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n413(U32.is_lt(c, 44014), c)
    case False{}:
      ccc.n414(U32.is_lt(c, 64287), c)

def ccc.n416(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n417(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n418(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n417(U32.is_lt(c, 66045), c)

def ccc.n419(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n416(U32.is_lt(c, 65063), c)
    case False{}:
      ccc.n418(U32.is_lt(c, 65072), c)

def ccc.n420(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n415(U32.is_lt(c, 64286), c)
    case False{}:
      ccc.n419(U32.is_lt(c, 65070), c)

def ccc.n421(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n422(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n423(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n422(U32.is_lt(c, 66427), c)

def ccc.n424(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n421(U32.is_lt(c, 66272), c)
    case False{}:
      ccc.n423(U32.is_lt(c, 66422), c)

def ccc.n425(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n426(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n427(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n426(U32.is_lt(c, 68152), c)

def ccc.n428(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n425(U32.is_lt(c, 68110), c)
    case False{}:
      ccc.n427(U32.is_lt(c, 68112), c)

def ccc.n429(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n424(U32.is_lt(c, 66273), c)
    case False{}:
      ccc.n428(U32.is_lt(c, 68111), c)

def ccc.n430(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n420(U32.is_lt(c, 65056), c)
    case False{}:
      ccc.n429(U32.is_lt(c, 68109), c)

def ccc.n431(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      220

def ccc.n432(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n433(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n431(U32.is_lt(c, 68154), c)
    case False{}:
      ccc.n432(U32.is_lt(c, 68159), c)

def ccc.n434(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n435(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n436(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n435(U32.is_lt(c, 68900), c)

def ccc.n437(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n434(U32.is_lt(c, 68325), c)
    case False{}:
      ccc.n436(U32.is_lt(c, 68327), c)

def ccc.n438(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n433(U32.is_lt(c, 68155), c)
    case False{}:
      ccc.n437(U32.is_lt(c, 68326), c)

def ccc.n439(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n440(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n441(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n440(U32.is_lt(c, 69293), c)

def ccc.n442(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n439(U32.is_lt(c, 68969), c)
    case False{}:
      ccc.n441(U32.is_lt(c, 69291), c)

def ccc.n443(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n444(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n445(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n444(U32.is_lt(c, 69446), c)

def ccc.n446(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n443(U32.is_lt(c, 69372), c)
    case False{}:
      ccc.n445(U32.is_lt(c, 69376), c)

def ccc.n447(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n442(U32.is_lt(c, 68974), c)
    case False{}:
      ccc.n446(U32.is_lt(c, 69373), c)

def ccc.n448(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n438(U32.is_lt(c, 68160), c)
    case False{}:
      ccc.n447(U32.is_lt(c, 69370), c)

def ccc.n449(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n430(U32.is_lt(c, 66046), c)
    case False{}:
      ccc.n448(U32.is_lt(c, 68904), c)

def ccc.n450(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n412(U32.is_lt(c, 43347), c)
    case False{}:
      ccc.n449(U32.is_lt(c, 68153), c)

def ccc.n451(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n375(U32.is_lt(c, 7671), c)
    case False{}:
      ccc.n450(U32.is_lt(c, 44013), c)

def ccc.n452(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n453(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n454(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n452(U32.is_lt(c, 69451), c)
    case False{}:
      ccc.n453(U32.is_lt(c, 69453), c)

def ccc.n455(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n456(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n457(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      ccc.n456(U32.is_lt(c, 69509), c)

def ccc.n458(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n455(U32.is_lt(c, 69506), c)
    case False{}:
      ccc.n457(U32.is_lt(c, 69508), c)

def ccc.n459(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n454(U32.is_lt(c, 69452), c)
    case False{}:
      ccc.n458(U32.is_lt(c, 69507), c)

def ccc.n460(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n461(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n462(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n461(U32.is_lt(c, 69745), c)

def ccc.n463(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n460(U32.is_lt(c, 69702), c)
    case False{}:
      ccc.n462(U32.is_lt(c, 69744), c)

def ccc.n464(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n465(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n466(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n465(U32.is_lt(c, 69819), c)

def ccc.n467(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n464(U32.is_lt(c, 69760), c)
    case False{}:
      ccc.n466(U32.is_lt(c, 69818), c)

def ccc.n468(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n463(U32.is_lt(c, 69703), c)
    case False{}:
      ccc.n467(U32.is_lt(c, 69817), c)

def ccc.n469(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n459(U32.is_lt(c, 69457), c)
    case False{}:
      ccc.n468(U32.is_lt(c, 69759), c)

def ccc.n470(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n471(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n472(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n470(U32.is_lt(c, 69891), c)
    case False{}:
      ccc.n471(U32.is_lt(c, 69941), c)

def ccc.n473(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n474(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n475(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n474(U32.is_lt(c, 70090), c)

def ccc.n476(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n473(U32.is_lt(c, 70004), c)
    case False{}:
      ccc.n475(U32.is_lt(c, 70081), c)

def ccc.n477(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n472(U32.is_lt(c, 69939), c)
    case False{}:
      ccc.n476(U32.is_lt(c, 70080), c)

def ccc.n478(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n479(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n480(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      ccc.n479(U32.is_lt(c, 70377), c)

def ccc.n481(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n478(U32.is_lt(c, 70197), c)
    case False{}:
      ccc.n480(U32.is_lt(c, 70199), c)

def ccc.n482(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n483(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n484(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      ccc.n483(U32.is_lt(c, 70477), c)

def ccc.n485(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n482(U32.is_lt(c, 70379), c)
    case False{}:
      ccc.n484(U32.is_lt(c, 70461), c)

def ccc.n486(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n481(U32.is_lt(c, 70198), c)
    case False{}:
      ccc.n485(U32.is_lt(c, 70459), c)

def ccc.n487(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n477(U32.is_lt(c, 70003), c)
    case False{}:
      ccc.n486(U32.is_lt(c, 70378), c)

def ccc.n488(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n469(U32.is_lt(c, 69510), c)
    case False{}:
      ccc.n487(U32.is_lt(c, 70091), c)

def ccc.n489(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n490(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n491(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n489(U32.is_lt(c, 70502), c)
    case False{}:
      ccc.n490(U32.is_lt(c, 70512), c)

def ccc.n492(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n493(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n494(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n493(U32.is_lt(c, 70723), c)

def ccc.n495(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n492(U32.is_lt(c, 70606), c)
    case False{}:
      ccc.n494(U32.is_lt(c, 70722), c)

def ccc.n496(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n491(U32.is_lt(c, 70509), c)
    case False{}:
      ccc.n495(U32.is_lt(c, 70609), c)

def ccc.n497(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n498(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n499(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n498(U32.is_lt(c, 70850), c)

def ccc.n500(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n497(U32.is_lt(c, 70727), c)
    case False{}:
      ccc.n499(U32.is_lt(c, 70751), c)

def ccc.n501(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n502(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n503(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n502(U32.is_lt(c, 71105), c)

def ccc.n504(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n501(U32.is_lt(c, 70852), c)
    case False{}:
      ccc.n503(U32.is_lt(c, 71104), c)

def ccc.n505(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n500(U32.is_lt(c, 70750), c)
    case False{}:
      ccc.n504(U32.is_lt(c, 71103), c)

def ccc.n506(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n496(U32.is_lt(c, 70517), c)
    case False{}:
      ccc.n505(U32.is_lt(c, 70851), c)

def ccc.n507(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n508(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      7

def ccc.n509(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n507(U32.is_lt(c, 71232), c)
    case False{}:
      ccc.n508(U32.is_lt(c, 71351), c)

def ccc.n510(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n511(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      7

def ccc.n512(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n511(U32.is_lt(c, 71738), c)

def ccc.n513(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n510(U32.is_lt(c, 71467), c)
    case False{}:
      ccc.n512(U32.is_lt(c, 71737), c)

def ccc.n514(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n509(U32.is_lt(c, 71350), c)
    case False{}:
      ccc.n513(U32.is_lt(c, 71468), c)

def ccc.n515(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n516(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n517(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n516(U32.is_lt(c, 72004), c)

def ccc.n518(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n515(U32.is_lt(c, 71997), c)
    case False{}:
      ccc.n517(U32.is_lt(c, 72003), c)

def ccc.n519(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n520(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n521(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n520(U32.is_lt(c, 72263), c)

def ccc.n522(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n519(U32.is_lt(c, 72161), c)
    case False{}:
      ccc.n521(U32.is_lt(c, 72245), c)

def ccc.n523(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n518(U32.is_lt(c, 71999), c)
    case False{}:
      ccc.n522(U32.is_lt(c, 72244), c)

def ccc.n524(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n514(U32.is_lt(c, 71352), c)
    case False{}:
      ccc.n523(U32.is_lt(c, 72160), c)

def ccc.n525(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n506(U32.is_lt(c, 70726), c)
    case False{}:
      ccc.n524(U32.is_lt(c, 71739), c)

def ccc.n526(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n488(U32.is_lt(c, 69888), c)
    case False{}:
      ccc.n525(U32.is_lt(c, 71231), c)

def ccc.n527(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n528(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n529(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n527(U32.is_lt(c, 72345), c)
    case False{}:
      ccc.n528(U32.is_lt(c, 72767), c)

def ccc.n530(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def ccc.n531(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n532(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n531(U32.is_lt(c, 73030), c)

def ccc.n533(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n530(U32.is_lt(c, 73026), c)
    case False{}:
      ccc.n532(U32.is_lt(c, 73028), c)

def ccc.n534(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n529(U32.is_lt(c, 72346), c)
    case False{}:
      ccc.n533(U32.is_lt(c, 73027), c)

def ccc.n535(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      0

def ccc.n536(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def ccc.n537(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      9
    case False{}:
      ccc.n536(U32.is_lt(c, 90415), c)

def ccc.n538(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n535(U32.is_lt(c, 73112), c)
    case False{}:
      ccc.n537(U32.is_lt(c, 73539), c)

def ccc.n539(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      1

def ccc.n540(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n541(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n540(U32.is_lt(c, 92983), c)

def ccc.n542(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n539(U32.is_lt(c, 92912), c)
    case False{}:
      ccc.n541(U32.is_lt(c, 92976), c)

def ccc.n543(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n538(U32.is_lt(c, 73537), c)
    case False{}:
      ccc.n542(U32.is_lt(c, 92917), c)

def ccc.n544(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n534(U32.is_lt(c, 72768), c)
    case False{}:
      ccc.n543(U32.is_lt(c, 90416), c)

def ccc.n545(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      6
    case False{}:
      0

def ccc.n546(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      1
    case False{}:
      0

def ccc.n547(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n545(U32.is_lt(c, 94194), c)
    case False{}:
      ccc.n546(U32.is_lt(c, 113823), c)

def ccc.n548(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      216
    case False{}:
      1

def ccc.n549(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      226
    case False{}:
      216

def ccc.n550(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n549(U32.is_lt(c, 119150), c)

def ccc.n551(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n548(U32.is_lt(c, 119143), c)
    case False{}:
      ccc.n550(U32.is_lt(c, 119149), c)

def ccc.n552(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n547(U32.is_lt(c, 113822), c)
    case False{}:
      ccc.n551(U32.is_lt(c, 119146), c)

def ccc.n553(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      220

def ccc.n554(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      220

def ccc.n555(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n554(U32.is_lt(c, 119178), c)

def ccc.n556(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n553(U32.is_lt(c, 119163), c)
    case False{}:
      ccc.n555(U32.is_lt(c, 119173), c)

def ccc.n557(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n558(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n559(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n558(U32.is_lt(c, 119365), c)

def ccc.n560(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n557(U32.is_lt(c, 119210), c)
    case False{}:
      ccc.n559(U32.is_lt(c, 119362), c)

def ccc.n561(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n556(U32.is_lt(c, 119171), c)
    case False{}:
      ccc.n560(U32.is_lt(c, 119214), c)

def ccc.n562(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n552(U32.is_lt(c, 119141), c)
    case False{}:
      ccc.n561(U32.is_lt(c, 119180), c)

def ccc.n563(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n544(U32.is_lt(c, 73111), c)
    case False{}:
      ccc.n562(U32.is_lt(c, 119155), c)

def ccc.n564(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n565(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n566(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n564(U32.is_lt(c, 122887), c)
    case False{}:
      ccc.n565(U32.is_lt(c, 122905), c)

def ccc.n567(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n568(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n569(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n568(U32.is_lt(c, 122918), c)

def ccc.n570(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n567(U32.is_lt(c, 122914), c)
    case False{}:
      ccc.n569(U32.is_lt(c, 122917), c)

def ccc.n571(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n566(U32.is_lt(c, 122888), c)
    case False{}:
      ccc.n570(U32.is_lt(c, 122915), c)

def ccc.n572(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n573(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n574(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n573(U32.is_lt(c, 123191), c)

def ccc.n575(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n572(U32.is_lt(c, 123023), c)
    case False{}:
      ccc.n574(U32.is_lt(c, 123184), c)

def ccc.n576(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n577(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      232

def ccc.n578(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n577(U32.is_lt(c, 124140), c)

def ccc.n579(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n576(U32.is_lt(c, 123567), c)
    case False{}:
      ccc.n578(U32.is_lt(c, 123632), c)

def ccc.n580(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n575(U32.is_lt(c, 123024), c)
    case False{}:
      ccc.n579(U32.is_lt(c, 123628), c)

def ccc.n581(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n571(U32.is_lt(c, 122907), c)
    case False{}:
      ccc.n580(U32.is_lt(c, 123566), c)

def ccc.n582(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      230

def ccc.n583(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n584(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n582(U32.is_lt(c, 124143), c)
    case False{}:
      ccc.n583(U32.is_lt(c, 124398), c)

def ccc.n585(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n586(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n587(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n586(U32.is_lt(c, 124646), c)

def ccc.n588(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n585(U32.is_lt(c, 124400), c)
    case False{}:
      ccc.n587(U32.is_lt(c, 124644), c)

def ccc.n589(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n584(U32.is_lt(c, 124144), c)
    case False{}:
      ccc.n588(U32.is_lt(c, 124643), c)

def ccc.n590(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      230

def ccc.n591(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      0

def ccc.n592(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      ccc.n591(U32.is_lt(c, 124662), c)

def ccc.n593(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n590(U32.is_lt(c, 124654), c)
    case False{}:
      ccc.n592(U32.is_lt(c, 124661), c)

def ccc.n594(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      220
    case False{}:
      0

def ccc.n595(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def ccc.n596(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      230
    case False{}:
      ccc.n595(U32.is_lt(c, 125259), c)

def ccc.n597(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n594(U32.is_lt(c, 125143), c)
    case False{}:
      ccc.n596(U32.is_lt(c, 125258), c)

def ccc.n598(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n593(U32.is_lt(c, 124656), c)
    case False{}:
      ccc.n597(U32.is_lt(c, 125252), c)

def ccc.n599(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n589(U32.is_lt(c, 124399), c)
    case False{}:
      ccc.n598(U32.is_lt(c, 125136), c)

def ccc.n600(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n581(U32.is_lt(c, 122923), c)
    case False{}:
      ccc.n599(U32.is_lt(c, 124647), c)

def ccc.n601(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n563(U32.is_lt(c, 94192), c)
    case False{}:
      ccc.n600(U32.is_lt(c, 124142), c)

def ccc.n602(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n526(U32.is_lt(c, 70478), c)
    case False{}:
      ccc.n601(U32.is_lt(c, 122880), c)

def ccc.n603(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n451(U32.is_lt(c, 12443), c)
    case False{}:
      ccc.n602(U32.is_lt(c, 72264), c)

def ccc.n604(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      ccc.n301(U32.is_lt(c, 2260), c)
    case False{}:
      ccc.n603(U32.is_lt(c, 69448), c)

def ccc(+c: U32) -> U32:
  ccc.n604(U32.is_lt(c, 7021), c)

def dec.n0(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{41}\u{300}"

def dec.n1(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{301}"
    case False{}:
      "\u{41}\u{302}"

def dec.n2(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n0(U32.is_lt(c, 192), c)
    case False{}:
      dec.n1(U32.is_lt(c, 194), c)

def dec.n3(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{303}"
    case False{}:
      "\u{41}\u{308}"

def dec.n4(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{43}\u{327}"

def dec.n5(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{30A}"
    case False{}:
      dec.n4(U32.is_lt(c, 199), c)

def dec.n6(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n3(U32.is_lt(c, 196), c)
    case False{}:
      dec.n5(U32.is_lt(c, 198), c)

def dec.n7(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2(U32.is_lt(c, 193), c)
    case False{}:
      dec.n6(U32.is_lt(c, 197), c)

def dec.n8(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{300}"
    case False{}:
      "\u{45}\u{301}"

def dec.n9(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{302}"
    case False{}:
      "\u{45}\u{308}"

def dec.n10(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n8(U32.is_lt(c, 201), c)
    case False{}:
      dec.n9(U32.is_lt(c, 203), c)

def dec.n11(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{300}"
    case False{}:
      "\u{49}\u{301}"

def dec.n12(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n13(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{302}"
    case False{}:
      dec.n12(U32.is_lt(c, 208), c)

def dec.n14(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n11(U32.is_lt(c, 205), c)
    case False{}:
      dec.n13(U32.is_lt(c, 207), c)

def dec.n15(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n10(U32.is_lt(c, 202), c)
    case False{}:
      dec.n14(U32.is_lt(c, 206), c)

def dec.n16(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n7(U32.is_lt(c, 195), c)
    case False{}:
      dec.n15(U32.is_lt(c, 204), c)

def dec.n17(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E}\u{303}"
    case False{}:
      "\u{4F}\u{300}"

def dec.n18(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{301}"
    case False{}:
      "\u{4F}\u{302}"

def dec.n19(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n17(U32.is_lt(c, 210), c)
    case False{}:
      dec.n18(U32.is_lt(c, 212), c)

def dec.n20(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{303}"
    case False{}:
      "\u{4F}\u{308}"

def dec.n21(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{300}"
    case False{}:
      "\u{55}\u{301}"

def dec.n22(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n21(U32.is_lt(c, 218), c)

def dec.n23(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n20(U32.is_lt(c, 214), c)
    case False{}:
      dec.n22(U32.is_lt(c, 217), c)

def dec.n24(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n19(U32.is_lt(c, 211), c)
    case False{}:
      dec.n23(U32.is_lt(c, 215), c)

def dec.n25(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{302}"
    case False{}:
      "\u{55}\u{308}"

def dec.n26(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{59}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n27(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n25(U32.is_lt(c, 220), c)
    case False{}:
      dec.n26(U32.is_lt(c, 222), c)

def dec.n28(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{300}"
    case False{}:
      "\u{61}\u{301}"

def dec.n29(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{303}"
    case False{}:
      "\u{61}\u{308}"

def dec.n30(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{302}"
    case False{}:
      dec.n29(U32.is_lt(c, 228), c)

def dec.n31(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n28(U32.is_lt(c, 225), c)
    case False{}:
      dec.n30(U32.is_lt(c, 227), c)

def dec.n32(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n27(U32.is_lt(c, 221), c)
    case False{}:
      dec.n31(U32.is_lt(c, 226), c)

def dec.n33(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n24(U32.is_lt(c, 213), c)
    case False{}:
      dec.n32(U32.is_lt(c, 224), c)

def dec.n34(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n16(U32.is_lt(c, 200), c)
    case False{}:
      dec.n33(U32.is_lt(c, 219), c)

def dec.n35(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{30A}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n36(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{63}\u{327}"
    case False{}:
      "\u{65}\u{300}"

def dec.n37(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n35(U32.is_lt(c, 230), c)
    case False{}:
      dec.n36(U32.is_lt(c, 232), c)

def dec.n38(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{301}"
    case False{}:
      "\u{65}\u{302}"

def dec.n39(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{300}"
    case False{}:
      "\u{69}\u{301}"

def dec.n40(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{308}"
    case False{}:
      dec.n39(U32.is_lt(c, 237), c)

def dec.n41(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n38(U32.is_lt(c, 234), c)
    case False{}:
      dec.n40(U32.is_lt(c, 236), c)

def dec.n42(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n37(U32.is_lt(c, 231), c)
    case False{}:
      dec.n41(U32.is_lt(c, 235), c)

def dec.n43(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{302}"
    case False{}:
      "\u{69}\u{308}"

def dec.n44(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6E}\u{303}"

def dec.n45(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n43(U32.is_lt(c, 239), c)
    case False{}:
      dec.n44(U32.is_lt(c, 241), c)

def dec.n46(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{300}"
    case False{}:
      "\u{6F}\u{301}"

def dec.n47(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{303}"
    case False{}:
      "\u{6F}\u{308}"

def dec.n48(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{302}"
    case False{}:
      dec.n47(U32.is_lt(c, 246), c)

def dec.n49(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n46(U32.is_lt(c, 243), c)
    case False{}:
      dec.n48(U32.is_lt(c, 245), c)

def dec.n50(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n45(U32.is_lt(c, 240), c)
    case False{}:
      dec.n49(U32.is_lt(c, 244), c)

def dec.n51(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n42(U32.is_lt(c, 233), c)
    case False{}:
      dec.n50(U32.is_lt(c, 242), c)

def dec.n52(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{75}\u{300}"

def dec.n53(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{301}"
    case False{}:
      "\u{75}\u{302}"

def dec.n54(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n52(U32.is_lt(c, 249), c)
    case False{}:
      dec.n53(U32.is_lt(c, 251), c)

def dec.n55(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{308}"
    case False{}:
      "\u{79}\u{301}"

def dec.n56(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{308}"
    case False{}:
      "\u{41}\u{304}"

def dec.n57(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n56(U32.is_lt(c, 256), c)

def dec.n58(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n55(U32.is_lt(c, 253), c)
    case False{}:
      dec.n57(U32.is_lt(c, 255), c)

def dec.n59(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n54(U32.is_lt(c, 250), c)
    case False{}:
      dec.n58(U32.is_lt(c, 254), c)

def dec.n60(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{304}"
    case False{}:
      "\u{41}\u{306}"

def dec.n61(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{306}"
    case False{}:
      "\u{41}\u{328}"

def dec.n62(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n60(U32.is_lt(c, 258), c)
    case False{}:
      dec.n61(U32.is_lt(c, 260), c)

def dec.n63(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{328}"
    case False{}:
      "\u{43}\u{301}"

def dec.n64(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43}\u{302}"
    case False{}:
      "\u{63}\u{302}"

def dec.n65(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{63}\u{301}"
    case False{}:
      dec.n64(U32.is_lt(c, 265), c)

def dec.n66(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n63(U32.is_lt(c, 262), c)
    case False{}:
      dec.n65(U32.is_lt(c, 264), c)

def dec.n67(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n62(U32.is_lt(c, 259), c)
    case False{}:
      dec.n66(U32.is_lt(c, 263), c)

def dec.n68(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n59(U32.is_lt(c, 252), c)
    case False{}:
      dec.n67(U32.is_lt(c, 261), c)

def dec.n69(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n51(U32.is_lt(c, 238), c)
    case False{}:
      dec.n68(U32.is_lt(c, 257), c)

def dec.n70(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n34(U32.is_lt(c, 209), c)
    case False{}:
      dec.n69(U32.is_lt(c, 247), c)

def dec.n71(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43}\u{307}"
    case False{}:
      "\u{63}\u{307}"

def dec.n72(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43}\u{30C}"
    case False{}:
      "\u{63}\u{30C}"

def dec.n73(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n71(U32.is_lt(c, 267), c)
    case False{}:
      dec.n72(U32.is_lt(c, 269), c)

def dec.n74(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44}\u{30C}"
    case False{}:
      "\u{64}\u{30C}"

def dec.n75(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{304}"
    case False{}:
      "\u{65}\u{304}"

def dec.n76(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n75(U32.is_lt(c, 275), c)

def dec.n77(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n74(U32.is_lt(c, 271), c)
    case False{}:
      dec.n76(U32.is_lt(c, 274), c)

def dec.n78(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n73(U32.is_lt(c, 268), c)
    case False{}:
      dec.n77(U32.is_lt(c, 272), c)

def dec.n79(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{306}"
    case False{}:
      "\u{65}\u{306}"

def dec.n80(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{307}"
    case False{}:
      "\u{65}\u{307}"

def dec.n81(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n79(U32.is_lt(c, 277), c)
    case False{}:
      dec.n80(U32.is_lt(c, 279), c)

def dec.n82(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{328}"
    case False{}:
      "\u{65}\u{328}"

def dec.n83(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{30C}"
    case False{}:
      "\u{47}\u{302}"

def dec.n84(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{30C}"
    case False{}:
      dec.n83(U32.is_lt(c, 284), c)

def dec.n85(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n82(U32.is_lt(c, 281), c)
    case False{}:
      dec.n84(U32.is_lt(c, 283), c)

def dec.n86(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n81(U32.is_lt(c, 278), c)
    case False{}:
      dec.n85(U32.is_lt(c, 282), c)

def dec.n87(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n78(U32.is_lt(c, 270), c)
    case False{}:
      dec.n86(U32.is_lt(c, 280), c)

def dec.n88(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67}\u{302}"
    case False{}:
      "\u{47}\u{306}"

def dec.n89(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67}\u{306}"
    case False{}:
      "\u{47}\u{307}"

def dec.n90(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n88(U32.is_lt(c, 286), c)
    case False{}:
      dec.n89(U32.is_lt(c, 288), c)

def dec.n91(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67}\u{307}"
    case False{}:
      "\u{47}\u{327}"

def dec.n92(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{302}"
    case False{}:
      "\u{68}\u{302}"

def dec.n93(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67}\u{327}"
    case False{}:
      dec.n92(U32.is_lt(c, 293), c)

def dec.n94(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n91(U32.is_lt(c, 290), c)
    case False{}:
      dec.n93(U32.is_lt(c, 292), c)

def dec.n95(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n90(U32.is_lt(c, 287), c)
    case False{}:
      dec.n94(U32.is_lt(c, 291), c)

def dec.n96(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{49}\u{303}"

def dec.n97(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{303}"
    case False{}:
      "\u{49}\u{304}"

def dec.n98(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n96(U32.is_lt(c, 296), c)
    case False{}:
      dec.n97(U32.is_lt(c, 298), c)

def dec.n99(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{304}"
    case False{}:
      "\u{49}\u{306}"

def dec.n100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{328}"
    case False{}:
      "\u{69}\u{328}"

def dec.n101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{306}"
    case False{}:
      dec.n100(U32.is_lt(c, 303), c)

def dec.n102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n99(U32.is_lt(c, 300), c)
    case False{}:
      dec.n101(U32.is_lt(c, 302), c)

def dec.n103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n98(U32.is_lt(c, 297), c)
    case False{}:
      dec.n102(U32.is_lt(c, 301), c)

def dec.n104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n95(U32.is_lt(c, 289), c)
    case False{}:
      dec.n103(U32.is_lt(c, 299), c)

def dec.n105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n87(U32.is_lt(c, 276), c)
    case False{}:
      dec.n104(U32.is_lt(c, 294), c)

def dec.n106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{307}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A}\u{302}"
    case False{}:
      "\u{6A}\u{302}"

def dec.n108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n106(U32.is_lt(c, 305), c)
    case False{}:
      dec.n107(U32.is_lt(c, 309), c)

def dec.n109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4B}\u{327}"
    case False{}:
      "\u{6B}\u{327}"

def dec.n110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C}\u{301}"
    case False{}:
      "\u{6C}\u{301}"

def dec.n111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n110(U32.is_lt(c, 314), c)

def dec.n112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n109(U32.is_lt(c, 311), c)
    case False{}:
      dec.n111(U32.is_lt(c, 313), c)

def dec.n113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n108(U32.is_lt(c, 308), c)
    case False{}:
      dec.n112(U32.is_lt(c, 312), c)

def dec.n114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C}\u{327}"
    case False{}:
      "\u{6C}\u{327}"

def dec.n115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C}\u{30C}"
    case False{}:
      "\u{6C}\u{30C}"

def dec.n116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n114(U32.is_lt(c, 316), c)
    case False{}:
      dec.n115(U32.is_lt(c, 318), c)

def dec.n117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4E}\u{301}"

def dec.n118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E}\u{327}"
    case False{}:
      "\u{6E}\u{327}"

def dec.n119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{301}"
    case False{}:
      dec.n118(U32.is_lt(c, 326), c)

def dec.n120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n117(U32.is_lt(c, 323), c)
    case False{}:
      dec.n119(U32.is_lt(c, 325), c)

def dec.n121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n116(U32.is_lt(c, 317), c)
    case False{}:
      dec.n120(U32.is_lt(c, 324), c)

def dec.n122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n113(U32.is_lt(c, 310), c)
    case False{}:
      dec.n121(U32.is_lt(c, 319), c)

def dec.n123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E}\u{30C}"
    case False{}:
      "\u{6E}\u{30C}"

def dec.n124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F}\u{304}"

def dec.n125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n123(U32.is_lt(c, 328), c)
    case False{}:
      dec.n124(U32.is_lt(c, 332), c)

def dec.n126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{304}"
    case False{}:
      "\u{4F}\u{306}"

def dec.n127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{30B}"
    case False{}:
      "\u{6F}\u{30B}"

def dec.n128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{306}"
    case False{}:
      dec.n127(U32.is_lt(c, 337), c)

def dec.n129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n126(U32.is_lt(c, 334), c)
    case False{}:
      dec.n128(U32.is_lt(c, 336), c)

def dec.n130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n125(U32.is_lt(c, 329), c)
    case False{}:
      dec.n129(U32.is_lt(c, 335), c)

def dec.n131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{52}\u{301}"

def dec.n132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{301}"
    case False{}:
      "\u{52}\u{327}"

def dec.n133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n131(U32.is_lt(c, 340), c)
    case False{}:
      dec.n132(U32.is_lt(c, 342), c)

def dec.n134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{327}"
    case False{}:
      "\u{52}\u{30C}"

def dec.n135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{301}"
    case False{}:
      "\u{73}\u{301}"

def dec.n136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{30C}"
    case False{}:
      dec.n135(U32.is_lt(c, 347), c)

def dec.n137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n134(U32.is_lt(c, 344), c)
    case False{}:
      dec.n136(U32.is_lt(c, 346), c)

def dec.n138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n133(U32.is_lt(c, 341), c)
    case False{}:
      dec.n137(U32.is_lt(c, 345), c)

def dec.n139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n130(U32.is_lt(c, 333), c)
    case False{}:
      dec.n138(U32.is_lt(c, 343), c)

def dec.n140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n122(U32.is_lt(c, 315), c)
    case False{}:
      dec.n139(U32.is_lt(c, 338), c)

def dec.n141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n105(U32.is_lt(c, 285), c)
    case False{}:
      dec.n140(U32.is_lt(c, 327), c)

def dec.n142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n70(U32.is_lt(c, 229), c)
    case False{}:
      dec.n141(U32.is_lt(c, 304), c)

def dec.n143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{302}"
    case False{}:
      "\u{73}\u{302}"

def dec.n144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{327}"
    case False{}:
      "\u{73}\u{327}"

def dec.n145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n143(U32.is_lt(c, 349), c)
    case False{}:
      dec.n144(U32.is_lt(c, 351), c)

def dec.n146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{30C}"
    case False{}:
      "\u{73}\u{30C}"

def dec.n147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{327}"
    case False{}:
      "\u{54}\u{30C}"

def dec.n148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{54}\u{327}"
    case False{}:
      dec.n147(U32.is_lt(c, 356), c)

def dec.n149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n146(U32.is_lt(c, 353), c)
    case False{}:
      dec.n148(U32.is_lt(c, 355), c)

def dec.n150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n145(U32.is_lt(c, 350), c)
    case False{}:
      dec.n149(U32.is_lt(c, 354), c)

def dec.n151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{30C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{303}"
    case False{}:
      "\u{75}\u{303}"

def dec.n153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n151(U32.is_lt(c, 358), c)
    case False{}:
      dec.n152(U32.is_lt(c, 361), c)

def dec.n154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{304}"
    case False{}:
      "\u{75}\u{304}"

def dec.n155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{306}"
    case False{}:
      "\u{55}\u{30A}"

def dec.n156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{306}"
    case False{}:
      dec.n155(U32.is_lt(c, 366), c)

def dec.n157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n154(U32.is_lt(c, 363), c)
    case False{}:
      dec.n156(U32.is_lt(c, 365), c)

def dec.n158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n153(U32.is_lt(c, 360), c)
    case False{}:
      dec.n157(U32.is_lt(c, 364), c)

def dec.n159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n150(U32.is_lt(c, 352), c)
    case False{}:
      dec.n158(U32.is_lt(c, 362), c)

def dec.n160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{30A}"
    case False{}:
      "\u{55}\u{30B}"

def dec.n161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{30B}"
    case False{}:
      "\u{55}\u{328}"

def dec.n162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n160(U32.is_lt(c, 368), c)
    case False{}:
      dec.n161(U32.is_lt(c, 370), c)

def dec.n163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{328}"
    case False{}:
      "\u{57}\u{302}"

def dec.n164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{59}\u{302}"
    case False{}:
      "\u{79}\u{302}"

def dec.n165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{77}\u{302}"
    case False{}:
      dec.n164(U32.is_lt(c, 375), c)

def dec.n166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n163(U32.is_lt(c, 372), c)
    case False{}:
      dec.n165(U32.is_lt(c, 374), c)

def dec.n167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n162(U32.is_lt(c, 369), c)
    case False{}:
      dec.n166(U32.is_lt(c, 373), c)

def dec.n168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{59}\u{308}"
    case False{}:
      "\u{5A}\u{301}"

def dec.n169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{301}"
    case False{}:
      "\u{5A}\u{307}"

def dec.n170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n168(U32.is_lt(c, 377), c)
    case False{}:
      dec.n169(U32.is_lt(c, 379), c)

def dec.n171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{307}"
    case False{}:
      "\u{5A}\u{30C}"

def dec.n172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F}\u{31B}"

def dec.n173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{30C}"
    case False{}:
      dec.n172(U32.is_lt(c, 416), c)

def dec.n174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n171(U32.is_lt(c, 381), c)
    case False{}:
      dec.n173(U32.is_lt(c, 383), c)

def dec.n175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n170(U32.is_lt(c, 378), c)
    case False{}:
      dec.n174(U32.is_lt(c, 382), c)

def dec.n176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n167(U32.is_lt(c, 371), c)
    case False{}:
      dec.n175(U32.is_lt(c, 380), c)

def dec.n177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n159(U32.is_lt(c, 357), c)
    case False{}:
      dec.n176(U32.is_lt(c, 376), c)

def dec.n178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{31B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{31B}"
    case False{}:
      "\u{75}\u{31B}"

def dec.n180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n178(U32.is_lt(c, 418), c)
    case False{}:
      dec.n179(U32.is_lt(c, 432), c)

def dec.n181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{41}\u{30C}"

def dec.n182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{30C}"
    case False{}:
      "\u{69}\u{30C}"

def dec.n183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{30C}"
    case False{}:
      dec.n182(U32.is_lt(c, 464), c)

def dec.n184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n181(U32.is_lt(c, 461), c)
    case False{}:
      dec.n183(U32.is_lt(c, 463), c)

def dec.n185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n180(U32.is_lt(c, 431), c)
    case False{}:
      dec.n184(U32.is_lt(c, 462), c)

def dec.n186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{30C}"
    case False{}:
      "\u{6F}\u{30C}"

def dec.n187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{30C}"
    case False{}:
      "\u{75}\u{30C}"

def dec.n188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n186(U32.is_lt(c, 466), c)
    case False{}:
      dec.n187(U32.is_lt(c, 468), c)

def dec.n189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{308}\u{304}"
    case False{}:
      "\u{75}\u{308}\u{304}"

def dec.n190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{308}\u{301}"
    case False{}:
      "\u{55}\u{308}\u{30C}"

def dec.n191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{308}\u{301}"
    case False{}:
      dec.n190(U32.is_lt(c, 473), c)

def dec.n192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n189(U32.is_lt(c, 470), c)
    case False{}:
      dec.n191(U32.is_lt(c, 472), c)

def dec.n193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n188(U32.is_lt(c, 467), c)
    case False{}:
      dec.n192(U32.is_lt(c, 471), c)

def dec.n194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n185(U32.is_lt(c, 433), c)
    case False{}:
      dec.n193(U32.is_lt(c, 469), c)

def dec.n195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{308}\u{30C}"
    case False{}:
      "\u{55}\u{308}\u{300}"

def dec.n196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{308}\u{300}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n195(U32.is_lt(c, 475), c)
    case False{}:
      dec.n196(U32.is_lt(c, 477), c)

def dec.n198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{308}\u{304}"
    case False{}:
      "\u{61}\u{308}\u{304}"

def dec.n199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{307}\u{304}"
    case False{}:
      "\u{C6}\u{304}"

def dec.n200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{307}\u{304}"
    case False{}:
      dec.n199(U32.is_lt(c, 482), c)

def dec.n201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n198(U32.is_lt(c, 479), c)
    case False{}:
      dec.n200(U32.is_lt(c, 481), c)

def dec.n202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n197(U32.is_lt(c, 476), c)
    case False{}:
      dec.n201(U32.is_lt(c, 480), c)

def dec.n203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E6}\u{304}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{47}\u{30C}"
    case False{}:
      "\u{67}\u{30C}"

def dec.n205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n203(U32.is_lt(c, 484), c)
    case False{}:
      dec.n204(U32.is_lt(c, 487), c)

def dec.n206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4B}\u{30C}"
    case False{}:
      "\u{6B}\u{30C}"

def dec.n207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{328}"
    case False{}:
      "\u{4F}\u{328}\u{304}"

def dec.n208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{328}"
    case False{}:
      dec.n207(U32.is_lt(c, 492), c)

def dec.n209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n206(U32.is_lt(c, 489), c)
    case False{}:
      dec.n208(U32.is_lt(c, 491), c)

def dec.n210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n205(U32.is_lt(c, 486), c)
    case False{}:
      dec.n209(U32.is_lt(c, 490), c)

def dec.n211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n202(U32.is_lt(c, 478), c)
    case False{}:
      dec.n210(U32.is_lt(c, 488), c)

def dec.n212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n194(U32.is_lt(c, 465), c)
    case False{}:
      dec.n211(U32.is_lt(c, 483), c)

def dec.n213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n177(U32.is_lt(c, 367), c)
    case False{}:
      dec.n212(U32.is_lt(c, 474), c)

def dec.n214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{328}\u{304}"
    case False{}:
      "\u{1B7}\u{30C}"

def dec.n215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{292}\u{30C}"
    case False{}:
      "\u{6A}\u{30C}"

def dec.n216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n214(U32.is_lt(c, 494), c)
    case False{}:
      dec.n215(U32.is_lt(c, 496), c)

def dec.n217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{47}\u{301}"

def dec.n218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4E}\u{300}"

def dec.n219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67}\u{301}"
    case False{}:
      dec.n218(U32.is_lt(c, 504), c)

def dec.n220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n217(U32.is_lt(c, 500), c)
    case False{}:
      dec.n219(U32.is_lt(c, 502), c)

def dec.n221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n216(U32.is_lt(c, 495), c)
    case False{}:
      dec.n220(U32.is_lt(c, 501), c)

def dec.n222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{300}"
    case False{}:
      "\u{41}\u{30A}\u{301}"

def dec.n223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{30A}\u{301}"
    case False{}:
      "\u{C6}\u{301}"

def dec.n224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n222(U32.is_lt(c, 506), c)
    case False{}:
      dec.n223(U32.is_lt(c, 508), c)

def dec.n225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E6}\u{301}"
    case False{}:
      "\u{D8}\u{301}"

def dec.n226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{30F}"
    case False{}:
      "\u{61}\u{30F}"

def dec.n227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F8}\u{301}"
    case False{}:
      dec.n226(U32.is_lt(c, 513), c)

def dec.n228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n225(U32.is_lt(c, 510), c)
    case False{}:
      dec.n227(U32.is_lt(c, 512), c)

def dec.n229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n224(U32.is_lt(c, 507), c)
    case False{}:
      dec.n228(U32.is_lt(c, 511), c)

def dec.n230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n221(U32.is_lt(c, 497), c)
    case False{}:
      dec.n229(U32.is_lt(c, 509), c)

def dec.n231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{311}"
    case False{}:
      "\u{61}\u{311}"

def dec.n232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{30F}"
    case False{}:
      "\u{65}\u{30F}"

def dec.n233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n231(U32.is_lt(c, 515), c)
    case False{}:
      dec.n232(U32.is_lt(c, 517), c)

def dec.n234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{311}"
    case False{}:
      "\u{65}\u{311}"

def dec.n235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{30F}"
    case False{}:
      "\u{49}\u{311}"

def dec.n236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{30F}"
    case False{}:
      dec.n235(U32.is_lt(c, 522), c)

def dec.n237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n234(U32.is_lt(c, 519), c)
    case False{}:
      dec.n236(U32.is_lt(c, 521), c)

def dec.n238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n233(U32.is_lt(c, 516), c)
    case False{}:
      dec.n237(U32.is_lt(c, 520), c)

def dec.n239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{311}"
    case False{}:
      "\u{4F}\u{30F}"

def dec.n240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{30F}"
    case False{}:
      "\u{4F}\u{311}"

def dec.n241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n239(U32.is_lt(c, 524), c)
    case False{}:
      dec.n240(U32.is_lt(c, 526), c)

def dec.n242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{311}"
    case False{}:
      "\u{52}\u{30F}"

def dec.n243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52}\u{311}"
    case False{}:
      "\u{72}\u{311}"

def dec.n244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{30F}"
    case False{}:
      dec.n243(U32.is_lt(c, 531), c)

def dec.n245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n242(U32.is_lt(c, 528), c)
    case False{}:
      dec.n244(U32.is_lt(c, 530), c)

def dec.n246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n241(U32.is_lt(c, 525), c)
    case False{}:
      dec.n245(U32.is_lt(c, 529), c)

def dec.n247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n238(U32.is_lt(c, 518), c)
    case False{}:
      dec.n246(U32.is_lt(c, 527), c)

def dec.n248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n230(U32.is_lt(c, 505), c)
    case False{}:
      dec.n247(U32.is_lt(c, 523), c)

def dec.n249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{30F}"
    case False{}:
      "\u{75}\u{30F}"

def dec.n250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{311}"
    case False{}:
      "\u{75}\u{311}"

def dec.n251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n249(U32.is_lt(c, 533), c)
    case False{}:
      dec.n250(U32.is_lt(c, 535), c)

def dec.n252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{326}"
    case False{}:
      "\u{73}\u{326}"

def dec.n253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{326}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{54}\u{326}"
    case False{}:
      dec.n253(U32.is_lt(c, 540), c)

def dec.n255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n252(U32.is_lt(c, 537), c)
    case False{}:
      dec.n254(U32.is_lt(c, 539), c)

def dec.n256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n251(U32.is_lt(c, 534), c)
    case False{}:
      dec.n255(U32.is_lt(c, 538), c)

def dec.n257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{30C}"
    case False{}:
      "\u{68}\u{30C}"

def dec.n258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{41}\u{307}"

def dec.n259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n257(U32.is_lt(c, 543), c)
    case False{}:
      dec.n258(U32.is_lt(c, 550), c)

def dec.n260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{307}"
    case False{}:
      "\u{45}\u{327}"

def dec.n261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{308}\u{304}"
    case False{}:
      "\u{6F}\u{308}\u{304}"

def dec.n262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{327}"
    case False{}:
      dec.n261(U32.is_lt(c, 555), c)

def dec.n263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n260(U32.is_lt(c, 552), c)
    case False{}:
      dec.n262(U32.is_lt(c, 554), c)

def dec.n264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n259(U32.is_lt(c, 544), c)
    case False{}:
      dec.n263(U32.is_lt(c, 553), c)

def dec.n265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n256(U32.is_lt(c, 536), c)
    case False{}:
      dec.n264(U32.is_lt(c, 551), c)

def dec.n266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{303}\u{304}"
    case False{}:
      "\u{6F}\u{303}\u{304}"

def dec.n267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{307}"
    case False{}:
      "\u{6F}\u{307}"

def dec.n268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n266(U32.is_lt(c, 557), c)
    case False{}:
      dec.n267(U32.is_lt(c, 559), c)

def dec.n269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{307}\u{304}"
    case False{}:
      "\u{6F}\u{307}\u{304}"

def dec.n270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{304}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{59}\u{304}"
    case False{}:
      dec.n270(U32.is_lt(c, 564), c)

def dec.n272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n269(U32.is_lt(c, 561), c)
    case False{}:
      dec.n271(U32.is_lt(c, 563), c)

def dec.n273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n268(U32.is_lt(c, 558), c)
    case False{}:
      dec.n272(U32.is_lt(c, 562), c)

def dec.n274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{300}"
    case False{}:
      "\u{301}"

def dec.n275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{313}"

def dec.n276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n274(U32.is_lt(c, 833), c)
    case False{}:
      dec.n275(U32.is_lt(c, 835), c)

def dec.n277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{308}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B}"

def dec.n279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2B9}"
    case False{}:
      dec.n278(U32.is_lt(c, 894), c)

def dec.n280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n277(U32.is_lt(c, 837), c)
    case False{}:
      dec.n279(U32.is_lt(c, 885), c)

def dec.n281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n276(U32.is_lt(c, 834), c)
    case False{}:
      dec.n280(U32.is_lt(c, 884), c)

def dec.n282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n273(U32.is_lt(c, 560), c)
    case False{}:
      dec.n281(U32.is_lt(c, 836), c)

def dec.n283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n265(U32.is_lt(c, 542), c)
    case False{}:
      dec.n282(U32.is_lt(c, 832), c)

def dec.n284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n248(U32.is_lt(c, 514), c)
    case False{}:
      dec.n283(U32.is_lt(c, 556), c)

def dec.n285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n213(U32.is_lt(c, 417), c)
    case False{}:
      dec.n284(U32.is_lt(c, 532), c)

def dec.n286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n142(U32.is_lt(c, 266), c)
    case False{}:
      dec.n285(U32.is_lt(c, 493), c)

def dec.n287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A8}\u{301}"

def dec.n288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{301}"
    case False{}:
      "\u{B7}"

def dec.n289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n287(U32.is_lt(c, 901), c)
    case False{}:
      dec.n288(U32.is_lt(c, 903), c)

def dec.n290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{301}"
    case False{}:
      "\u{397}\u{301}"

def dec.n291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{39F}\u{301}"

def dec.n292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{301}"
    case False{}:
      dec.n291(U32.is_lt(c, 908), c)

def dec.n293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n290(U32.is_lt(c, 905), c)
    case False{}:
      dec.n292(U32.is_lt(c, 907), c)

def dec.n294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n289(U32.is_lt(c, 902), c)
    case False{}:
      dec.n293(U32.is_lt(c, 906), c)

def dec.n295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3A5}\u{301}"

def dec.n296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{301}"
    case False{}:
      "\u{3B9}\u{308}\u{301}"

def dec.n297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n295(U32.is_lt(c, 910), c)
    case False{}:
      dec.n296(U32.is_lt(c, 912), c)

def dec.n298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{399}\u{308}"

def dec.n299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{301}"
    case False{}:
      "\u{3B5}\u{301}"

def dec.n300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{308}"
    case False{}:
      dec.n299(U32.is_lt(c, 941), c)

def dec.n301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n298(U32.is_lt(c, 938), c)
    case False{}:
      dec.n300(U32.is_lt(c, 940), c)

def dec.n302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n297(U32.is_lt(c, 911), c)
    case False{}:
      dec.n301(U32.is_lt(c, 939), c)

def dec.n303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n294(U32.is_lt(c, 904), c)
    case False{}:
      dec.n302(U32.is_lt(c, 913), c)

def dec.n304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{301}"
    case False{}:
      "\u{3B9}\u{301}"

def dec.n305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n304(U32.is_lt(c, 943), c)
    case False{}:
      dec.n305(U32.is_lt(c, 945), c)

def dec.n307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}"
    case False{}:
      "\u{3C5}\u{308}"

def dec.n308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{301}"
    case False{}:
      "\u{3C9}\u{301}"

def dec.n309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BF}\u{301}"
    case False{}:
      dec.n308(U32.is_lt(c, 974), c)

def dec.n310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n307(U32.is_lt(c, 971), c)
    case False{}:
      dec.n309(U32.is_lt(c, 973), c)

def dec.n311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n306(U32.is_lt(c, 944), c)
    case False{}:
      dec.n310(U32.is_lt(c, 972), c)

def dec.n312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3D2}\u{301}"

def dec.n313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3D2}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n312(U32.is_lt(c, 979), c)
    case False{}:
      dec.n313(U32.is_lt(c, 981), c)

def dec.n315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{415}\u{300}"
    case False{}:
      "\u{415}\u{308}"

def dec.n316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{413}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n316(U32.is_lt(c, 1028), c)

def dec.n318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n315(U32.is_lt(c, 1025), c)
    case False{}:
      dec.n317(U32.is_lt(c, 1027), c)

def dec.n319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n314(U32.is_lt(c, 980), c)
    case False{}:
      dec.n318(U32.is_lt(c, 1026), c)

def dec.n320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n311(U32.is_lt(c, 970), c)
    case False{}:
      dec.n319(U32.is_lt(c, 1024), c)

def dec.n321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n303(U32.is_lt(c, 909), c)
    case False{}:
      dec.n320(U32.is_lt(c, 975), c)

def dec.n322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{406}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41A}\u{301}"
    case False{}:
      "\u{418}\u{300}"

def dec.n324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n322(U32.is_lt(c, 1032), c)
    case False{}:
      dec.n323(U32.is_lt(c, 1037), c)

def dec.n325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{423}\u{306}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{438}\u{306}"

def dec.n327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{418}\u{306}"
    case False{}:
      dec.n326(U32.is_lt(c, 1081), c)

def dec.n328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n325(U32.is_lt(c, 1039), c)
    case False{}:
      dec.n327(U32.is_lt(c, 1050), c)

def dec.n329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n324(U32.is_lt(c, 1036), c)
    case False{}:
      dec.n328(U32.is_lt(c, 1049), c)

def dec.n330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{435}\u{300}"

def dec.n331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{435}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n330(U32.is_lt(c, 1104), c)
    case False{}:
      dec.n331(U32.is_lt(c, 1106), c)

def dec.n333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{433}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{43A}\u{301}"

def dec.n335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{456}\u{308}"
    case False{}:
      dec.n334(U32.is_lt(c, 1116), c)

def dec.n336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n333(U32.is_lt(c, 1108), c)
    case False{}:
      dec.n335(U32.is_lt(c, 1112), c)

def dec.n337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n332(U32.is_lt(c, 1105), c)
    case False{}:
      dec.n336(U32.is_lt(c, 1111), c)

def dec.n338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n329(U32.is_lt(c, 1038), c)
    case False{}:
      dec.n337(U32.is_lt(c, 1107), c)

def dec.n339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{438}\u{300}"
    case False{}:
      "\u{443}\u{306}"

def dec.n340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{474}\u{30F}"

def dec.n341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n339(U32.is_lt(c, 1118), c)
    case False{}:
      dec.n340(U32.is_lt(c, 1142), c)

def dec.n342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{475}\u{30F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{436}\u{306}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{416}\u{306}"
    case False{}:
      dec.n343(U32.is_lt(c, 1219), c)

def dec.n345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n342(U32.is_lt(c, 1144), c)
    case False{}:
      dec.n344(U32.is_lt(c, 1218), c)

def dec.n346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n341(U32.is_lt(c, 1119), c)
    case False{}:
      dec.n345(U32.is_lt(c, 1217), c)

def dec.n347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{410}\u{306}"
    case False{}:
      "\u{430}\u{306}"

def dec.n348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{410}\u{308}"
    case False{}:
      "\u{430}\u{308}"

def dec.n349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n347(U32.is_lt(c, 1233), c)
    case False{}:
      dec.n348(U32.is_lt(c, 1235), c)

def dec.n350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{415}\u{306}"

def dec.n351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D8}\u{308}"

def dec.n352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{435}\u{306}"
    case False{}:
      dec.n351(U32.is_lt(c, 1242), c)

def dec.n353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n350(U32.is_lt(c, 1238), c)
    case False{}:
      dec.n352(U32.is_lt(c, 1240), c)

def dec.n354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n349(U32.is_lt(c, 1234), c)
    case False{}:
      dec.n353(U32.is_lt(c, 1239), c)

def dec.n355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n346(U32.is_lt(c, 1143), c)
    case False{}:
      dec.n354(U32.is_lt(c, 1236), c)

def dec.n356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n338(U32.is_lt(c, 1082), c)
    case False{}:
      dec.n355(U32.is_lt(c, 1232), c)

def dec.n357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n321(U32.is_lt(c, 942), c)
    case False{}:
      dec.n356(U32.is_lt(c, 1117), c)

def dec.n358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4D9}\u{308}"
    case False{}:
      "\u{416}\u{308}"

def dec.n359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{436}\u{308}"
    case False{}:
      "\u{417}\u{308}"

def dec.n360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n358(U32.is_lt(c, 1244), c)
    case False{}:
      dec.n359(U32.is_lt(c, 1246), c)

def dec.n361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{437}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{438}\u{304}"
    case False{}:
      "\u{418}\u{308}"

def dec.n363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{418}\u{304}"
    case False{}:
      dec.n362(U32.is_lt(c, 1252), c)

def dec.n364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n361(U32.is_lt(c, 1248), c)
    case False{}:
      dec.n363(U32.is_lt(c, 1251), c)

def dec.n365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n360(U32.is_lt(c, 1245), c)
    case False{}:
      dec.n364(U32.is_lt(c, 1250), c)

def dec.n366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{438}\u{308}"
    case False{}:
      "\u{41E}\u{308}"

def dec.n367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43E}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n366(U32.is_lt(c, 1254), c)
    case False{}:
      dec.n367(U32.is_lt(c, 1256), c)

def dec.n369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E8}\u{308}"
    case False{}:
      "\u{4E9}\u{308}"

def dec.n370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44D}\u{308}"
    case False{}:
      "\u{423}\u{304}"

def dec.n371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{42D}\u{308}"
    case False{}:
      dec.n370(U32.is_lt(c, 1262), c)

def dec.n372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n369(U32.is_lt(c, 1259), c)
    case False{}:
      dec.n371(U32.is_lt(c, 1261), c)

def dec.n373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n368(U32.is_lt(c, 1255), c)
    case False{}:
      dec.n372(U32.is_lt(c, 1260), c)

def dec.n374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n365(U32.is_lt(c, 1247), c)
    case False{}:
      dec.n373(U32.is_lt(c, 1258), c)

def dec.n375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{443}\u{304}"
    case False{}:
      "\u{423}\u{308}"

def dec.n376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{443}\u{308}"
    case False{}:
      "\u{423}\u{30B}"

def dec.n377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n375(U32.is_lt(c, 1264), c)
    case False{}:
      dec.n376(U32.is_lt(c, 1266), c)

def dec.n378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{443}\u{30B}"
    case False{}:
      "\u{427}\u{308}"

def dec.n379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{42B}\u{308}"

def dec.n380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{447}\u{308}"
    case False{}:
      dec.n379(U32.is_lt(c, 1272), c)

def dec.n381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n378(U32.is_lt(c, 1268), c)
    case False{}:
      dec.n380(U32.is_lt(c, 1270), c)

def dec.n382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n377(U32.is_lt(c, 1265), c)
    case False{}:
      dec.n381(U32.is_lt(c, 1269), c)

def dec.n383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44B}\u{308}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{627}\u{653}"
    case False{}:
      "\u{627}\u{654}"

def dec.n385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n383(U32.is_lt(c, 1274), c)
    case False{}:
      dec.n384(U32.is_lt(c, 1571), c)

def dec.n386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{648}\u{654}"
    case False{}:
      "\u{627}\u{655}"

def dec.n387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6D5}\u{654}"

def dec.n388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{64A}\u{654}"
    case False{}:
      dec.n387(U32.is_lt(c, 1728), c)

def dec.n389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n386(U32.is_lt(c, 1573), c)
    case False{}:
      dec.n388(U32.is_lt(c, 1575), c)

def dec.n390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n385(U32.is_lt(c, 1570), c)
    case False{}:
      dec.n389(U32.is_lt(c, 1574), c)

def dec.n391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n382(U32.is_lt(c, 1267), c)
    case False{}:
      dec.n390(U32.is_lt(c, 1572), c)

def dec.n392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n374(U32.is_lt(c, 1253), c)
    case False{}:
      dec.n391(U32.is_lt(c, 1273), c)

def dec.n393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6C1}\u{654}"

def dec.n394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6D2}\u{654}"

def dec.n395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n393(U32.is_lt(c, 1730), c)
    case False{}:
      dec.n394(U32.is_lt(c, 1747), c)

def dec.n396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{928}\u{93C}"

def dec.n397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{930}\u{93C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n397(U32.is_lt(c, 2354), c)

def dec.n399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n396(U32.is_lt(c, 2345), c)
    case False{}:
      dec.n398(U32.is_lt(c, 2353), c)

def dec.n400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n395(U32.is_lt(c, 1731), c)
    case False{}:
      dec.n399(U32.is_lt(c, 2346), c)

def dec.n401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{933}\u{93C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{915}\u{93C}"
    case False{}:
      "\u{916}\u{93C}"

def dec.n403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n401(U32.is_lt(c, 2357), c)
    case False{}:
      dec.n402(U32.is_lt(c, 2393), c)

def dec.n404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{917}\u{93C}"
    case False{}:
      "\u{91C}\u{93C}"

def dec.n405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{922}\u{93C}"
    case False{}:
      "\u{92B}\u{93C}"

def dec.n406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{921}\u{93C}"
    case False{}:
      dec.n405(U32.is_lt(c, 2398), c)

def dec.n407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n404(U32.is_lt(c, 2395), c)
    case False{}:
      dec.n406(U32.is_lt(c, 2397), c)

def dec.n408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n403(U32.is_lt(c, 2392), c)
    case False{}:
      dec.n407(U32.is_lt(c, 2396), c)

def dec.n409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n400(U32.is_lt(c, 1748), c)
    case False{}:
      dec.n408(U32.is_lt(c, 2394), c)

def dec.n410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{92F}\u{93C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9C7}\u{9BE}"
    case False{}:
      "\u{9C7}\u{9D7}"

def dec.n412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n410(U32.is_lt(c, 2400), c)
    case False{}:
      dec.n411(U32.is_lt(c, 2508), c)

def dec.n413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{9A1}\u{9BC}"

def dec.n414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{9AF}\u{9BC}"

def dec.n415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9A2}\u{9BC}"
    case False{}:
      dec.n414(U32.is_lt(c, 2527), c)

def dec.n416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n413(U32.is_lt(c, 2524), c)
    case False{}:
      dec.n415(U32.is_lt(c, 2526), c)

def dec.n417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n412(U32.is_lt(c, 2507), c)
    case False{}:
      dec.n416(U32.is_lt(c, 2525), c)

def dec.n418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A32}\u{A3C}"

def dec.n419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A38}\u{A3C}"

def dec.n420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n418(U32.is_lt(c, 2611), c)
    case False{}:
      dec.n419(U32.is_lt(c, 2614), c)

def dec.n421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A16}\u{A3C}"

def dec.n422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A1C}\u{A3C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A17}\u{A3C}"
    case False{}:
      dec.n422(U32.is_lt(c, 2652), c)

def dec.n424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n421(U32.is_lt(c, 2649), c)
    case False{}:
      dec.n423(U32.is_lt(c, 2651), c)

def dec.n425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n420(U32.is_lt(c, 2612), c)
    case False{}:
      dec.n424(U32.is_lt(c, 2650), c)

def dec.n426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n417(U32.is_lt(c, 2509), c)
    case False{}:
      dec.n425(U32.is_lt(c, 2615), c)

def dec.n427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n409(U32.is_lt(c, 2356), c)
    case False{}:
      dec.n426(U32.is_lt(c, 2528), c)

def dec.n428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n392(U32.is_lt(c, 1263), c)
    case False{}:
      dec.n427(U32.is_lt(c, 2399), c)

def dec.n429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n357(U32.is_lt(c, 1031), c)
    case False{}:
      dec.n428(U32.is_lt(c, 1729), c)

def dec.n430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A2B}\u{A3C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{B47}\u{B56}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n430(U32.is_lt(c, 2655), c)
    case False{}:
      dec.n431(U32.is_lt(c, 2889), c)

def dec.n433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{B47}\u{B3E}"
    case False{}:
      "\u{B47}\u{B57}"

def dec.n434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{B21}\u{B3C}"
    case False{}:
      "\u{B22}\u{B3C}"

def dec.n435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n434(U32.is_lt(c, 2909), c)

def dec.n436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n433(U32.is_lt(c, 2892), c)
    case False{}:
      dec.n435(U32.is_lt(c, 2908), c)

def dec.n437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n432(U32.is_lt(c, 2888), c)
    case False{}:
      dec.n436(U32.is_lt(c, 2893), c)

def dec.n438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{B92}\u{BD7}"

def dec.n439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{BC6}\u{BBE}"

def dec.n440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n438(U32.is_lt(c, 2964), c)
    case False{}:
      dec.n439(U32.is_lt(c, 3018), c)

def dec.n441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{BC7}\u{BBE}"
    case False{}:
      "\u{BC6}\u{BD7}"

def dec.n442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{C46}\u{C56}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n442(U32.is_lt(c, 3145), c)

def dec.n444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n441(U32.is_lt(c, 3020), c)
    case False{}:
      dec.n443(U32.is_lt(c, 3144), c)

def dec.n445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n440(U32.is_lt(c, 2965), c)
    case False{}:
      dec.n444(U32.is_lt(c, 3021), c)

def dec.n446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n437(U32.is_lt(c, 2891), c)
    case False{}:
      dec.n445(U32.is_lt(c, 3019), c)

def dec.n447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{CBF}\u{CD5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{CC6}\u{CD5}"
    case False{}:
      "\u{CC6}\u{CD6}"

def dec.n449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n447(U32.is_lt(c, 3265), c)
    case False{}:
      dec.n448(U32.is_lt(c, 3272), c)

def dec.n450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{CC6}\u{CC2}"

def dec.n451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{D46}\u{D3E}"

def dec.n452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{CC6}\u{CC2}\u{CD5}"
    case False{}:
      dec.n451(U32.is_lt(c, 3402), c)

def dec.n453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n450(U32.is_lt(c, 3274), c)
    case False{}:
      dec.n452(U32.is_lt(c, 3276), c)

def dec.n454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n449(U32.is_lt(c, 3271), c)
    case False{}:
      dec.n453(U32.is_lt(c, 3275), c)

def dec.n455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{D47}\u{D3E}"
    case False{}:
      "\u{D46}\u{D57}"

def dec.n456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{DD9}\u{DCA}"

def dec.n457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n455(U32.is_lt(c, 3404), c)
    case False{}:
      dec.n456(U32.is_lt(c, 3546), c)

def dec.n458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{DD9}\u{DCF}"

def dec.n459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{DD9}\u{DDF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{DD9}\u{DCF}\u{DCA}"
    case False{}:
      dec.n459(U32.is_lt(c, 3551), c)

def dec.n461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n458(U32.is_lt(c, 3548), c)
    case False{}:
      dec.n460(U32.is_lt(c, 3550), c)

def dec.n462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n457(U32.is_lt(c, 3405), c)
    case False{}:
      dec.n461(U32.is_lt(c, 3549), c)

def dec.n463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n454(U32.is_lt(c, 3273), c)
    case False{}:
      dec.n462(U32.is_lt(c, 3547), c)

def dec.n464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n446(U32.is_lt(c, 2910), c)
    case False{}:
      dec.n463(U32.is_lt(c, 3403), c)

def dec.n465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F42}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F4C}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n465(U32.is_lt(c, 3908), c)
    case False{}:
      dec.n466(U32.is_lt(c, 3918), c)

def dec.n468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F51}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F5B}\u{FB7}"

def dec.n470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F56}\u{FB7}"
    case False{}:
      dec.n469(U32.is_lt(c, 3932), c)

def dec.n471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n468(U32.is_lt(c, 3923), c)
    case False{}:
      dec.n470(U32.is_lt(c, 3928), c)

def dec.n472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n467(U32.is_lt(c, 3917), c)
    case False{}:
      dec.n471(U32.is_lt(c, 3927), c)

def dec.n473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F40}\u{FB5}"

def dec.n474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F71}\u{F72}"

def dec.n475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n473(U32.is_lt(c, 3945), c)
    case False{}:
      dec.n474(U32.is_lt(c, 3955), c)

def dec.n476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F71}\u{F74}"

def dec.n477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{FB3}\u{F80}"

def dec.n478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FB2}\u{F80}"
    case False{}:
      dec.n477(U32.is_lt(c, 3960), c)

def dec.n479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n476(U32.is_lt(c, 3957), c)
    case False{}:
      dec.n478(U32.is_lt(c, 3959), c)

def dec.n480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n475(U32.is_lt(c, 3946), c)
    case False{}:
      dec.n479(U32.is_lt(c, 3958), c)

def dec.n481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n472(U32.is_lt(c, 3922), c)
    case False{}:
      dec.n480(U32.is_lt(c, 3956), c)

def dec.n482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F71}\u{F80}"

def dec.n483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F92}\u{FB7}"

def dec.n484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n482(U32.is_lt(c, 3969), c)
    case False{}:
      dec.n483(U32.is_lt(c, 3987), c)

def dec.n485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F9C}\u{FB7}"

def dec.n486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FA1}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n486(U32.is_lt(c, 4003), c)

def dec.n488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n485(U32.is_lt(c, 3997), c)
    case False{}:
      dec.n487(U32.is_lt(c, 4002), c)

def dec.n489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n484(U32.is_lt(c, 3970), c)
    case False{}:
      dec.n488(U32.is_lt(c, 3998), c)

def dec.n490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FA6}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FAB}\u{FB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n490(U32.is_lt(c, 4008), c)
    case False{}:
      dec.n491(U32.is_lt(c, 4013), c)

def dec.n493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F90}\u{FB5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1B05}\u{1B35}"

def dec.n495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1025}\u{102E}"
    case False{}:
      dec.n494(U32.is_lt(c, 6918), c)

def dec.n496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n493(U32.is_lt(c, 4026), c)
    case False{}:
      dec.n495(U32.is_lt(c, 4135), c)

def dec.n497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n492(U32.is_lt(c, 4012), c)
    case False{}:
      dec.n496(U32.is_lt(c, 4134), c)

def dec.n498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n489(U32.is_lt(c, 3988), c)
    case False{}:
      dec.n497(U32.is_lt(c, 4025), c)

def dec.n499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n481(U32.is_lt(c, 3933), c)
    case False{}:
      dec.n498(U32.is_lt(c, 4007), c)

def dec.n500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n464(U32.is_lt(c, 3264), c)
    case False{}:
      dec.n499(U32.is_lt(c, 3961), c)

def dec.n501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1B07}\u{1B35}"

def dec.n502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1B09}\u{1B35}"

def dec.n503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n501(U32.is_lt(c, 6920), c)
    case False{}:
      dec.n502(U32.is_lt(c, 6922), c)

def dec.n504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1B0B}\u{1B35}"

def dec.n505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B0D}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n505(U32.is_lt(c, 6927), c)

def dec.n507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n504(U32.is_lt(c, 6924), c)
    case False{}:
      dec.n506(U32.is_lt(c, 6926), c)

def dec.n508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n503(U32.is_lt(c, 6921), c)
    case False{}:
      dec.n507(U32.is_lt(c, 6925), c)

def dec.n509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B11}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B3A}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n509(U32.is_lt(c, 6931), c)
    case False{}:
      dec.n510(U32.is_lt(c, 6972), c)

def dec.n512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B3C}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B3F}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B3E}\u{1B35}"
    case False{}:
      dec.n513(U32.is_lt(c, 6978), c)

def dec.n515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n512(U32.is_lt(c, 6974), c)
    case False{}:
      dec.n514(U32.is_lt(c, 6977), c)

def dec.n516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n511(U32.is_lt(c, 6971), c)
    case False{}:
      dec.n515(U32.is_lt(c, 6976), c)

def dec.n517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n508(U32.is_lt(c, 6923), c)
    case False{}:
      dec.n516(U32.is_lt(c, 6973), c)

def dec.n518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B42}\u{1B35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{325}"
    case False{}:
      "\u{61}\u{325}"

def dec.n520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n518(U32.is_lt(c, 6980), c)
    case False{}:
      dec.n519(U32.is_lt(c, 7681), c)

def dec.n521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{42}\u{307}"
    case False{}:
      "\u{62}\u{307}"

def dec.n522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62}\u{323}"
    case False{}:
      "\u{42}\u{331}"

def dec.n523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{42}\u{323}"
    case False{}:
      dec.n522(U32.is_lt(c, 7686), c)

def dec.n524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n521(U32.is_lt(c, 7683), c)
    case False{}:
      dec.n523(U32.is_lt(c, 7685), c)

def dec.n525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n520(U32.is_lt(c, 7680), c)
    case False{}:
      dec.n524(U32.is_lt(c, 7684), c)

def dec.n526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62}\u{331}"
    case False{}:
      "\u{43}\u{327}\u{301}"

def dec.n527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{63}\u{327}\u{301}"
    case False{}:
      "\u{44}\u{307}"

def dec.n528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n526(U32.is_lt(c, 7688), c)
    case False{}:
      dec.n527(U32.is_lt(c, 7690), c)

def dec.n529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{64}\u{307}"
    case False{}:
      "\u{44}\u{323}"

def dec.n530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44}\u{331}"
    case False{}:
      "\u{64}\u{331}"

def dec.n531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{64}\u{323}"
    case False{}:
      dec.n530(U32.is_lt(c, 7695), c)

def dec.n532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n529(U32.is_lt(c, 7692), c)
    case False{}:
      dec.n531(U32.is_lt(c, 7694), c)

def dec.n533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n528(U32.is_lt(c, 7689), c)
    case False{}:
      dec.n532(U32.is_lt(c, 7693), c)

def dec.n534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n525(U32.is_lt(c, 7682), c)
    case False{}:
      dec.n533(U32.is_lt(c, 7691), c)

def dec.n535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n517(U32.is_lt(c, 6930), c)
    case False{}:
      dec.n534(U32.is_lt(c, 7687), c)

def dec.n536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44}\u{327}"
    case False{}:
      "\u{64}\u{327}"

def dec.n537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44}\u{32D}"
    case False{}:
      "\u{64}\u{32D}"

def dec.n538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n536(U32.is_lt(c, 7697), c)
    case False{}:
      dec.n537(U32.is_lt(c, 7699), c)

def dec.n539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{304}\u{300}"
    case False{}:
      "\u{65}\u{304}\u{300}"

def dec.n540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{304}\u{301}"
    case False{}:
      "\u{45}\u{32D}"

def dec.n541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{304}\u{301}"
    case False{}:
      dec.n540(U32.is_lt(c, 7704), c)

def dec.n542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n539(U32.is_lt(c, 7701), c)
    case False{}:
      dec.n541(U32.is_lt(c, 7703), c)

def dec.n543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n538(U32.is_lt(c, 7698), c)
    case False{}:
      dec.n542(U32.is_lt(c, 7702), c)

def dec.n544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{32D}"
    case False{}:
      "\u{45}\u{330}"

def dec.n545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{330}"
    case False{}:
      "\u{45}\u{327}\u{306}"

def dec.n546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n544(U32.is_lt(c, 7706), c)
    case False{}:
      dec.n545(U32.is_lt(c, 7708), c)

def dec.n547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{327}\u{306}"
    case False{}:
      "\u{46}\u{307}"

def dec.n548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{47}\u{304}"
    case False{}:
      "\u{67}\u{304}"

def dec.n549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66}\u{307}"
    case False{}:
      dec.n548(U32.is_lt(c, 7713), c)

def dec.n550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n547(U32.is_lt(c, 7710), c)
    case False{}:
      dec.n549(U32.is_lt(c, 7712), c)

def dec.n551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n546(U32.is_lt(c, 7707), c)
    case False{}:
      dec.n550(U32.is_lt(c, 7711), c)

def dec.n552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n543(U32.is_lt(c, 7700), c)
    case False{}:
      dec.n551(U32.is_lt(c, 7709), c)

def dec.n553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{307}"
    case False{}:
      "\u{68}\u{307}"

def dec.n554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{323}"
    case False{}:
      "\u{68}\u{323}"

def dec.n555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n553(U32.is_lt(c, 7715), c)
    case False{}:
      dec.n554(U32.is_lt(c, 7717), c)

def dec.n556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{308}"
    case False{}:
      "\u{68}\u{308}"

def dec.n557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{68}\u{327}"
    case False{}:
      "\u{48}\u{32E}"

def dec.n558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{48}\u{327}"
    case False{}:
      dec.n557(U32.is_lt(c, 7722), c)

def dec.n559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n556(U32.is_lt(c, 7719), c)
    case False{}:
      dec.n558(U32.is_lt(c, 7721), c)

def dec.n560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n555(U32.is_lt(c, 7716), c)
    case False{}:
      dec.n559(U32.is_lt(c, 7720), c)

def dec.n561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{68}\u{32E}"
    case False{}:
      "\u{49}\u{330}"

def dec.n562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{308}\u{301}"
    case False{}:
      "\u{69}\u{308}\u{301}"

def dec.n563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{330}"
    case False{}:
      dec.n562(U32.is_lt(c, 7727), c)

def dec.n564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n561(U32.is_lt(c, 7724), c)
    case False{}:
      dec.n563(U32.is_lt(c, 7726), c)

def dec.n565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4B}\u{301}"
    case False{}:
      "\u{6B}\u{301}"

def dec.n566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B}\u{323}"
    case False{}:
      "\u{4B}\u{331}"

def dec.n567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4B}\u{323}"
    case False{}:
      dec.n566(U32.is_lt(c, 7732), c)

def dec.n568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n565(U32.is_lt(c, 7729), c)
    case False{}:
      dec.n567(U32.is_lt(c, 7731), c)

def dec.n569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n564(U32.is_lt(c, 7725), c)
    case False{}:
      dec.n568(U32.is_lt(c, 7730), c)

def dec.n570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n560(U32.is_lt(c, 7718), c)
    case False{}:
      dec.n569(U32.is_lt(c, 7728), c)

def dec.n571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n552(U32.is_lt(c, 7705), c)
    case False{}:
      dec.n570(U32.is_lt(c, 7723), c)

def dec.n572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n535(U32.is_lt(c, 6979), c)
    case False{}:
      dec.n571(U32.is_lt(c, 7714), c)

def dec.n573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n500(U32.is_lt(c, 3907), c)
    case False{}:
      dec.n572(U32.is_lt(c, 7696), c)

def dec.n574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n429(U32.is_lt(c, 1243), c)
    case False{}:
      dec.n573(U32.is_lt(c, 6919), c)

def dec.n575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n286(U32.is_lt(c, 348), c)
    case False{}:
      dec.n574(U32.is_lt(c, 2654), c)

def dec.n576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B}\u{331}"
    case False{}:
      "\u{4C}\u{323}"

def dec.n577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C}\u{323}"
    case False{}:
      "\u{4C}\u{323}\u{304}"

def dec.n578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n576(U32.is_lt(c, 7734), c)
    case False{}:
      dec.n577(U32.is_lt(c, 7736), c)

def dec.n579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C}\u{323}\u{304}"
    case False{}:
      "\u{4C}\u{331}"

def dec.n580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C}\u{32D}"
    case False{}:
      "\u{6C}\u{32D}"

def dec.n581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C}\u{331}"
    case False{}:
      dec.n580(U32.is_lt(c, 7741), c)

def dec.n582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n579(U32.is_lt(c, 7738), c)
    case False{}:
      dec.n581(U32.is_lt(c, 7740), c)

def dec.n583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n578(U32.is_lt(c, 7735), c)
    case False{}:
      dec.n582(U32.is_lt(c, 7739), c)

def dec.n584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4D}\u{301}"
    case False{}:
      "\u{6D}\u{301}"

def dec.n585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4D}\u{307}"
    case False{}:
      "\u{6D}\u{307}"

def dec.n586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n584(U32.is_lt(c, 7743), c)
    case False{}:
      dec.n585(U32.is_lt(c, 7745), c)

def dec.n587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4D}\u{323}"
    case False{}:
      "\u{6D}\u{323}"

def dec.n588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{307}"
    case False{}:
      "\u{4E}\u{323}"

def dec.n589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E}\u{307}"
    case False{}:
      dec.n588(U32.is_lt(c, 7750), c)

def dec.n590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n587(U32.is_lt(c, 7747), c)
    case False{}:
      dec.n589(U32.is_lt(c, 7749), c)

def dec.n591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n586(U32.is_lt(c, 7744), c)
    case False{}:
      dec.n590(U32.is_lt(c, 7748), c)

def dec.n592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n583(U32.is_lt(c, 7737), c)
    case False{}:
      dec.n591(U32.is_lt(c, 7746), c)

def dec.n593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{323}"
    case False{}:
      "\u{4E}\u{331}"

def dec.n594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{331}"
    case False{}:
      "\u{4E}\u{32D}"

def dec.n595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n593(U32.is_lt(c, 7752), c)
    case False{}:
      dec.n594(U32.is_lt(c, 7754), c)

def dec.n596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}\u{32D}"
    case False{}:
      "\u{4F}\u{303}\u{301}"

def dec.n597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{303}\u{308}"
    case False{}:
      "\u{6F}\u{303}\u{308}"

def dec.n598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{303}\u{301}"
    case False{}:
      dec.n597(U32.is_lt(c, 7759), c)

def dec.n599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n596(U32.is_lt(c, 7756), c)
    case False{}:
      dec.n598(U32.is_lt(c, 7758), c)

def dec.n600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n595(U32.is_lt(c, 7753), c)
    case False{}:
      dec.n599(U32.is_lt(c, 7757), c)

def dec.n601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{304}\u{300}"
    case False{}:
      "\u{6F}\u{304}\u{300}"

def dec.n602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{304}\u{301}"
    case False{}:
      "\u{6F}\u{304}\u{301}"

def dec.n603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n601(U32.is_lt(c, 7761), c)
    case False{}:
      dec.n602(U32.is_lt(c, 7763), c)

def dec.n604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{50}\u{301}"
    case False{}:
      "\u{70}\u{301}"

def dec.n605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{70}\u{307}"
    case False{}:
      "\u{52}\u{307}"

def dec.n606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{50}\u{307}"
    case False{}:
      dec.n605(U32.is_lt(c, 7768), c)

def dec.n607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n604(U32.is_lt(c, 7765), c)
    case False{}:
      dec.n606(U32.is_lt(c, 7767), c)

def dec.n608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n603(U32.is_lt(c, 7762), c)
    case False{}:
      dec.n607(U32.is_lt(c, 7766), c)

def dec.n609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n600(U32.is_lt(c, 7755), c)
    case False{}:
      dec.n608(U32.is_lt(c, 7764), c)

def dec.n610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n592(U32.is_lt(c, 7742), c)
    case False{}:
      dec.n609(U32.is_lt(c, 7760), c)

def dec.n611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{307}"
    case False{}:
      "\u{52}\u{323}"

def dec.n612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{323}"
    case False{}:
      "\u{52}\u{323}\u{304}"

def dec.n613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n611(U32.is_lt(c, 7770), c)
    case False{}:
      dec.n612(U32.is_lt(c, 7772), c)

def dec.n614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{323}\u{304}"
    case False{}:
      "\u{52}\u{331}"

def dec.n615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{307}"
    case False{}:
      "\u{73}\u{307}"

def dec.n616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72}\u{331}"
    case False{}:
      dec.n615(U32.is_lt(c, 7777), c)

def dec.n617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n614(U32.is_lt(c, 7774), c)
    case False{}:
      dec.n616(U32.is_lt(c, 7776), c)

def dec.n618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n613(U32.is_lt(c, 7771), c)
    case False{}:
      dec.n617(U32.is_lt(c, 7775), c)

def dec.n619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{323}"
    case False{}:
      "\u{73}\u{323}"

def dec.n620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{301}\u{307}"
    case False{}:
      "\u{73}\u{301}\u{307}"

def dec.n621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n619(U32.is_lt(c, 7779), c)
    case False{}:
      dec.n620(U32.is_lt(c, 7781), c)

def dec.n622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{30C}\u{307}"
    case False{}:
      "\u{73}\u{30C}\u{307}"

def dec.n623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73}\u{323}\u{307}"
    case False{}:
      "\u{54}\u{307}"

def dec.n624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53}\u{323}\u{307}"
    case False{}:
      dec.n623(U32.is_lt(c, 7786), c)

def dec.n625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n622(U32.is_lt(c, 7783), c)
    case False{}:
      dec.n624(U32.is_lt(c, 7785), c)

def dec.n626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n621(U32.is_lt(c, 7780), c)
    case False{}:
      dec.n625(U32.is_lt(c, 7784), c)

def dec.n627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n618(U32.is_lt(c, 7773), c)
    case False{}:
      dec.n626(U32.is_lt(c, 7782), c)

def dec.n628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{307}"
    case False{}:
      "\u{54}\u{323}"

def dec.n629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{323}"
    case False{}:
      "\u{54}\u{331}"

def dec.n630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n628(U32.is_lt(c, 7788), c)
    case False{}:
      dec.n629(U32.is_lt(c, 7790), c)

def dec.n631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{331}"
    case False{}:
      "\u{54}\u{32D}"

def dec.n632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{324}"
    case False{}:
      "\u{75}\u{324}"

def dec.n633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{32D}"
    case False{}:
      dec.n632(U32.is_lt(c, 7795), c)

def dec.n634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n631(U32.is_lt(c, 7792), c)
    case False{}:
      dec.n633(U32.is_lt(c, 7794), c)

def dec.n635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n630(U32.is_lt(c, 7789), c)
    case False{}:
      dec.n634(U32.is_lt(c, 7793), c)

def dec.n636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{330}"
    case False{}:
      "\u{75}\u{330}"

def dec.n637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{32D}"
    case False{}:
      "\u{75}\u{32D}"

def dec.n638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n636(U32.is_lt(c, 7797), c)
    case False{}:
      dec.n637(U32.is_lt(c, 7799), c)

def dec.n639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{303}\u{301}"
    case False{}:
      "\u{75}\u{303}\u{301}"

def dec.n640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{304}\u{308}"
    case False{}:
      "\u{56}\u{303}"

def dec.n641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{304}\u{308}"
    case False{}:
      dec.n640(U32.is_lt(c, 7804), c)

def dec.n642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n639(U32.is_lt(c, 7801), c)
    case False{}:
      dec.n641(U32.is_lt(c, 7803), c)

def dec.n643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n638(U32.is_lt(c, 7798), c)
    case False{}:
      dec.n642(U32.is_lt(c, 7802), c)

def dec.n644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n635(U32.is_lt(c, 7791), c)
    case False{}:
      dec.n643(U32.is_lt(c, 7800), c)

def dec.n645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n627(U32.is_lt(c, 7778), c)
    case False{}:
      dec.n644(U32.is_lt(c, 7796), c)

def dec.n646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n610(U32.is_lt(c, 7751), c)
    case False{}:
      dec.n645(U32.is_lt(c, 7787), c)

def dec.n647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76}\u{303}"
    case False{}:
      "\u{56}\u{323}"

def dec.n648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76}\u{323}"
    case False{}:
      "\u{57}\u{300}"

def dec.n649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n647(U32.is_lt(c, 7806), c)
    case False{}:
      dec.n648(U32.is_lt(c, 7808), c)

def dec.n650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{77}\u{300}"
    case False{}:
      "\u{57}\u{301}"

def dec.n651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57}\u{308}"
    case False{}:
      "\u{77}\u{308}"

def dec.n652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{77}\u{301}"
    case False{}:
      dec.n651(U32.is_lt(c, 7813), c)

def dec.n653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n650(U32.is_lt(c, 7810), c)
    case False{}:
      dec.n652(U32.is_lt(c, 7812), c)

def dec.n654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n649(U32.is_lt(c, 7807), c)
    case False{}:
      dec.n653(U32.is_lt(c, 7811), c)

def dec.n655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57}\u{307}"
    case False{}:
      "\u{77}\u{307}"

def dec.n656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57}\u{323}"
    case False{}:
      "\u{77}\u{323}"

def dec.n657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n655(U32.is_lt(c, 7815), c)
    case False{}:
      dec.n656(U32.is_lt(c, 7817), c)

def dec.n658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58}\u{307}"
    case False{}:
      "\u{78}\u{307}"

def dec.n659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{78}\u{308}"
    case False{}:
      "\u{59}\u{307}"

def dec.n660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58}\u{308}"
    case False{}:
      dec.n659(U32.is_lt(c, 7822), c)

def dec.n661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n658(U32.is_lt(c, 7819), c)
    case False{}:
      dec.n660(U32.is_lt(c, 7821), c)

def dec.n662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n657(U32.is_lt(c, 7816), c)
    case False{}:
      dec.n661(U32.is_lt(c, 7820), c)

def dec.n663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n654(U32.is_lt(c, 7809), c)
    case False{}:
      dec.n662(U32.is_lt(c, 7818), c)

def dec.n664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{307}"
    case False{}:
      "\u{5A}\u{302}"

def dec.n665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{302}"
    case False{}:
      "\u{5A}\u{323}"

def dec.n666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n664(U32.is_lt(c, 7824), c)
    case False{}:
      dec.n665(U32.is_lt(c, 7826), c)

def dec.n667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{323}"
    case False{}:
      "\u{5A}\u{331}"

def dec.n668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{68}\u{331}"
    case False{}:
      "\u{74}\u{308}"

def dec.n669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A}\u{331}"
    case False{}:
      dec.n668(U32.is_lt(c, 7831), c)

def dec.n670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n667(U32.is_lt(c, 7828), c)
    case False{}:
      dec.n669(U32.is_lt(c, 7830), c)

def dec.n671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n666(U32.is_lt(c, 7825), c)
    case False{}:
      dec.n670(U32.is_lt(c, 7829), c)

def dec.n672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{77}\u{30A}"
    case False{}:
      "\u{79}\u{30A}"

def dec.n673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{17F}\u{307}"

def dec.n674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n672(U32.is_lt(c, 7833), c)
    case False{}:
      dec.n673(U32.is_lt(c, 7835), c)

def dec.n675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{41}\u{323}"

def dec.n676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{309}"
    case False{}:
      "\u{61}\u{309}"

def dec.n677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{323}"
    case False{}:
      dec.n676(U32.is_lt(c, 7843), c)

def dec.n678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n675(U32.is_lt(c, 7840), c)
    case False{}:
      dec.n677(U32.is_lt(c, 7842), c)

def dec.n679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n674(U32.is_lt(c, 7834), c)
    case False{}:
      dec.n678(U32.is_lt(c, 7841), c)

def dec.n680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n671(U32.is_lt(c, 7827), c)
    case False{}:
      dec.n679(U32.is_lt(c, 7836), c)

def dec.n681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n663(U32.is_lt(c, 7814), c)
    case False{}:
      dec.n680(U32.is_lt(c, 7832), c)

def dec.n682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{302}\u{301}"
    case False{}:
      "\u{61}\u{302}\u{301}"

def dec.n683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{302}\u{300}"
    case False{}:
      "\u{61}\u{302}\u{300}"

def dec.n684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n682(U32.is_lt(c, 7845), c)
    case False{}:
      dec.n683(U32.is_lt(c, 7847), c)

def dec.n685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{302}\u{309}"
    case False{}:
      "\u{61}\u{302}\u{309}"

def dec.n686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{302}\u{303}"
    case False{}:
      "\u{41}\u{323}\u{302}"

def dec.n687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{302}\u{303}"
    case False{}:
      dec.n686(U32.is_lt(c, 7852), c)

def dec.n688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n685(U32.is_lt(c, 7849), c)
    case False{}:
      dec.n687(U32.is_lt(c, 7851), c)

def dec.n689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n684(U32.is_lt(c, 7846), c)
    case False{}:
      dec.n688(U32.is_lt(c, 7850), c)

def dec.n690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{323}\u{302}"
    case False{}:
      "\u{41}\u{306}\u{301}"

def dec.n691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{306}\u{301}"
    case False{}:
      "\u{41}\u{306}\u{300}"

def dec.n692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n690(U32.is_lt(c, 7854), c)
    case False{}:
      dec.n691(U32.is_lt(c, 7856), c)

def dec.n693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{306}\u{300}"
    case False{}:
      "\u{41}\u{306}\u{309}"

def dec.n694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{306}\u{303}"
    case False{}:
      "\u{61}\u{306}\u{303}"

def dec.n695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61}\u{306}\u{309}"
    case False{}:
      dec.n694(U32.is_lt(c, 7861), c)

def dec.n696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n693(U32.is_lt(c, 7858), c)
    case False{}:
      dec.n695(U32.is_lt(c, 7860), c)

def dec.n697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n692(U32.is_lt(c, 7855), c)
    case False{}:
      dec.n696(U32.is_lt(c, 7859), c)

def dec.n698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n689(U32.is_lt(c, 7848), c)
    case False{}:
      dec.n697(U32.is_lt(c, 7857), c)

def dec.n699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{323}\u{306}"
    case False{}:
      "\u{61}\u{323}\u{306}"

def dec.n700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{323}"
    case False{}:
      "\u{65}\u{323}"

def dec.n701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n699(U32.is_lt(c, 7863), c)
    case False{}:
      dec.n700(U32.is_lt(c, 7865), c)

def dec.n702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{309}"
    case False{}:
      "\u{65}\u{309}"

def dec.n703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{303}"
    case False{}:
      "\u{45}\u{302}\u{301}"

def dec.n704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{303}"
    case False{}:
      dec.n703(U32.is_lt(c, 7870), c)

def dec.n705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n702(U32.is_lt(c, 7867), c)
    case False{}:
      dec.n704(U32.is_lt(c, 7869), c)

def dec.n706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n701(U32.is_lt(c, 7864), c)
    case False{}:
      dec.n705(U32.is_lt(c, 7868), c)

def dec.n707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{302}\u{301}"
    case False{}:
      "\u{45}\u{302}\u{300}"

def dec.n708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{302}\u{300}"
    case False{}:
      "\u{45}\u{302}\u{309}"

def dec.n709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n707(U32.is_lt(c, 7872), c)
    case False{}:
      dec.n708(U32.is_lt(c, 7874), c)

def dec.n710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{302}\u{309}"
    case False{}:
      "\u{45}\u{302}\u{303}"

def dec.n711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45}\u{323}\u{302}"
    case False{}:
      "\u{65}\u{323}\u{302}"

def dec.n712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65}\u{302}\u{303}"
    case False{}:
      dec.n711(U32.is_lt(c, 7879), c)

def dec.n713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n710(U32.is_lt(c, 7876), c)
    case False{}:
      dec.n712(U32.is_lt(c, 7878), c)

def dec.n714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n709(U32.is_lt(c, 7873), c)
    case False{}:
      dec.n713(U32.is_lt(c, 7877), c)

def dec.n715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n706(U32.is_lt(c, 7866), c)
    case False{}:
      dec.n714(U32.is_lt(c, 7875), c)

def dec.n716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n698(U32.is_lt(c, 7853), c)
    case False{}:
      dec.n715(U32.is_lt(c, 7871), c)

def dec.n717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n681(U32.is_lt(c, 7823), c)
    case False{}:
      dec.n716(U32.is_lt(c, 7862), c)

def dec.n718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n646(U32.is_lt(c, 7769), c)
    case False{}:
      dec.n717(U32.is_lt(c, 7844), c)

def dec.n719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{309}"
    case False{}:
      "\u{69}\u{309}"

def dec.n720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49}\u{323}"
    case False{}:
      "\u{69}\u{323}"

def dec.n721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n719(U32.is_lt(c, 7881), c)
    case False{}:
      dec.n720(U32.is_lt(c, 7883), c)

def dec.n722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{323}"
    case False{}:
      "\u{6F}\u{323}"

def dec.n723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{309}"
    case False{}:
      "\u{4F}\u{302}\u{301}"

def dec.n724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{309}"
    case False{}:
      dec.n723(U32.is_lt(c, 7888), c)

def dec.n725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n722(U32.is_lt(c, 7885), c)
    case False{}:
      dec.n724(U32.is_lt(c, 7887), c)

def dec.n726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n721(U32.is_lt(c, 7882), c)
    case False{}:
      dec.n725(U32.is_lt(c, 7886), c)

def dec.n727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{302}\u{301}"
    case False{}:
      "\u{4F}\u{302}\u{300}"

def dec.n728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{302}\u{300}"
    case False{}:
      "\u{4F}\u{302}\u{309}"

def dec.n729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n727(U32.is_lt(c, 7890), c)
    case False{}:
      dec.n728(U32.is_lt(c, 7892), c)

def dec.n730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{302}\u{309}"
    case False{}:
      "\u{4F}\u{302}\u{303}"

def dec.n731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{323}\u{302}"
    case False{}:
      "\u{6F}\u{323}\u{302}"

def dec.n732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{302}\u{303}"
    case False{}:
      dec.n731(U32.is_lt(c, 7897), c)

def dec.n733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n730(U32.is_lt(c, 7894), c)
    case False{}:
      dec.n732(U32.is_lt(c, 7896), c)

def dec.n734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n729(U32.is_lt(c, 7891), c)
    case False{}:
      dec.n733(U32.is_lt(c, 7895), c)

def dec.n735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n726(U32.is_lt(c, 7884), c)
    case False{}:
      dec.n734(U32.is_lt(c, 7893), c)

def dec.n736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{31B}\u{301}"
    case False{}:
      "\u{6F}\u{31B}\u{301}"

def dec.n737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{31B}\u{300}"
    case False{}:
      "\u{6F}\u{31B}\u{300}"

def dec.n738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n736(U32.is_lt(c, 7899), c)
    case False{}:
      dec.n737(U32.is_lt(c, 7901), c)

def dec.n739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{31B}\u{309}"
    case False{}:
      "\u{6F}\u{31B}\u{309}"

def dec.n740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{31B}\u{303}"
    case False{}:
      "\u{4F}\u{31B}\u{323}"

def dec.n741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F}\u{31B}\u{303}"
    case False{}:
      dec.n740(U32.is_lt(c, 7906), c)

def dec.n742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n739(U32.is_lt(c, 7903), c)
    case False{}:
      dec.n741(U32.is_lt(c, 7905), c)

def dec.n743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n738(U32.is_lt(c, 7900), c)
    case False{}:
      dec.n742(U32.is_lt(c, 7904), c)

def dec.n744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}\u{31B}\u{323}"
    case False{}:
      "\u{55}\u{323}"

def dec.n745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{323}"
    case False{}:
      "\u{55}\u{309}"

def dec.n746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n744(U32.is_lt(c, 7908), c)
    case False{}:
      dec.n745(U32.is_lt(c, 7910), c)

def dec.n747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{309}"
    case False{}:
      "\u{55}\u{31B}\u{301}"

def dec.n748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{31B}\u{300}"
    case False{}:
      "\u{75}\u{31B}\u{300}"

def dec.n749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}\u{31B}\u{301}"
    case False{}:
      dec.n748(U32.is_lt(c, 7915), c)

def dec.n750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n747(U32.is_lt(c, 7912), c)
    case False{}:
      dec.n749(U32.is_lt(c, 7914), c)

def dec.n751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n746(U32.is_lt(c, 7909), c)
    case False{}:
      dec.n750(U32.is_lt(c, 7913), c)

def dec.n752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n743(U32.is_lt(c, 7902), c)
    case False{}:
      dec.n751(U32.is_lt(c, 7911), c)

def dec.n753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n735(U32.is_lt(c, 7889), c)
    case False{}:
      dec.n752(U32.is_lt(c, 7907), c)

def dec.n754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{31B}\u{309}"
    case False{}:
      "\u{75}\u{31B}\u{309}"

def dec.n755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{31B}\u{303}"
    case False{}:
      "\u{75}\u{31B}\u{303}"

def dec.n756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n754(U32.is_lt(c, 7917), c)
    case False{}:
      dec.n755(U32.is_lt(c, 7919), c)

def dec.n757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55}\u{31B}\u{323}"
    case False{}:
      "\u{75}\u{31B}\u{323}"

def dec.n758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{300}"
    case False{}:
      "\u{59}\u{323}"

def dec.n759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{59}\u{300}"
    case False{}:
      dec.n758(U32.is_lt(c, 7924), c)

def dec.n760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n757(U32.is_lt(c, 7921), c)
    case False{}:
      dec.n759(U32.is_lt(c, 7923), c)

def dec.n761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n756(U32.is_lt(c, 7918), c)
    case False{}:
      dec.n760(U32.is_lt(c, 7922), c)

def dec.n762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{323}"
    case False{}:
      "\u{59}\u{309}"

def dec.n763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{309}"
    case False{}:
      "\u{59}\u{303}"

def dec.n764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n762(U32.is_lt(c, 7926), c)
    case False{}:
      dec.n763(U32.is_lt(c, 7928), c)

def dec.n765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{303}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}"
    case False{}:
      "\u{3B1}\u{313}\u{300}"

def dec.n767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{313}"
    case False{}:
      dec.n766(U32.is_lt(c, 7938), c)

def dec.n768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n765(U32.is_lt(c, 7930), c)
    case False{}:
      dec.n767(U32.is_lt(c, 7937), c)

def dec.n769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n764(U32.is_lt(c, 7927), c)
    case False{}:
      dec.n768(U32.is_lt(c, 7936), c)

def dec.n770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n761(U32.is_lt(c, 7920), c)
    case False{}:
      dec.n769(U32.is_lt(c, 7929), c)

def dec.n771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}\u{300}"
    case False{}:
      "\u{3B1}\u{313}\u{301}"

def dec.n772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}\u{301}"
    case False{}:
      "\u{3B1}\u{313}\u{342}"

def dec.n773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n771(U32.is_lt(c, 7940), c)
    case False{}:
      dec.n772(U32.is_lt(c, 7942), c)

def dec.n774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}\u{342}"
    case False{}:
      "\u{391}\u{313}"

def dec.n775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{313}\u{300}"
    case False{}:
      "\u{391}\u{314}\u{300}"

def dec.n776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{314}"
    case False{}:
      dec.n775(U32.is_lt(c, 7947), c)

def dec.n777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n774(U32.is_lt(c, 7944), c)
    case False{}:
      dec.n776(U32.is_lt(c, 7946), c)

def dec.n778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n773(U32.is_lt(c, 7941), c)
    case False{}:
      dec.n777(U32.is_lt(c, 7945), c)

def dec.n779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{313}\u{301}"
    case False{}:
      "\u{391}\u{314}\u{301}"

def dec.n780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{313}\u{342}"
    case False{}:
      "\u{391}\u{314}\u{342}"

def dec.n781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n779(U32.is_lt(c, 7949), c)
    case False{}:
      dec.n780(U32.is_lt(c, 7951), c)

def dec.n782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}\u{313}"
    case False{}:
      "\u{3B5}\u{314}"

def dec.n783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}\u{314}\u{300}"
    case False{}:
      "\u{3B5}\u{313}\u{301}"

def dec.n784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}\u{313}\u{300}"
    case False{}:
      dec.n783(U32.is_lt(c, 7956), c)

def dec.n785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n782(U32.is_lt(c, 7953), c)
    case False{}:
      dec.n784(U32.is_lt(c, 7955), c)

def dec.n786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n781(U32.is_lt(c, 7950), c)
    case False{}:
      dec.n785(U32.is_lt(c, 7954), c)

def dec.n787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n778(U32.is_lt(c, 7943), c)
    case False{}:
      dec.n786(U32.is_lt(c, 7952), c)

def dec.n788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n770(U32.is_lt(c, 7925), c)
    case False{}:
      dec.n787(U32.is_lt(c, 7948), c)

def dec.n789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n753(U32.is_lt(c, 7898), c)
    case False{}:
      dec.n788(U32.is_lt(c, 7939), c)

def dec.n790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}\u{314}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{313}"
    case False{}:
      "\u{395}\u{314}"

def dec.n792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n790(U32.is_lt(c, 7958), c)
    case False{}:
      dec.n791(U32.is_lt(c, 7961), c)

def dec.n793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{313}\u{300}"
    case False{}:
      "\u{395}\u{314}\u{300}"

def dec.n794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{314}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{313}\u{301}"
    case False{}:
      dec.n794(U32.is_lt(c, 7966), c)

def dec.n796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n793(U32.is_lt(c, 7963), c)
    case False{}:
      dec.n795(U32.is_lt(c, 7965), c)

def dec.n797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n792(U32.is_lt(c, 7960), c)
    case False{}:
      dec.n796(U32.is_lt(c, 7964), c)

def dec.n798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}"
    case False{}:
      "\u{3B7}\u{314}"

def dec.n799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{300}"
    case False{}:
      "\u{3B7}\u{314}\u{300}"

def dec.n800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n798(U32.is_lt(c, 7969), c)
    case False{}:
      dec.n799(U32.is_lt(c, 7971), c)

def dec.n801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{301}"
    case False{}:
      "\u{3B7}\u{314}\u{301}"

def dec.n802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{314}\u{342}"
    case False{}:
      "\u{397}\u{313}"

def dec.n803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{342}"
    case False{}:
      dec.n802(U32.is_lt(c, 7976), c)

def dec.n804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n801(U32.is_lt(c, 7973), c)
    case False{}:
      dec.n803(U32.is_lt(c, 7975), c)

def dec.n805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n800(U32.is_lt(c, 7970), c)
    case False{}:
      dec.n804(U32.is_lt(c, 7974), c)

def dec.n806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n797(U32.is_lt(c, 7962), c)
    case False{}:
      dec.n805(U32.is_lt(c, 7972), c)

def dec.n807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}"
    case False{}:
      "\u{397}\u{313}\u{300}"

def dec.n808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{300}"
    case False{}:
      "\u{397}\u{313}\u{301}"

def dec.n809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n807(U32.is_lt(c, 7978), c)
    case False{}:
      dec.n808(U32.is_lt(c, 7980), c)

def dec.n810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{301}"
    case False{}:
      "\u{397}\u{313}\u{342}"

def dec.n811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{313}"
    case False{}:
      "\u{3B9}\u{314}"

def dec.n812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{342}"
    case False{}:
      dec.n811(U32.is_lt(c, 7985), c)

def dec.n813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n810(U32.is_lt(c, 7982), c)
    case False{}:
      dec.n812(U32.is_lt(c, 7984), c)

def dec.n814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n809(U32.is_lt(c, 7979), c)
    case False{}:
      dec.n813(U32.is_lt(c, 7983), c)

def dec.n815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{313}\u{300}"
    case False{}:
      "\u{3B9}\u{314}\u{300}"

def dec.n816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{313}\u{301}"
    case False{}:
      "\u{3B9}\u{314}\u{301}"

def dec.n817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n815(U32.is_lt(c, 7987), c)
    case False{}:
      dec.n816(U32.is_lt(c, 7989), c)

def dec.n818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{313}\u{342}"
    case False{}:
      "\u{3B9}\u{314}\u{342}"

def dec.n819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{314}"
    case False{}:
      "\u{399}\u{313}\u{300}"

def dec.n820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{313}"
    case False{}:
      dec.n819(U32.is_lt(c, 7994), c)

def dec.n821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n818(U32.is_lt(c, 7991), c)
    case False{}:
      dec.n820(U32.is_lt(c, 7993), c)

def dec.n822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n817(U32.is_lt(c, 7988), c)
    case False{}:
      dec.n821(U32.is_lt(c, 7992), c)

def dec.n823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n814(U32.is_lt(c, 7981), c)
    case False{}:
      dec.n822(U32.is_lt(c, 7990), c)

def dec.n824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n806(U32.is_lt(c, 7968), c)
    case False{}:
      dec.n823(U32.is_lt(c, 7986), c)

def dec.n825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{314}\u{300}"
    case False{}:
      "\u{399}\u{313}\u{301}"

def dec.n826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{314}\u{301}"
    case False{}:
      "\u{399}\u{313}\u{342}"

def dec.n827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n825(U32.is_lt(c, 7996), c)
    case False{}:
      dec.n826(U32.is_lt(c, 7998), c)

def dec.n828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{314}\u{342}"
    case False{}:
      "\u{3BF}\u{313}"

def dec.n829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BF}\u{313}\u{300}"
    case False{}:
      "\u{3BF}\u{314}\u{300}"

def dec.n830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BF}\u{314}"
    case False{}:
      dec.n829(U32.is_lt(c, 8003), c)

def dec.n831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n828(U32.is_lt(c, 8000), c)
    case False{}:
      dec.n830(U32.is_lt(c, 8002), c)

def dec.n832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n827(U32.is_lt(c, 7997), c)
    case False{}:
      dec.n831(U32.is_lt(c, 8001), c)

def dec.n833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BF}\u{313}\u{301}"
    case False{}:
      "\u{3BF}\u{314}\u{301}"

def dec.n834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{39F}\u{313}"

def dec.n835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n833(U32.is_lt(c, 8005), c)
    case False{}:
      dec.n834(U32.is_lt(c, 8008), c)

def dec.n836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{39F}\u{314}"
    case False{}:
      "\u{39F}\u{313}\u{300}"

def dec.n837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{39F}\u{313}\u{301}"
    case False{}:
      "\u{39F}\u{314}\u{301}"

def dec.n838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{39F}\u{314}\u{300}"
    case False{}:
      dec.n837(U32.is_lt(c, 8013), c)

def dec.n839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n836(U32.is_lt(c, 8010), c)
    case False{}:
      dec.n838(U32.is_lt(c, 8012), c)

def dec.n840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n835(U32.is_lt(c, 8006), c)
    case False{}:
      dec.n839(U32.is_lt(c, 8011), c)

def dec.n841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n832(U32.is_lt(c, 7999), c)
    case False{}:
      dec.n840(U32.is_lt(c, 8009), c)

def dec.n842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C5}\u{313}"

def dec.n843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{314}"
    case False{}:
      "\u{3C5}\u{313}\u{300}"

def dec.n844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n842(U32.is_lt(c, 8016), c)
    case False{}:
      dec.n843(U32.is_lt(c, 8018), c)

def dec.n845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{314}\u{300}"
    case False{}:
      "\u{3C5}\u{313}\u{301}"

def dec.n846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{313}\u{342}"
    case False{}:
      "\u{3C5}\u{314}\u{342}"

def dec.n847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{314}\u{301}"
    case False{}:
      dec.n846(U32.is_lt(c, 8023), c)

def dec.n848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n845(U32.is_lt(c, 8020), c)
    case False{}:
      dec.n847(U32.is_lt(c, 8022), c)

def dec.n849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n844(U32.is_lt(c, 8017), c)
    case False{}:
      dec.n848(U32.is_lt(c, 8021), c)

def dec.n850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3A5}\u{314}"

def dec.n851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{314}\u{300}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n851(U32.is_lt(c, 8028), c)

def dec.n853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n850(U32.is_lt(c, 8025), c)
    case False{}:
      dec.n852(U32.is_lt(c, 8027), c)

def dec.n854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{314}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}"
    case False{}:
      "\u{3C9}\u{314}"

def dec.n856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{314}\u{342}"
    case False{}:
      dec.n855(U32.is_lt(c, 8033), c)

def dec.n857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n854(U32.is_lt(c, 8030), c)
    case False{}:
      dec.n856(U32.is_lt(c, 8032), c)

def dec.n858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n853(U32.is_lt(c, 8026), c)
    case False{}:
      dec.n857(U32.is_lt(c, 8031), c)

def dec.n859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n849(U32.is_lt(c, 8019), c)
    case False{}:
      dec.n858(U32.is_lt(c, 8029), c)

def dec.n860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n841(U32.is_lt(c, 8004), c)
    case False{}:
      dec.n859(U32.is_lt(c, 8024), c)

def dec.n861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n824(U32.is_lt(c, 7977), c)
    case False{}:
      dec.n860(U32.is_lt(c, 8014), c)

def dec.n862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n789(U32.is_lt(c, 7916), c)
    case False{}:
      dec.n861(U32.is_lt(c, 7995), c)

def dec.n863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n718(U32.is_lt(c, 7805), c)
    case False{}:
      dec.n862(U32.is_lt(c, 7957), c)

def dec.n864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{300}"
    case False{}:
      "\u{3C9}\u{314}\u{300}"

def dec.n865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{301}"
    case False{}:
      "\u{3C9}\u{314}\u{301}"

def dec.n866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n864(U32.is_lt(c, 8035), c)
    case False{}:
      dec.n865(U32.is_lt(c, 8037), c)

def dec.n867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{342}"
    case False{}:
      "\u{3C9}\u{314}\u{342}"

def dec.n868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}"
    case False{}:
      "\u{3A9}\u{313}\u{300}"

def dec.n869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{313}"
    case False{}:
      dec.n868(U32.is_lt(c, 8042), c)

def dec.n870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n867(U32.is_lt(c, 8039), c)
    case False{}:
      dec.n869(U32.is_lt(c, 8041), c)

def dec.n871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n866(U32.is_lt(c, 8036), c)
    case False{}:
      dec.n870(U32.is_lt(c, 8040), c)

def dec.n872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{300}"
    case False{}:
      "\u{3A9}\u{313}\u{301}"

def dec.n873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{301}"
    case False{}:
      "\u{3A9}\u{313}\u{342}"

def dec.n874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n872(U32.is_lt(c, 8044), c)
    case False{}:
      dec.n873(U32.is_lt(c, 8046), c)

def dec.n875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{342}"
    case False{}:
      "\u{3B1}\u{300}"

def dec.n876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}\u{300}"
    case False{}:
      "\u{3B5}\u{301}"

def dec.n877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{301}"
    case False{}:
      dec.n876(U32.is_lt(c, 8051), c)

def dec.n878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n875(U32.is_lt(c, 8048), c)
    case False{}:
      dec.n877(U32.is_lt(c, 8050), c)

def dec.n879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n874(U32.is_lt(c, 8045), c)
    case False{}:
      dec.n878(U32.is_lt(c, 8049), c)

def dec.n880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n871(U32.is_lt(c, 8038), c)
    case False{}:
      dec.n879(U32.is_lt(c, 8047), c)

def dec.n881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{300}"
    case False{}:
      "\u{3B7}\u{301}"

def dec.n882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{300}"
    case False{}:
      "\u{3B9}\u{301}"

def dec.n883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n881(U32.is_lt(c, 8053), c)
    case False{}:
      dec.n882(U32.is_lt(c, 8055), c)

def dec.n884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BF}\u{300}"
    case False{}:
      "\u{3BF}\u{301}"

def dec.n885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{301}"
    case False{}:
      "\u{3C9}\u{300}"

def dec.n886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{300}"
    case False{}:
      dec.n885(U32.is_lt(c, 8060), c)

def dec.n887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n884(U32.is_lt(c, 8057), c)
    case False{}:
      dec.n886(U32.is_lt(c, 8059), c)

def dec.n888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n883(U32.is_lt(c, 8054), c)
    case False{}:
      dec.n887(U32.is_lt(c, 8058), c)

def dec.n889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{313}\u{345}"
    case False{}:
      "\u{3B1}\u{314}\u{345}"

def dec.n891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n889(U32.is_lt(c, 8062), c)
    case False{}:
      dec.n890(U32.is_lt(c, 8065), c)

def dec.n892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{313}\u{300}\u{345}"
    case False{}:
      "\u{3B1}\u{314}\u{300}\u{345}"

def dec.n893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}\u{301}\u{345}"
    case False{}:
      "\u{3B1}\u{313}\u{342}\u{345}"

def dec.n894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{313}\u{301}\u{345}"
    case False{}:
      dec.n893(U32.is_lt(c, 8070), c)

def dec.n895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n892(U32.is_lt(c, 8067), c)
    case False{}:
      dec.n894(U32.is_lt(c, 8069), c)

def dec.n896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n891(U32.is_lt(c, 8064), c)
    case False{}:
      dec.n895(U32.is_lt(c, 8068), c)

def dec.n897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n888(U32.is_lt(c, 8056), c)
    case False{}:
      dec.n896(U32.is_lt(c, 8066), c)

def dec.n898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n880(U32.is_lt(c, 8043), c)
    case False{}:
      dec.n897(U32.is_lt(c, 8061), c)

def dec.n899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{314}\u{342}\u{345}"
    case False{}:
      "\u{391}\u{313}\u{345}"

def dec.n900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{314}\u{345}"
    case False{}:
      "\u{391}\u{313}\u{300}\u{345}"

def dec.n901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n899(U32.is_lt(c, 8072), c)
    case False{}:
      dec.n900(U32.is_lt(c, 8074), c)

def dec.n902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{314}\u{300}\u{345}"
    case False{}:
      "\u{391}\u{313}\u{301}\u{345}"

def dec.n903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{313}\u{342}\u{345}"
    case False{}:
      "\u{391}\u{314}\u{342}\u{345}"

def dec.n904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{314}\u{301}\u{345}"
    case False{}:
      dec.n903(U32.is_lt(c, 8079), c)

def dec.n905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n902(U32.is_lt(c, 8076), c)
    case False{}:
      dec.n904(U32.is_lt(c, 8078), c)

def dec.n906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n901(U32.is_lt(c, 8073), c)
    case False{}:
      dec.n905(U32.is_lt(c, 8077), c)

def dec.n907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{345}"
    case False{}:
      "\u{3B7}\u{314}\u{345}"

def dec.n908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{300}\u{345}"
    case False{}:
      "\u{3B7}\u{314}\u{300}\u{345}"

def dec.n909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n907(U32.is_lt(c, 8081), c)
    case False{}:
      dec.n908(U32.is_lt(c, 8083), c)

def dec.n910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{301}\u{345}"
    case False{}:
      "\u{3B7}\u{314}\u{301}\u{345}"

def dec.n911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{314}\u{342}\u{345}"
    case False{}:
      "\u{397}\u{313}\u{345}"

def dec.n912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{313}\u{342}\u{345}"
    case False{}:
      dec.n911(U32.is_lt(c, 8088), c)

def dec.n913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n910(U32.is_lt(c, 8085), c)
    case False{}:
      dec.n912(U32.is_lt(c, 8087), c)

def dec.n914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n909(U32.is_lt(c, 8082), c)
    case False{}:
      dec.n913(U32.is_lt(c, 8086), c)

def dec.n915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n906(U32.is_lt(c, 8075), c)
    case False{}:
      dec.n914(U32.is_lt(c, 8084), c)

def dec.n916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{345}"
    case False{}:
      "\u{397}\u{313}\u{300}\u{345}"

def dec.n917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{300}\u{345}"
    case False{}:
      "\u{397}\u{313}\u{301}\u{345}"

def dec.n918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n916(U32.is_lt(c, 8090), c)
    case False{}:
      dec.n917(U32.is_lt(c, 8092), c)

def dec.n919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{301}\u{345}"
    case False{}:
      "\u{397}\u{313}\u{342}\u{345}"

def dec.n920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{345}"
    case False{}:
      "\u{3C9}\u{314}\u{345}"

def dec.n921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{314}\u{342}\u{345}"
    case False{}:
      dec.n920(U32.is_lt(c, 8097), c)

def dec.n922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n919(U32.is_lt(c, 8094), c)
    case False{}:
      dec.n921(U32.is_lt(c, 8096), c)

def dec.n923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n918(U32.is_lt(c, 8091), c)
    case False{}:
      dec.n922(U32.is_lt(c, 8095), c)

def dec.n924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{300}\u{345}"
    case False{}:
      "\u{3C9}\u{314}\u{300}\u{345}"

def dec.n925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{301}\u{345}"
    case False{}:
      "\u{3C9}\u{314}\u{301}\u{345}"

def dec.n926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n924(U32.is_lt(c, 8099), c)
    case False{}:
      dec.n925(U32.is_lt(c, 8101), c)

def dec.n927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{313}\u{342}\u{345}"
    case False{}:
      "\u{3C9}\u{314}\u{342}\u{345}"

def dec.n928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{345}"
    case False{}:
      "\u{3A9}\u{313}\u{300}\u{345}"

def dec.n929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{313}\u{345}"
    case False{}:
      dec.n928(U32.is_lt(c, 8106), c)

def dec.n930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n927(U32.is_lt(c, 8103), c)
    case False{}:
      dec.n929(U32.is_lt(c, 8105), c)

def dec.n931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n926(U32.is_lt(c, 8100), c)
    case False{}:
      dec.n930(U32.is_lt(c, 8104), c)

def dec.n932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n923(U32.is_lt(c, 8093), c)
    case False{}:
      dec.n931(U32.is_lt(c, 8102), c)

def dec.n933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n915(U32.is_lt(c, 8080), c)
    case False{}:
      dec.n932(U32.is_lt(c, 8098), c)

def dec.n934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n898(U32.is_lt(c, 8052), c)
    case False{}:
      dec.n933(U32.is_lt(c, 8089), c)

def dec.n935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{300}\u{345}"
    case False{}:
      "\u{3A9}\u{313}\u{301}\u{345}"

def dec.n936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{301}\u{345}"
    case False{}:
      "\u{3A9}\u{313}\u{342}\u{345}"

def dec.n937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n935(U32.is_lt(c, 8108), c)
    case False{}:
      dec.n936(U32.is_lt(c, 8110), c)

def dec.n938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{314}\u{342}\u{345}"
    case False{}:
      "\u{3B1}\u{306}"

def dec.n939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{300}\u{345}"
    case False{}:
      "\u{3B1}\u{345}"

def dec.n940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{304}"
    case False{}:
      dec.n939(U32.is_lt(c, 8115), c)

def dec.n941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n938(U32.is_lt(c, 8112), c)
    case False{}:
      dec.n940(U32.is_lt(c, 8114), c)

def dec.n942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n937(U32.is_lt(c, 8109), c)
    case False{}:
      dec.n941(U32.is_lt(c, 8113), c)

def dec.n943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{301}\u{345}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{342}"
    case False{}:
      "\u{3B1}\u{342}\u{345}"

def dec.n945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n943(U32.is_lt(c, 8117), c)
    case False{}:
      dec.n944(U32.is_lt(c, 8119), c)

def dec.n946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{306}"
    case False{}:
      "\u{391}\u{304}"

def dec.n947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{301}"
    case False{}:
      "\u{391}\u{345}"

def dec.n948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{391}\u{300}"
    case False{}:
      dec.n947(U32.is_lt(c, 8124), c)

def dec.n949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n946(U32.is_lt(c, 8121), c)
    case False{}:
      dec.n948(U32.is_lt(c, 8123), c)

def dec.n950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n945(U32.is_lt(c, 8118), c)
    case False{}:
      dec.n949(U32.is_lt(c, 8122), c)

def dec.n951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n942(U32.is_lt(c, 8111), c)
    case False{}:
      dec.n950(U32.is_lt(c, 8120), c)

def dec.n952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B9}"

def dec.n953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A8}\u{342}"

def dec.n954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n952(U32.is_lt(c, 8126), c)
    case False{}:
      dec.n953(U32.is_lt(c, 8129), c)

def dec.n955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{300}\u{345}"
    case False{}:
      "\u{3B7}\u{345}"

def dec.n956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B7}\u{342}"

def dec.n957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{301}\u{345}"
    case False{}:
      dec.n956(U32.is_lt(c, 8134), c)

def dec.n958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n955(U32.is_lt(c, 8131), c)
    case False{}:
      dec.n957(U32.is_lt(c, 8133), c)

def dec.n959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n954(U32.is_lt(c, 8127), c)
    case False{}:
      dec.n958(U32.is_lt(c, 8132), c)

def dec.n960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{342}\u{345}"
    case False{}:
      "\u{395}\u{300}"

def dec.n961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{395}\u{301}"
    case False{}:
      "\u{397}\u{300}"

def dec.n962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n960(U32.is_lt(c, 8136), c)
    case False{}:
      dec.n961(U32.is_lt(c, 8138), c)

def dec.n963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{397}\u{301}"
    case False{}:
      "\u{397}\u{345}"

def dec.n964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FBF}\u{301}"
    case False{}:
      "\u{1FBF}\u{342}"

def dec.n965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FBF}\u{300}"
    case False{}:
      dec.n964(U32.is_lt(c, 8143), c)

def dec.n966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n963(U32.is_lt(c, 8140), c)
    case False{}:
      dec.n965(U32.is_lt(c, 8142), c)

def dec.n967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n962(U32.is_lt(c, 8137), c)
    case False{}:
      dec.n966(U32.is_lt(c, 8141), c)

def dec.n968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n959(U32.is_lt(c, 8130), c)
    case False{}:
      dec.n967(U32.is_lt(c, 8139), c)

def dec.n969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n951(U32.is_lt(c, 8116), c)
    case False{}:
      dec.n968(U32.is_lt(c, 8135), c)

def dec.n970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{306}"
    case False{}:
      "\u{3B9}\u{304}"

def dec.n971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}\u{300}"
    case False{}:
      "\u{3B9}\u{308}\u{301}"

def dec.n972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n970(U32.is_lt(c, 8145), c)
    case False{}:
      dec.n971(U32.is_lt(c, 8147), c)

def dec.n973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B9}\u{342}"

def dec.n974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{306}"
    case False{}:
      "\u{399}\u{304}"

def dec.n975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}\u{342}"
    case False{}:
      dec.n974(U32.is_lt(c, 8153), c)

def dec.n976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n973(U32.is_lt(c, 8150), c)
    case False{}:
      dec.n975(U32.is_lt(c, 8152), c)

def dec.n977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n972(U32.is_lt(c, 8146), c)
    case False{}:
      dec.n976(U32.is_lt(c, 8151), c)

def dec.n978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{399}\u{300}"
    case False{}:
      "\u{399}\u{301}"

def dec.n979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1FFE}\u{300}"

def dec.n980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n978(U32.is_lt(c, 8155), c)
    case False{}:
      dec.n979(U32.is_lt(c, 8157), c)

def dec.n981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FFE}\u{301}"
    case False{}:
      "\u{1FFE}\u{342}"

def dec.n982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{304}"
    case False{}:
      "\u{3C5}\u{308}\u{300}"

def dec.n983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{306}"
    case False{}:
      dec.n982(U32.is_lt(c, 8162), c)

def dec.n984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n981(U32.is_lt(c, 8159), c)
    case False{}:
      dec.n983(U32.is_lt(c, 8161), c)

def dec.n985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n980(U32.is_lt(c, 8156), c)
    case False{}:
      dec.n984(U32.is_lt(c, 8160), c)

def dec.n986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n977(U32.is_lt(c, 8148), c)
    case False{}:
      dec.n985(U32.is_lt(c, 8158), c)

def dec.n987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{301}"
    case False{}:
      "\u{3C1}\u{313}"

def dec.n988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C1}\u{314}"
    case False{}:
      "\u{3C5}\u{342}"

def dec.n989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n987(U32.is_lt(c, 8164), c)
    case False{}:
      dec.n988(U32.is_lt(c, 8166), c)

def dec.n990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{342}"
    case False{}:
      "\u{3A5}\u{306}"

def dec.n991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{300}"
    case False{}:
      "\u{3A5}\u{301}"

def dec.n992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A5}\u{304}"
    case False{}:
      dec.n991(U32.is_lt(c, 8171), c)

def dec.n993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n990(U32.is_lt(c, 8168), c)
    case False{}:
      dec.n992(U32.is_lt(c, 8170), c)

def dec.n994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n989(U32.is_lt(c, 8165), c)
    case False{}:
      dec.n993(U32.is_lt(c, 8169), c)

def dec.n995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A1}\u{314}"
    case False{}:
      "\u{A8}\u{300}"

def dec.n996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A8}\u{301}"
    case False{}:
      "\u{60}"

def dec.n997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n995(U32.is_lt(c, 8173), c)
    case False{}:
      dec.n996(U32.is_lt(c, 8175), c)

def dec.n998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C9}\u{300}\u{345}"

def dec.n999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{301}\u{345}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{345}"
    case False{}:
      dec.n999(U32.is_lt(c, 8181), c)

def dec.n1001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n998(U32.is_lt(c, 8178), c)
    case False{}:
      dec.n1000(U32.is_lt(c, 8180), c)

def dec.n1002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n997(U32.is_lt(c, 8174), c)
    case False{}:
      dec.n1001(U32.is_lt(c, 8179), c)

def dec.n1003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n994(U32.is_lt(c, 8167), c)
    case False{}:
      dec.n1002(U32.is_lt(c, 8176), c)

def dec.n1004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n986(U32.is_lt(c, 8154), c)
    case False{}:
      dec.n1003(U32.is_lt(c, 8172), c)

def dec.n1005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n969(U32.is_lt(c, 8125), c)
    case False{}:
      dec.n1004(U32.is_lt(c, 8163), c)

def dec.n1006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n934(U32.is_lt(c, 8071), c)
    case False{}:
      dec.n1005(U32.is_lt(c, 8144), c)

def dec.n1007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{342}"
    case False{}:
      "\u{3C9}\u{342}\u{345}"

def dec.n1008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{39F}\u{300}"
    case False{}:
      "\u{39F}\u{301}"

def dec.n1009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1007(U32.is_lt(c, 8183), c)
    case False{}:
      dec.n1008(U32.is_lt(c, 8185), c)

def dec.n1010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{300}"
    case False{}:
      "\u{3A9}\u{301}"

def dec.n1011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{B4}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A9}\u{345}"
    case False{}:
      dec.n1011(U32.is_lt(c, 8190), c)

def dec.n1013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1010(U32.is_lt(c, 8187), c)
    case False{}:
      dec.n1012(U32.is_lt(c, 8189), c)

def dec.n1014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1009(U32.is_lt(c, 8184), c)
    case False{}:
      dec.n1013(U32.is_lt(c, 8188), c)

def dec.n1015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2002}"
    case False{}:
      "\u{2003}"

def dec.n1016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3A9}"

def dec.n1017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1015(U32.is_lt(c, 8193), c)
    case False{}:
      dec.n1016(U32.is_lt(c, 8486), c)

def dec.n1018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B}"

def dec.n1019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2190}\u{338}"

def dec.n1020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{41}\u{30A}"
    case False{}:
      dec.n1019(U32.is_lt(c, 8602), c)

def dec.n1021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1018(U32.is_lt(c, 8490), c)
    case False{}:
      dec.n1020(U32.is_lt(c, 8492), c)

def dec.n1022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1017(U32.is_lt(c, 8194), c)
    case False{}:
      dec.n1021(U32.is_lt(c, 8491), c)

def dec.n1023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1014(U32.is_lt(c, 8186), c)
    case False{}:
      dec.n1022(U32.is_lt(c, 8487), c)

def dec.n1024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2192}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2194}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1024(U32.is_lt(c, 8604), c)
    case False{}:
      dec.n1025(U32.is_lt(c, 8623), c)

def dec.n1027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{21D0}\u{338}"
    case False{}:
      "\u{21D4}\u{338}"

def dec.n1028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2203}\u{338}"

def dec.n1029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{21D2}\u{338}"
    case False{}:
      dec.n1028(U32.is_lt(c, 8708), c)

def dec.n1030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1027(U32.is_lt(c, 8654), c)
    case False{}:
      dec.n1029(U32.is_lt(c, 8656), c)

def dec.n1031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1026(U32.is_lt(c, 8622), c)
    case False{}:
      dec.n1030(U32.is_lt(c, 8655), c)

def dec.n1032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2208}\u{338}"

def dec.n1033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{220B}\u{338}"

def dec.n1034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1032(U32.is_lt(c, 8713), c)
    case False{}:
      dec.n1033(U32.is_lt(c, 8716), c)

def dec.n1035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2223}\u{338}"

def dec.n1036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2225}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1036(U32.is_lt(c, 8743), c)

def dec.n1038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1035(U32.is_lt(c, 8740), c)
    case False{}:
      dec.n1037(U32.is_lt(c, 8742), c)

def dec.n1039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1034(U32.is_lt(c, 8714), c)
    case False{}:
      dec.n1038(U32.is_lt(c, 8741), c)

def dec.n1040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1031(U32.is_lt(c, 8653), c)
    case False{}:
      dec.n1039(U32.is_lt(c, 8717), c)

def dec.n1041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1023(U32.is_lt(c, 8192), c)
    case False{}:
      dec.n1040(U32.is_lt(c, 8709), c)

def dec.n1042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{223C}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2243}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1042(U32.is_lt(c, 8770), c)
    case False{}:
      dec.n1043(U32.is_lt(c, 8773), c)

def dec.n1045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2245}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3D}\u{338}"

def dec.n1047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2248}\u{338}"
    case False{}:
      dec.n1046(U32.is_lt(c, 8800), c)

def dec.n1048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1045(U32.is_lt(c, 8776), c)
    case False{}:
      dec.n1047(U32.is_lt(c, 8778), c)

def dec.n1049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1044(U32.is_lt(c, 8772), c)
    case False{}:
      dec.n1048(U32.is_lt(c, 8777), c)

def dec.n1050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2261}\u{338}"

def dec.n1051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{224D}\u{338}"

def dec.n1052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1050(U32.is_lt(c, 8802), c)
    case False{}:
      dec.n1051(U32.is_lt(c, 8813), c)

def dec.n1053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C}\u{338}"
    case False{}:
      "\u{3E}\u{338}"

def dec.n1054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2265}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2264}\u{338}"
    case False{}:
      dec.n1054(U32.is_lt(c, 8818), c)

def dec.n1056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1053(U32.is_lt(c, 8815), c)
    case False{}:
      dec.n1055(U32.is_lt(c, 8817), c)

def dec.n1057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1052(U32.is_lt(c, 8803), c)
    case False{}:
      dec.n1056(U32.is_lt(c, 8816), c)

def dec.n1058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1049(U32.is_lt(c, 8775), c)
    case False{}:
      dec.n1057(U32.is_lt(c, 8814), c)

def dec.n1059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2272}\u{338}"
    case False{}:
      "\u{2273}\u{338}"

def dec.n1060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2276}\u{338}"

def dec.n1061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1059(U32.is_lt(c, 8821), c)
    case False{}:
      dec.n1060(U32.is_lt(c, 8824), c)

def dec.n1062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2277}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{227B}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{227A}\u{338}"
    case False{}:
      dec.n1063(U32.is_lt(c, 8834), c)

def dec.n1065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1062(U32.is_lt(c, 8826), c)
    case False{}:
      dec.n1064(U32.is_lt(c, 8833), c)

def dec.n1066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1061(U32.is_lt(c, 8822), c)
    case False{}:
      dec.n1065(U32.is_lt(c, 8832), c)

def dec.n1067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2282}\u{338}"
    case False{}:
      "\u{2283}\u{338}"

def dec.n1068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2286}\u{338}"

def dec.n1069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1067(U32.is_lt(c, 8837), c)
    case False{}:
      dec.n1068(U32.is_lt(c, 8840), c)

def dec.n1070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2287}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22A8}\u{338}"
    case False{}:
      "\u{22A9}\u{338}"

def dec.n1072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22A2}\u{338}"
    case False{}:
      dec.n1071(U32.is_lt(c, 8878), c)

def dec.n1073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1070(U32.is_lt(c, 8842), c)
    case False{}:
      dec.n1072(U32.is_lt(c, 8877), c)

def dec.n1074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1069(U32.is_lt(c, 8838), c)
    case False{}:
      dec.n1073(U32.is_lt(c, 8876), c)

def dec.n1075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1066(U32.is_lt(c, 8825), c)
    case False{}:
      dec.n1074(U32.is_lt(c, 8841), c)

def dec.n1076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1058(U32.is_lt(c, 8801), c)
    case False{}:
      dec.n1075(U32.is_lt(c, 8836), c)

def dec.n1077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1041(U32.is_lt(c, 8603), c)
    case False{}:
      dec.n1076(U32.is_lt(c, 8820), c)

def dec.n1078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22AB}\u{338}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{227C}\u{338}"
    case False{}:
      "\u{227D}\u{338}"

def dec.n1080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1078(U32.is_lt(c, 8880), c)
    case False{}:
      dec.n1079(U32.is_lt(c, 8929), c)

def dec.n1081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2291}\u{338}"
    case False{}:
      "\u{2292}\u{338}"

def dec.n1082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22B2}\u{338}"
    case False{}:
      "\u{22B3}\u{338}"

def dec.n1083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1082(U32.is_lt(c, 8939), c)

def dec.n1084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1081(U32.is_lt(c, 8931), c)
    case False{}:
      dec.n1083(U32.is_lt(c, 8938), c)

def dec.n1085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1080(U32.is_lt(c, 8928), c)
    case False{}:
      dec.n1084(U32.is_lt(c, 8932), c)

def dec.n1086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22B4}\u{338}"
    case False{}:
      "\u{22B5}\u{338}"

def dec.n1087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3008}"

def dec.n1088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1086(U32.is_lt(c, 8941), c)
    case False{}:
      dec.n1087(U32.is_lt(c, 9001), c)

def dec.n1089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3009}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{304B}\u{3099}"

def dec.n1091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2ADD}\u{338}"
    case False{}:
      dec.n1090(U32.is_lt(c, 12364), c)

def dec.n1092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1089(U32.is_lt(c, 9003), c)
    case False{}:
      dec.n1091(U32.is_lt(c, 10973), c)

def dec.n1093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1088(U32.is_lt(c, 8942), c)
    case False{}:
      dec.n1092(U32.is_lt(c, 10972), c)

def dec.n1094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1085(U32.is_lt(c, 8930), c)
    case False{}:
      dec.n1093(U32.is_lt(c, 9002), c)

def dec.n1095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{304D}\u{3099}"

def dec.n1096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{304F}\u{3099}"

def dec.n1097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1095(U32.is_lt(c, 12366), c)
    case False{}:
      dec.n1096(U32.is_lt(c, 12368), c)

def dec.n1098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3051}\u{3099}"

def dec.n1099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3053}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1099(U32.is_lt(c, 12373), c)

def dec.n1101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1098(U32.is_lt(c, 12370), c)
    case False{}:
      dec.n1100(U32.is_lt(c, 12372), c)

def dec.n1102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1097(U32.is_lt(c, 12367), c)
    case False{}:
      dec.n1101(U32.is_lt(c, 12371), c)

def dec.n1103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3055}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3057}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1103(U32.is_lt(c, 12375), c)
    case False{}:
      dec.n1104(U32.is_lt(c, 12377), c)

def dec.n1106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3059}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{305D}\u{3099}"

def dec.n1108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{305B}\u{3099}"
    case False{}:
      dec.n1107(U32.is_lt(c, 12382), c)

def dec.n1109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1106(U32.is_lt(c, 12379), c)
    case False{}:
      dec.n1108(U32.is_lt(c, 12381), c)

def dec.n1110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1105(U32.is_lt(c, 12376), c)
    case False{}:
      dec.n1109(U32.is_lt(c, 12380), c)

def dec.n1111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1102(U32.is_lt(c, 12369), c)
    case False{}:
      dec.n1110(U32.is_lt(c, 12378), c)

def dec.n1112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1094(U32.is_lt(c, 8940), c)
    case False{}:
      dec.n1111(U32.is_lt(c, 12374), c)

def dec.n1113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{305F}\u{3099}"

def dec.n1114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3061}\u{3099}"

def dec.n1115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1113(U32.is_lt(c, 12384), c)
    case False{}:
      dec.n1114(U32.is_lt(c, 12386), c)

def dec.n1116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3064}\u{3099}"

def dec.n1117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3066}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1117(U32.is_lt(c, 12392), c)

def dec.n1119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1116(U32.is_lt(c, 12389), c)
    case False{}:
      dec.n1118(U32.is_lt(c, 12391), c)

def dec.n1120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1115(U32.is_lt(c, 12385), c)
    case False{}:
      dec.n1119(U32.is_lt(c, 12390), c)

def dec.n1121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3068}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{306F}\u{3099}"
    case False{}:
      "\u{306F}\u{309A}"

def dec.n1123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1121(U32.is_lt(c, 12394), c)
    case False{}:
      dec.n1122(U32.is_lt(c, 12401), c)

def dec.n1124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3072}\u{3099}"

def dec.n1125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3075}\u{3099}"

def dec.n1126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3072}\u{309A}"
    case False{}:
      dec.n1125(U32.is_lt(c, 12406), c)

def dec.n1127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1124(U32.is_lt(c, 12403), c)
    case False{}:
      dec.n1126(U32.is_lt(c, 12405), c)

def dec.n1128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1123(U32.is_lt(c, 12400), c)
    case False{}:
      dec.n1127(U32.is_lt(c, 12404), c)

def dec.n1129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1120(U32.is_lt(c, 12387), c)
    case False{}:
      dec.n1128(U32.is_lt(c, 12402), c)

def dec.n1130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3075}\u{309A}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3078}\u{3099}"
    case False{}:
      "\u{3078}\u{309A}"

def dec.n1132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1130(U32.is_lt(c, 12408), c)
    case False{}:
      dec.n1131(U32.is_lt(c, 12410), c)

def dec.n1133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{307B}\u{3099}"

def dec.n1134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3046}\u{3099}"

def dec.n1135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{307B}\u{309A}"
    case False{}:
      dec.n1134(U32.is_lt(c, 12436), c)

def dec.n1136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1133(U32.is_lt(c, 12412), c)
    case False{}:
      dec.n1135(U32.is_lt(c, 12414), c)

def dec.n1137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1132(U32.is_lt(c, 12409), c)
    case False{}:
      dec.n1136(U32.is_lt(c, 12413), c)

def dec.n1138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{309D}\u{3099}"

def dec.n1139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30AB}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1139(U32.is_lt(c, 12461), c)

def dec.n1141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1138(U32.is_lt(c, 12446), c)
    case False{}:
      dec.n1140(U32.is_lt(c, 12460), c)

def dec.n1142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30AD}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30B1}\u{3099}"

def dec.n1144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30AF}\u{3099}"
    case False{}:
      dec.n1143(U32.is_lt(c, 12466), c)

def dec.n1145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1142(U32.is_lt(c, 12463), c)
    case False{}:
      dec.n1144(U32.is_lt(c, 12465), c)

def dec.n1146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1141(U32.is_lt(c, 12447), c)
    case False{}:
      dec.n1145(U32.is_lt(c, 12464), c)

def dec.n1147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1137(U32.is_lt(c, 12411), c)
    case False{}:
      dec.n1146(U32.is_lt(c, 12462), c)

def dec.n1148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1129(U32.is_lt(c, 12393), c)
    case False{}:
      dec.n1147(U32.is_lt(c, 12437), c)

def dec.n1149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1112(U32.is_lt(c, 12365), c)
    case False{}:
      dec.n1148(U32.is_lt(c, 12407), c)

def dec.n1150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1077(U32.is_lt(c, 8769), c)
    case False{}:
      dec.n1149(U32.is_lt(c, 12383), c)

def dec.n1151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1006(U32.is_lt(c, 8107), c)
    case False{}:
      dec.n1150(U32.is_lt(c, 8879), c)

def dec.n1152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n863(U32.is_lt(c, 7880), c)
    case False{}:
      dec.n1151(U32.is_lt(c, 8182), c)

def dec.n1153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n575(U32.is_lt(c, 895), c)
    case False{}:
      dec.n1152(U32.is_lt(c, 8034), c)

def dec.n1154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30B3}\u{3099}"

def dec.n1155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30B5}\u{3099}"

def dec.n1156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1154(U32.is_lt(c, 12468), c)
    case False{}:
      dec.n1155(U32.is_lt(c, 12470), c)

def dec.n1157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30B7}\u{3099}"

def dec.n1158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30B9}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1158(U32.is_lt(c, 12475), c)

def dec.n1160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1157(U32.is_lt(c, 12472), c)
    case False{}:
      dec.n1159(U32.is_lt(c, 12474), c)

def dec.n1161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1156(U32.is_lt(c, 12469), c)
    case False{}:
      dec.n1160(U32.is_lt(c, 12473), c)

def dec.n1162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30BB}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30BD}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1162(U32.is_lt(c, 12477), c)
    case False{}:
      dec.n1163(U32.is_lt(c, 12479), c)

def dec.n1165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30BF}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30C4}\u{3099}"

def dec.n1167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30C1}\u{3099}"
    case False{}:
      dec.n1166(U32.is_lt(c, 12485), c)

def dec.n1168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1165(U32.is_lt(c, 12481), c)
    case False{}:
      dec.n1167(U32.is_lt(c, 12483), c)

def dec.n1169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1164(U32.is_lt(c, 12478), c)
    case False{}:
      dec.n1168(U32.is_lt(c, 12482), c)

def dec.n1170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1161(U32.is_lt(c, 12471), c)
    case False{}:
      dec.n1169(U32.is_lt(c, 12480), c)

def dec.n1171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30C6}\u{3099}"

def dec.n1172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30C8}\u{3099}"

def dec.n1173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1171(U32.is_lt(c, 12487), c)
    case False{}:
      dec.n1172(U32.is_lt(c, 12489), c)

def dec.n1174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30CF}\u{3099}"

def dec.n1175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30D2}\u{3099}"

def dec.n1176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30CF}\u{309A}"
    case False{}:
      dec.n1175(U32.is_lt(c, 12499), c)

def dec.n1177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1174(U32.is_lt(c, 12496), c)
    case False{}:
      dec.n1176(U32.is_lt(c, 12498), c)

def dec.n1178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1173(U32.is_lt(c, 12488), c)
    case False{}:
      dec.n1177(U32.is_lt(c, 12497), c)

def dec.n1179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30D2}\u{309A}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30D5}\u{3099}"
    case False{}:
      "\u{30D5}\u{309A}"

def dec.n1181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1179(U32.is_lt(c, 12501), c)
    case False{}:
      dec.n1180(U32.is_lt(c, 12503), c)

def dec.n1182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30D8}\u{3099}"

def dec.n1183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{30DB}\u{3099}"

def dec.n1184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30D8}\u{309A}"
    case False{}:
      dec.n1183(U32.is_lt(c, 12508), c)

def dec.n1185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1182(U32.is_lt(c, 12505), c)
    case False{}:
      dec.n1184(U32.is_lt(c, 12507), c)

def dec.n1186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1181(U32.is_lt(c, 12502), c)
    case False{}:
      dec.n1185(U32.is_lt(c, 12506), c)

def dec.n1187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1178(U32.is_lt(c, 12490), c)
    case False{}:
      dec.n1186(U32.is_lt(c, 12504), c)

def dec.n1188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1170(U32.is_lt(c, 12476), c)
    case False{}:
      dec.n1187(U32.is_lt(c, 12500), c)

def dec.n1189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30DB}\u{309A}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30A6}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1189(U32.is_lt(c, 12510), c)
    case False{}:
      dec.n1190(U32.is_lt(c, 12533), c)

def dec.n1192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30EF}\u{3099}"
    case False{}:
      "\u{30F0}\u{3099}"

def dec.n1193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30F2}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30F1}\u{3099}"
    case False{}:
      dec.n1193(U32.is_lt(c, 12539), c)

def dec.n1195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1192(U32.is_lt(c, 12536), c)
    case False{}:
      dec.n1194(U32.is_lt(c, 12538), c)

def dec.n1196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1191(U32.is_lt(c, 12532), c)
    case False{}:
      dec.n1195(U32.is_lt(c, 12537), c)

def dec.n1197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{30FD}\u{3099}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8C48}"
    case False{}:
      "\u{66F4}"

def dec.n1199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1197(U32.is_lt(c, 12543), c)
    case False{}:
      dec.n1198(U32.is_lt(c, 63745), c)

def dec.n1200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8ECA}"
    case False{}:
      "\u{8CC8}"

def dec.n1201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E32}"
    case False{}:
      "\u{53E5}"

def dec.n1202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6ED1}"
    case False{}:
      dec.n1201(U32.is_lt(c, 63750), c)

def dec.n1203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1200(U32.is_lt(c, 63747), c)
    case False{}:
      dec.n1202(U32.is_lt(c, 63749), c)

def dec.n1204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1199(U32.is_lt(c, 63744), c)
    case False{}:
      dec.n1203(U32.is_lt(c, 63748), c)

def dec.n1205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1196(U32.is_lt(c, 12535), c)
    case False{}:
      dec.n1204(U32.is_lt(c, 63746), c)

def dec.n1206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9F9C}"
    case False{}:
      "\u{5951}"

def dec.n1207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{91D1}"
    case False{}:
      "\u{5587}"

def dec.n1208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1206(U32.is_lt(c, 63753), c)
    case False{}:
      dec.n1207(U32.is_lt(c, 63755), c)

def dec.n1209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5948}"
    case False{}:
      "\u{61F6}"

def dec.n1210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7F85}"
    case False{}:
      "\u{863F}"

def dec.n1211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7669}"
    case False{}:
      dec.n1210(U32.is_lt(c, 63760), c)

def dec.n1212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1209(U32.is_lt(c, 63757), c)
    case False{}:
      dec.n1211(U32.is_lt(c, 63759), c)

def dec.n1213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1208(U32.is_lt(c, 63754), c)
    case False{}:
      dec.n1212(U32.is_lt(c, 63758), c)

def dec.n1214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{87BA}"
    case False{}:
      "\u{88F8}"

def dec.n1215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{908F}"
    case False{}:
      "\u{6A02}"

def dec.n1216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1214(U32.is_lt(c, 63762), c)
    case False{}:
      dec.n1215(U32.is_lt(c, 63764), c)

def dec.n1217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D1B}"
    case False{}:
      "\u{70D9}"

def dec.n1218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{843D}"
    case False{}:
      "\u{916A}"

def dec.n1219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73DE}"
    case False{}:
      dec.n1218(U32.is_lt(c, 63769), c)

def dec.n1220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1217(U32.is_lt(c, 63766), c)
    case False{}:
      dec.n1219(U32.is_lt(c, 63768), c)

def dec.n1221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1216(U32.is_lt(c, 63763), c)
    case False{}:
      dec.n1220(U32.is_lt(c, 63767), c)

def dec.n1222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1213(U32.is_lt(c, 63756), c)
    case False{}:
      dec.n1221(U32.is_lt(c, 63765), c)

def dec.n1223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1205(U32.is_lt(c, 12542), c)
    case False{}:
      dec.n1222(U32.is_lt(c, 63761), c)

def dec.n1224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1188(U32.is_lt(c, 12486), c)
    case False{}:
      dec.n1223(U32.is_lt(c, 63751), c)

def dec.n1225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{99F1}"
    case False{}:
      "\u{4E82}"

def dec.n1226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5375}"
    case False{}:
      "\u{6B04}"

def dec.n1227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1225(U32.is_lt(c, 63771), c)
    case False{}:
      dec.n1226(U32.is_lt(c, 63773), c)

def dec.n1228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{721B}"
    case False{}:
      "\u{862D}"

def dec.n1229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D50}"
    case False{}:
      "\u{6FEB}"

def dec.n1230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9E1E}"
    case False{}:
      dec.n1229(U32.is_lt(c, 63778), c)

def dec.n1231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1228(U32.is_lt(c, 63775), c)
    case False{}:
      dec.n1230(U32.is_lt(c, 63777), c)

def dec.n1232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1227(U32.is_lt(c, 63772), c)
    case False{}:
      dec.n1231(U32.is_lt(c, 63776), c)

def dec.n1233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{85CD}"
    case False{}:
      "\u{8964}"

def dec.n1234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62C9}"
    case False{}:
      "\u{81D8}"

def dec.n1235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1233(U32.is_lt(c, 63780), c)
    case False{}:
      dec.n1234(U32.is_lt(c, 63782), c)

def dec.n1236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{881F}"
    case False{}:
      "\u{5ECA}"

def dec.n1237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D6A}"
    case False{}:
      "\u{72FC}"

def dec.n1238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6717}"
    case False{}:
      dec.n1237(U32.is_lt(c, 63787), c)

def dec.n1239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1236(U32.is_lt(c, 63784), c)
    case False{}:
      dec.n1238(U32.is_lt(c, 63786), c)

def dec.n1240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1235(U32.is_lt(c, 63781), c)
    case False{}:
      dec.n1239(U32.is_lt(c, 63785), c)

def dec.n1241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1232(U32.is_lt(c, 63774), c)
    case False{}:
      dec.n1240(U32.is_lt(c, 63783), c)

def dec.n1242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{90CE}"
    case False{}:
      "\u{4F86}"

def dec.n1243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51B7}"
    case False{}:
      "\u{52DE}"

def dec.n1244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1242(U32.is_lt(c, 63789), c)
    case False{}:
      dec.n1243(U32.is_lt(c, 63791), c)

def dec.n1245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{64C4}"
    case False{}:
      "\u{6AD3}"

def dec.n1246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76E7}"
    case False{}:
      "\u{8001}"

def dec.n1247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7210}"
    case False{}:
      dec.n1246(U32.is_lt(c, 63796), c)

def dec.n1248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1245(U32.is_lt(c, 63793), c)
    case False{}:
      dec.n1247(U32.is_lt(c, 63795), c)

def dec.n1249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1244(U32.is_lt(c, 63790), c)
    case False{}:
      dec.n1248(U32.is_lt(c, 63794), c)

def dec.n1250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8606}"
    case False{}:
      "\u{865C}"

def dec.n1251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8DEF}"
    case False{}:
      "\u{9732}"

def dec.n1252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1250(U32.is_lt(c, 63798), c)
    case False{}:
      dec.n1251(U32.is_lt(c, 63800), c)

def dec.n1253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9B6F}"
    case False{}:
      "\u{9DFA}"

def dec.n1254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{797F}"
    case False{}:
      "\u{7DA0}"

def dec.n1255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{788C}"
    case False{}:
      dec.n1254(U32.is_lt(c, 63805), c)

def dec.n1256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1253(U32.is_lt(c, 63802), c)
    case False{}:
      dec.n1255(U32.is_lt(c, 63804), c)

def dec.n1257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1252(U32.is_lt(c, 63799), c)
    case False{}:
      dec.n1256(U32.is_lt(c, 63803), c)

def dec.n1258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1249(U32.is_lt(c, 63792), c)
    case False{}:
      dec.n1257(U32.is_lt(c, 63801), c)

def dec.n1259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1241(U32.is_lt(c, 63779), c)
    case False{}:
      dec.n1258(U32.is_lt(c, 63797), c)

def dec.n1260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{83C9}"
    case False{}:
      "\u{9304}"

def dec.n1261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9E7F}"
    case False{}:
      "\u{8AD6}"

def dec.n1262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1260(U32.is_lt(c, 63807), c)
    case False{}:
      dec.n1261(U32.is_lt(c, 63809), c)

def dec.n1263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58DF}"
    case False{}:
      "\u{5F04}"

def dec.n1264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{807E}"
    case False{}:
      "\u{7262}"

def dec.n1265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7C60}"
    case False{}:
      dec.n1264(U32.is_lt(c, 63814), c)

def dec.n1266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1263(U32.is_lt(c, 63811), c)
    case False{}:
      dec.n1265(U32.is_lt(c, 63813), c)

def dec.n1267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1262(U32.is_lt(c, 63808), c)
    case False{}:
      dec.n1266(U32.is_lt(c, 63812), c)

def dec.n1268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{78CA}"
    case False{}:
      "\u{8CC2}"

def dec.n1269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{96F7}"
    case False{}:
      "\u{58D8}"

def dec.n1270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1268(U32.is_lt(c, 63816), c)
    case False{}:
      dec.n1269(U32.is_lt(c, 63818), c)

def dec.n1271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5C62}"
    case False{}:
      "\u{6A13}"

def dec.n1272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F0F}"
    case False{}:
      "\u{7D2F}"

def dec.n1273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6DDA}"
    case False{}:
      dec.n1272(U32.is_lt(c, 63823), c)

def dec.n1274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1271(U32.is_lt(c, 63820), c)
    case False{}:
      dec.n1273(U32.is_lt(c, 63822), c)

def dec.n1275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1270(U32.is_lt(c, 63817), c)
    case False{}:
      dec.n1274(U32.is_lt(c, 63821), c)

def dec.n1276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1267(U32.is_lt(c, 63810), c)
    case False{}:
      dec.n1275(U32.is_lt(c, 63819), c)

def dec.n1277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7E37}"
    case False{}:
      "\u{964B}"

def dec.n1278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52D2}"
    case False{}:
      "\u{808B}"

def dec.n1279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1277(U32.is_lt(c, 63825), c)
    case False{}:
      dec.n1278(U32.is_lt(c, 63827), c)

def dec.n1280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51DC}"
    case False{}:
      "\u{51CC}"

def dec.n1281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7DBE}"
    case False{}:
      "\u{83F1}"

def dec.n1282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A1C}"
    case False{}:
      dec.n1281(U32.is_lt(c, 63832), c)

def dec.n1283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1280(U32.is_lt(c, 63829), c)
    case False{}:
      dec.n1282(U32.is_lt(c, 63831), c)

def dec.n1284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1279(U32.is_lt(c, 63826), c)
    case False{}:
      dec.n1283(U32.is_lt(c, 63830), c)

def dec.n1285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9675}"
    case False{}:
      "\u{8B80}"

def dec.n1286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62CF}"
    case False{}:
      "\u{6A02}"

def dec.n1287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1285(U32.is_lt(c, 63834), c)
    case False{}:
      dec.n1286(U32.is_lt(c, 63836), c)

def dec.n1288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AFE}"
    case False{}:
      "\u{4E39}"

def dec.n1289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6012}"
    case False{}:
      "\u{7387}"

def dec.n1290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BE7}"
    case False{}:
      dec.n1289(U32.is_lt(c, 63841), c)

def dec.n1291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1288(U32.is_lt(c, 63838), c)
    case False{}:
      dec.n1290(U32.is_lt(c, 63840), c)

def dec.n1292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1287(U32.is_lt(c, 63835), c)
    case False{}:
      dec.n1291(U32.is_lt(c, 63839), c)

def dec.n1293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1284(U32.is_lt(c, 63828), c)
    case False{}:
      dec.n1292(U32.is_lt(c, 63837), c)

def dec.n1294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1276(U32.is_lt(c, 63815), c)
    case False{}:
      dec.n1293(U32.is_lt(c, 63833), c)

def dec.n1295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1259(U32.is_lt(c, 63788), c)
    case False{}:
      dec.n1294(U32.is_lt(c, 63824), c)

def dec.n1296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1224(U32.is_lt(c, 12509), c)
    case False{}:
      dec.n1295(U32.is_lt(c, 63806), c)

def dec.n1297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7570}"
    case False{}:
      "\u{5317}"

def dec.n1298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{78FB}"
    case False{}:
      "\u{4FBF}"

def dec.n1299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1297(U32.is_lt(c, 63843), c)
    case False{}:
      dec.n1298(U32.is_lt(c, 63845), c)

def dec.n1300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5FA9}"
    case False{}:
      "\u{4E0D}"

def dec.n1301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6578}"
    case False{}:
      "\u{7D22}"

def dec.n1302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6CCC}"
    case False{}:
      dec.n1301(U32.is_lt(c, 63850), c)

def dec.n1303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1300(U32.is_lt(c, 63847), c)
    case False{}:
      dec.n1302(U32.is_lt(c, 63849), c)

def dec.n1304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1299(U32.is_lt(c, 63844), c)
    case False{}:
      dec.n1303(U32.is_lt(c, 63848), c)

def dec.n1305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53C3}"
    case False{}:
      "\u{585E}"

def dec.n1306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7701}"
    case False{}:
      "\u{8449}"

def dec.n1307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1305(U32.is_lt(c, 63852), c)
    case False{}:
      dec.n1306(U32.is_lt(c, 63854), c)

def dec.n1308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AAA}"
    case False{}:
      "\u{6BBA}"

def dec.n1309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C88}"
    case False{}:
      "\u{62FE}"

def dec.n1310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8FB0}"
    case False{}:
      dec.n1309(U32.is_lt(c, 63859), c)

def dec.n1311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1308(U32.is_lt(c, 63856), c)
    case False{}:
      dec.n1310(U32.is_lt(c, 63858), c)

def dec.n1312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1307(U32.is_lt(c, 63853), c)
    case False{}:
      dec.n1311(U32.is_lt(c, 63857), c)

def dec.n1313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1304(U32.is_lt(c, 63846), c)
    case False{}:
      dec.n1312(U32.is_lt(c, 63855), c)

def dec.n1314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{82E5}"
    case False{}:
      "\u{63A0}"

def dec.n1315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7565}"
    case False{}:
      "\u{4EAE}"

def dec.n1316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1314(U32.is_lt(c, 63861), c)
    case False{}:
      dec.n1315(U32.is_lt(c, 63863), c)

def dec.n1317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5169}"
    case False{}:
      "\u{51C9}"

def dec.n1318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7CE7}"
    case False{}:
      "\u{826F}"

def dec.n1319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6881}"
    case False{}:
      dec.n1318(U32.is_lt(c, 63868), c)

def dec.n1320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1317(U32.is_lt(c, 63865), c)
    case False{}:
      dec.n1319(U32.is_lt(c, 63867), c)

def dec.n1321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1316(U32.is_lt(c, 63862), c)
    case False{}:
      dec.n1320(U32.is_lt(c, 63866), c)

def dec.n1322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AD2}"
    case False{}:
      "\u{91CF}"

def dec.n1323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52F5}"
    case False{}:
      "\u{5442}"

def dec.n1324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1322(U32.is_lt(c, 63870), c)
    case False{}:
      dec.n1323(U32.is_lt(c, 63872), c)

def dec.n1325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5973}"
    case False{}:
      "\u{5EEC}"

def dec.n1326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6FFE}"
    case False{}:
      "\u{792A}"

def dec.n1327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65C5}"
    case False{}:
      dec.n1326(U32.is_lt(c, 63877), c)

def dec.n1328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1325(U32.is_lt(c, 63874), c)
    case False{}:
      dec.n1327(U32.is_lt(c, 63876), c)

def dec.n1329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1324(U32.is_lt(c, 63871), c)
    case False{}:
      dec.n1328(U32.is_lt(c, 63875), c)

def dec.n1330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1321(U32.is_lt(c, 63864), c)
    case False{}:
      dec.n1329(U32.is_lt(c, 63873), c)

def dec.n1331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1313(U32.is_lt(c, 63851), c)
    case False{}:
      dec.n1330(U32.is_lt(c, 63869), c)

def dec.n1332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{95AD}"
    case False{}:
      "\u{9A6A}"

def dec.n1333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9E97}"
    case False{}:
      "\u{9ECE}"

def dec.n1334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1332(U32.is_lt(c, 63879), c)
    case False{}:
      dec.n1333(U32.is_lt(c, 63881), c)

def dec.n1335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{529B}"
    case False{}:
      "\u{66C6}"

def dec.n1336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F62}"
    case False{}:
      "\u{5E74}"

def dec.n1337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B77}"
    case False{}:
      dec.n1336(U32.is_lt(c, 63886), c)

def dec.n1338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1335(U32.is_lt(c, 63883), c)
    case False{}:
      dec.n1337(U32.is_lt(c, 63885), c)

def dec.n1339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1334(U32.is_lt(c, 63880), c)
    case False{}:
      dec.n1338(U32.is_lt(c, 63884), c)

def dec.n1340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6190}"
    case False{}:
      "\u{6200}"

def dec.n1341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{649A}"
    case False{}:
      "\u{6F23}"

def dec.n1342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1340(U32.is_lt(c, 63888), c)
    case False{}:
      dec.n1341(U32.is_lt(c, 63890), c)

def dec.n1343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7149}"
    case False{}:
      "\u{7489}"

def dec.n1344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7DF4}"
    case False{}:
      "\u{806F}"

def dec.n1345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79CA}"
    case False{}:
      dec.n1344(U32.is_lt(c, 63895), c)

def dec.n1346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1343(U32.is_lt(c, 63892), c)
    case False{}:
      dec.n1345(U32.is_lt(c, 63894), c)

def dec.n1347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1342(U32.is_lt(c, 63889), c)
    case False{}:
      dec.n1346(U32.is_lt(c, 63893), c)

def dec.n1348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1339(U32.is_lt(c, 63882), c)
    case False{}:
      dec.n1347(U32.is_lt(c, 63891), c)

def dec.n1349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F26}"
    case False{}:
      "\u{84EE}"

def dec.n1350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9023}"
    case False{}:
      "\u{934A}"

def dec.n1351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1349(U32.is_lt(c, 63897), c)
    case False{}:
      dec.n1350(U32.is_lt(c, 63899), c)

def dec.n1352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5217}"
    case False{}:
      "\u{52A3}"

def dec.n1353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{70C8}"
    case False{}:
      "\u{88C2}"

def dec.n1354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{54BD}"
    case False{}:
      dec.n1353(U32.is_lt(c, 63904), c)

def dec.n1355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1352(U32.is_lt(c, 63901), c)
    case False{}:
      dec.n1354(U32.is_lt(c, 63903), c)

def dec.n1356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1351(U32.is_lt(c, 63898), c)
    case False{}:
      dec.n1355(U32.is_lt(c, 63902), c)

def dec.n1357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AAA}"
    case False{}:
      "\u{5EC9}"

def dec.n1358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5FF5}"
    case False{}:
      "\u{637B}"

def dec.n1359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1357(U32.is_lt(c, 63906), c)
    case False{}:
      dec.n1358(U32.is_lt(c, 63908), c)

def dec.n1360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6BAE}"
    case False{}:
      "\u{7C3E}"

def dec.n1361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4EE4}"
    case False{}:
      "\u{56F9}"

def dec.n1362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7375}"
    case False{}:
      dec.n1361(U32.is_lt(c, 63913), c)

def dec.n1363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1360(U32.is_lt(c, 63910), c)
    case False{}:
      dec.n1362(U32.is_lt(c, 63912), c)

def dec.n1364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1359(U32.is_lt(c, 63907), c)
    case False{}:
      dec.n1363(U32.is_lt(c, 63911), c)

def dec.n1365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1356(U32.is_lt(c, 63900), c)
    case False{}:
      dec.n1364(U32.is_lt(c, 63909), c)

def dec.n1366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1348(U32.is_lt(c, 63887), c)
    case False{}:
      dec.n1365(U32.is_lt(c, 63905), c)

def dec.n1367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1331(U32.is_lt(c, 63860), c)
    case False{}:
      dec.n1366(U32.is_lt(c, 63896), c)

def dec.n1368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BE7}"
    case False{}:
      "\u{5DBA}"

def dec.n1369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{601C}"
    case False{}:
      "\u{73B2}"

def dec.n1370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1368(U32.is_lt(c, 63915), c)
    case False{}:
      dec.n1369(U32.is_lt(c, 63917), c)

def dec.n1371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7469}"
    case False{}:
      "\u{7F9A}"

def dec.n1372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9234}"
    case False{}:
      "\u{96F6}"

def dec.n1373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8046}"
    case False{}:
      dec.n1372(U32.is_lt(c, 63922), c)

def dec.n1374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1371(U32.is_lt(c, 63919), c)
    case False{}:
      dec.n1373(U32.is_lt(c, 63921), c)

def dec.n1375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1370(U32.is_lt(c, 63916), c)
    case False{}:
      dec.n1374(U32.is_lt(c, 63920), c)

def dec.n1376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9748}"
    case False{}:
      "\u{9818}"

def dec.n1377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F8B}"
    case False{}:
      "\u{79AE}"

def dec.n1378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1376(U32.is_lt(c, 63924), c)
    case False{}:
      dec.n1377(U32.is_lt(c, 63926), c)

def dec.n1379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{91B4}"
    case False{}:
      "\u{96B8}"

def dec.n1380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E86}"
    case False{}:
      "\u{50DA}"

def dec.n1381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{60E1}"
    case False{}:
      dec.n1380(U32.is_lt(c, 63931), c)

def dec.n1382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1379(U32.is_lt(c, 63928), c)
    case False{}:
      dec.n1381(U32.is_lt(c, 63930), c)

def dec.n1383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1378(U32.is_lt(c, 63925), c)
    case False{}:
      dec.n1382(U32.is_lt(c, 63929), c)

def dec.n1384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1375(U32.is_lt(c, 63918), c)
    case False{}:
      dec.n1383(U32.is_lt(c, 63927), c)

def dec.n1385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BEE}"
    case False{}:
      "\u{5C3F}"

def dec.n1386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6599}"
    case False{}:
      "\u{6A02}"

def dec.n1387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1385(U32.is_lt(c, 63933), c)
    case False{}:
      dec.n1386(U32.is_lt(c, 63935), c)

def dec.n1388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{71CE}"
    case False{}:
      "\u{7642}"

def dec.n1389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{907C}"
    case False{}:
      "\u{9F8D}"

def dec.n1390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{84FC}"
    case False{}:
      dec.n1389(U32.is_lt(c, 63940), c)

def dec.n1391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1388(U32.is_lt(c, 63937), c)
    case False{}:
      dec.n1390(U32.is_lt(c, 63939), c)

def dec.n1392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1387(U32.is_lt(c, 63934), c)
    case False{}:
      dec.n1391(U32.is_lt(c, 63938), c)

def dec.n1393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6688}"
    case False{}:
      "\u{962E}"

def dec.n1394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5289}"
    case False{}:
      "\u{677B}"

def dec.n1395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1393(U32.is_lt(c, 63942), c)
    case False{}:
      dec.n1394(U32.is_lt(c, 63944), c)

def dec.n1396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{67F3}"
    case False{}:
      "\u{6D41}"

def dec.n1397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7409}"
    case False{}:
      "\u{7559}"

def dec.n1398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E9C}"
    case False{}:
      dec.n1397(U32.is_lt(c, 63949), c)

def dec.n1399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1396(U32.is_lt(c, 63946), c)
    case False{}:
      dec.n1398(U32.is_lt(c, 63948), c)

def dec.n1400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1395(U32.is_lt(c, 63943), c)
    case False{}:
      dec.n1399(U32.is_lt(c, 63947), c)

def dec.n1401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1392(U32.is_lt(c, 63936), c)
    case False{}:
      dec.n1400(U32.is_lt(c, 63945), c)

def dec.n1402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1384(U32.is_lt(c, 63923), c)
    case False{}:
      dec.n1401(U32.is_lt(c, 63941), c)

def dec.n1403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{786B}"
    case False{}:
      "\u{7D10}"

def dec.n1404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{985E}"
    case False{}:
      "\u{516D}"

def dec.n1405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1403(U32.is_lt(c, 63951), c)
    case False{}:
      dec.n1404(U32.is_lt(c, 63953), c)

def dec.n1406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{622E}"
    case False{}:
      "\u{9678}"

def dec.n1407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D19}"
    case False{}:
      "\u{6DEA}"

def dec.n1408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{502B}"
    case False{}:
      dec.n1407(U32.is_lt(c, 63958), c)

def dec.n1409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1406(U32.is_lt(c, 63955), c)
    case False{}:
      dec.n1408(U32.is_lt(c, 63957), c)

def dec.n1410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1405(U32.is_lt(c, 63952), c)
    case False{}:
      dec.n1409(U32.is_lt(c, 63956), c)

def dec.n1411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F2A}"
    case False{}:
      "\u{5F8B}"

def dec.n1412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6144}"
    case False{}:
      "\u{6817}"

def dec.n1413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1411(U32.is_lt(c, 63960), c)
    case False{}:
      dec.n1412(U32.is_lt(c, 63962), c)

def dec.n1414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7387}"
    case False{}:
      "\u{9686}"

def dec.n1415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{540F}"
    case False{}:
      "\u{5C65}"

def dec.n1416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5229}"
    case False{}:
      dec.n1415(U32.is_lt(c, 63967), c)

def dec.n1417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1414(U32.is_lt(c, 63964), c)
    case False{}:
      dec.n1416(U32.is_lt(c, 63966), c)

def dec.n1418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1413(U32.is_lt(c, 63961), c)
    case False{}:
      dec.n1417(U32.is_lt(c, 63965), c)

def dec.n1419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1410(U32.is_lt(c, 63954), c)
    case False{}:
      dec.n1418(U32.is_lt(c, 63963), c)

def dec.n1420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6613}"
    case False{}:
      "\u{674E}"

def dec.n1421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{68A8}"
    case False{}:
      "\u{6CE5}"

def dec.n1422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1420(U32.is_lt(c, 63969), c)
    case False{}:
      dec.n1421(U32.is_lt(c, 63971), c)

def dec.n1423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7406}"
    case False{}:
      "\u{75E2}"

def dec.n1424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{88CF}"
    case False{}:
      "\u{88E1}"

def dec.n1425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7F79}"
    case False{}:
      dec.n1424(U32.is_lt(c, 63976), c)

def dec.n1426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1423(U32.is_lt(c, 63973), c)
    case False{}:
      dec.n1425(U32.is_lt(c, 63975), c)

def dec.n1427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1422(U32.is_lt(c, 63970), c)
    case False{}:
      dec.n1426(U32.is_lt(c, 63974), c)

def dec.n1428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{91CC}"
    case False{}:
      "\u{96E2}"

def dec.n1429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6EBA}"
    case False{}:
      "\u{541D}"

def dec.n1430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{533F}"
    case False{}:
      dec.n1429(U32.is_lt(c, 63981), c)

def dec.n1431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1428(U32.is_lt(c, 63978), c)
    case False{}:
      dec.n1430(U32.is_lt(c, 63980), c)

def dec.n1432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{71D0}"
    case False{}:
      "\u{7498}"

def dec.n1433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{96A3}"
    case False{}:
      "\u{9C57}"

def dec.n1434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{85FA}"
    case False{}:
      dec.n1433(U32.is_lt(c, 63986), c)

def dec.n1435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1432(U32.is_lt(c, 63983), c)
    case False{}:
      dec.n1434(U32.is_lt(c, 63985), c)

def dec.n1436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1431(U32.is_lt(c, 63979), c)
    case False{}:
      dec.n1435(U32.is_lt(c, 63984), c)

def dec.n1437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1427(U32.is_lt(c, 63972), c)
    case False{}:
      dec.n1436(U32.is_lt(c, 63982), c)

def dec.n1438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1419(U32.is_lt(c, 63959), c)
    case False{}:
      dec.n1437(U32.is_lt(c, 63977), c)

def dec.n1439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1402(U32.is_lt(c, 63932), c)
    case False{}:
      dec.n1438(U32.is_lt(c, 63968), c)

def dec.n1440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1367(U32.is_lt(c, 63878), c)
    case False{}:
      dec.n1439(U32.is_lt(c, 63950), c)

def dec.n1441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1296(U32.is_lt(c, 63770), c)
    case False{}:
      dec.n1440(U32.is_lt(c, 63914), c)

def dec.n1442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9E9F}"
    case False{}:
      "\u{6797}"

def dec.n1443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6DCB}"
    case False{}:
      "\u{81E8}"

def dec.n1444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1442(U32.is_lt(c, 63988), c)
    case False{}:
      dec.n1443(U32.is_lt(c, 63990), c)

def dec.n1445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7ACB}"
    case False{}:
      "\u{7B20}"

def dec.n1446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{72C0}"
    case False{}:
      "\u{7099}"

def dec.n1447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7C92}"
    case False{}:
      dec.n1446(U32.is_lt(c, 63995), c)

def dec.n1448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1445(U32.is_lt(c, 63992), c)
    case False{}:
      dec.n1447(U32.is_lt(c, 63994), c)

def dec.n1449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1444(U32.is_lt(c, 63989), c)
    case False{}:
      dec.n1448(U32.is_lt(c, 63993), c)

def dec.n1450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8B58}"
    case False{}:
      "\u{4EC0}"

def dec.n1451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8336}"
    case False{}:
      "\u{523A}"

def dec.n1452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1450(U32.is_lt(c, 63997), c)
    case False{}:
      dec.n1451(U32.is_lt(c, 63999), c)

def dec.n1453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5207}"
    case False{}:
      "\u{5EA6}"

def dec.n1454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7CD6}"
    case False{}:
      "\u{5B85}"

def dec.n1455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62D3}"
    case False{}:
      dec.n1454(U32.is_lt(c, 64004), c)

def dec.n1456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1453(U32.is_lt(c, 64001), c)
    case False{}:
      dec.n1455(U32.is_lt(c, 64003), c)

def dec.n1457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1452(U32.is_lt(c, 63998), c)
    case False{}:
      dec.n1456(U32.is_lt(c, 64002), c)

def dec.n1458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1449(U32.is_lt(c, 63991), c)
    case False{}:
      dec.n1457(U32.is_lt(c, 64000), c)

def dec.n1459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D1E}"
    case False{}:
      "\u{66B4}"

def dec.n1460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F3B}"
    case False{}:
      "\u{884C}"

def dec.n1461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1459(U32.is_lt(c, 64006), c)
    case False{}:
      dec.n1460(U32.is_lt(c, 64008), c)

def dec.n1462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{964D}"
    case False{}:
      "\u{898B}"

def dec.n1463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5140}"
    case False{}:
      "\u{55C0}"

def dec.n1464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5ED3}"
    case False{}:
      dec.n1463(U32.is_lt(c, 64013), c)

def dec.n1465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1462(U32.is_lt(c, 64010), c)
    case False{}:
      dec.n1464(U32.is_lt(c, 64012), c)

def dec.n1466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1461(U32.is_lt(c, 64007), c)
    case False{}:
      dec.n1465(U32.is_lt(c, 64011), c)

def dec.n1467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{585A}"

def dec.n1468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6674}"

def dec.n1469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1467(U32.is_lt(c, 64016), c)
    case False{}:
      dec.n1468(U32.is_lt(c, 64018), c)

def dec.n1470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{51DE}"

def dec.n1471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76CA}"
    case False{}:
      "\u{793C}"

def dec.n1472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{732A}"
    case False{}:
      dec.n1471(U32.is_lt(c, 64024), c)

def dec.n1473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1470(U32.is_lt(c, 64021), c)
    case False{}:
      dec.n1472(U32.is_lt(c, 64023), c)

def dec.n1474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1469(U32.is_lt(c, 64017), c)
    case False{}:
      dec.n1473(U32.is_lt(c, 64022), c)

def dec.n1475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1466(U32.is_lt(c, 64009), c)
    case False{}:
      dec.n1474(U32.is_lt(c, 64019), c)

def dec.n1476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1458(U32.is_lt(c, 63996), c)
    case False{}:
      dec.n1475(U32.is_lt(c, 64014), c)

def dec.n1477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{795E}"
    case False{}:
      "\u{7965}"

def dec.n1478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{798F}"
    case False{}:
      "\u{9756}"

def dec.n1479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1477(U32.is_lt(c, 64026), c)
    case False{}:
      dec.n1478(U32.is_lt(c, 64028), c)

def dec.n1480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7CBE}"
    case False{}:
      "\u{7FBD}"

def dec.n1481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8612}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1481(U32.is_lt(c, 64033), c)

def dec.n1483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1480(U32.is_lt(c, 64030), c)
    case False{}:
      dec.n1482(U32.is_lt(c, 64032), c)

def dec.n1484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1479(U32.is_lt(c, 64027), c)
    case False{}:
      dec.n1483(U32.is_lt(c, 64031), c)

def dec.n1485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AF8}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9038}"
    case False{}:
      "\u{90FD}"

def dec.n1487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1485(U32.is_lt(c, 64035), c)
    case False{}:
      dec.n1486(U32.is_lt(c, 64038), c)

def dec.n1488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{98EF}"

def dec.n1489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9928}"
    case False{}:
      "\u{9DB4}"

def dec.n1490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{98FC}"
    case False{}:
      dec.n1489(U32.is_lt(c, 64045), c)

def dec.n1491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1488(U32.is_lt(c, 64042), c)
    case False{}:
      dec.n1490(U32.is_lt(c, 64044), c)

def dec.n1492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1487(U32.is_lt(c, 64037), c)
    case False{}:
      dec.n1491(U32.is_lt(c, 64043), c)

def dec.n1493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1484(U32.is_lt(c, 64029), c)
    case False{}:
      dec.n1492(U32.is_lt(c, 64039), c)

def dec.n1494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{90DE}"
    case False{}:
      "\u{96B7}"

def dec.n1495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4FAE}"
    case False{}:
      "\u{50E7}"

def dec.n1496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1494(U32.is_lt(c, 64047), c)
    case False{}:
      dec.n1495(U32.is_lt(c, 64049), c)

def dec.n1497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{514D}"
    case False{}:
      "\u{52C9}"

def dec.n1498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5351}"
    case False{}:
      "\u{559D}"

def dec.n1499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52E4}"
    case False{}:
      dec.n1498(U32.is_lt(c, 64054), c)

def dec.n1500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1497(U32.is_lt(c, 64051), c)
    case False{}:
      dec.n1499(U32.is_lt(c, 64053), c)

def dec.n1501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1496(U32.is_lt(c, 64048), c)
    case False{}:
      dec.n1500(U32.is_lt(c, 64052), c)

def dec.n1502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5606}"
    case False{}:
      "\u{5668}"

def dec.n1503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5840}"
    case False{}:
      "\u{58A8}"

def dec.n1504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1502(U32.is_lt(c, 64056), c)
    case False{}:
      dec.n1503(U32.is_lt(c, 64058), c)

def dec.n1505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5C64}"
    case False{}:
      "\u{5C6E}"

def dec.n1506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6168}"
    case False{}:
      "\u{618E}"

def dec.n1507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6094}"
    case False{}:
      dec.n1506(U32.is_lt(c, 64063), c)

def dec.n1508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1505(U32.is_lt(c, 64060), c)
    case False{}:
      dec.n1507(U32.is_lt(c, 64062), c)

def dec.n1509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1504(U32.is_lt(c, 64057), c)
    case False{}:
      dec.n1508(U32.is_lt(c, 64061), c)

def dec.n1510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1501(U32.is_lt(c, 64050), c)
    case False{}:
      dec.n1509(U32.is_lt(c, 64059), c)

def dec.n1511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1493(U32.is_lt(c, 64034), c)
    case False{}:
      dec.n1510(U32.is_lt(c, 64055), c)

def dec.n1512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1476(U32.is_lt(c, 64005), c)
    case False{}:
      dec.n1511(U32.is_lt(c, 64046), c)

def dec.n1513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61F2}"
    case False{}:
      "\u{654F}"

def dec.n1514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{65E2}"
    case False{}:
      "\u{6691}"

def dec.n1515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1513(U32.is_lt(c, 64065), c)
    case False{}:
      dec.n1514(U32.is_lt(c, 64067), c)

def dec.n1516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6885}"
    case False{}:
      "\u{6D77}"

def dec.n1517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F22}"
    case False{}:
      "\u{716E}"

def dec.n1518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E1A}"
    case False{}:
      dec.n1517(U32.is_lt(c, 64072), c)

def dec.n1519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1516(U32.is_lt(c, 64069), c)
    case False{}:
      dec.n1518(U32.is_lt(c, 64071), c)

def dec.n1520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1515(U32.is_lt(c, 64066), c)
    case False{}:
      dec.n1519(U32.is_lt(c, 64070), c)

def dec.n1521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{722B}"
    case False{}:
      "\u{7422}"

def dec.n1522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7891}"
    case False{}:
      "\u{793E}"

def dec.n1523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1521(U32.is_lt(c, 64074), c)
    case False{}:
      dec.n1522(U32.is_lt(c, 64076), c)

def dec.n1524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7949}"
    case False{}:
      "\u{7948}"

def dec.n1525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7956}"
    case False{}:
      "\u{795D}"

def dec.n1526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7950}"
    case False{}:
      dec.n1525(U32.is_lt(c, 64081), c)

def dec.n1527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1524(U32.is_lt(c, 64078), c)
    case False{}:
      dec.n1526(U32.is_lt(c, 64080), c)

def dec.n1528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1523(U32.is_lt(c, 64075), c)
    case False{}:
      dec.n1527(U32.is_lt(c, 64079), c)

def dec.n1529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1520(U32.is_lt(c, 64068), c)
    case False{}:
      dec.n1528(U32.is_lt(c, 64077), c)

def dec.n1530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{798D}"
    case False{}:
      "\u{798E}"

def dec.n1531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A40}"
    case False{}:
      "\u{7A81}"

def dec.n1532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1530(U32.is_lt(c, 64083), c)
    case False{}:
      dec.n1531(U32.is_lt(c, 64085), c)

def dec.n1533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7BC0}"
    case False{}:
      "\u{7DF4}"

def dec.n1534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7E41}"
    case False{}:
      "\u{7F72}"

def dec.n1535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7E09}"
    case False{}:
      dec.n1534(U32.is_lt(c, 64090), c)

def dec.n1536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1533(U32.is_lt(c, 64087), c)
    case False{}:
      dec.n1535(U32.is_lt(c, 64089), c)

def dec.n1537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1532(U32.is_lt(c, 64084), c)
    case False{}:
      dec.n1536(U32.is_lt(c, 64088), c)

def dec.n1538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8005}"
    case False{}:
      "\u{81ED}"

def dec.n1539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8279}"
    case False{}:
      "\u{8457}"

def dec.n1540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1538(U32.is_lt(c, 64092), c)
    case False{}:
      dec.n1539(U32.is_lt(c, 64095), c)

def dec.n1541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8910}"
    case False{}:
      "\u{8996}"

def dec.n1542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8B39}"
    case False{}:
      "\u{8CD3}"

def dec.n1543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8B01}"
    case False{}:
      dec.n1542(U32.is_lt(c, 64100), c)

def dec.n1544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1541(U32.is_lt(c, 64097), c)
    case False{}:
      dec.n1543(U32.is_lt(c, 64099), c)

def dec.n1545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1540(U32.is_lt(c, 64093), c)
    case False{}:
      dec.n1544(U32.is_lt(c, 64098), c)

def dec.n1546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1537(U32.is_lt(c, 64086), c)
    case False{}:
      dec.n1545(U32.is_lt(c, 64096), c)

def dec.n1547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1529(U32.is_lt(c, 64073), c)
    case False{}:
      dec.n1546(U32.is_lt(c, 64091), c)

def dec.n1548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8D08}"
    case False{}:
      "\u{8FB6}"

def dec.n1549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9038}"
    case False{}:
      "\u{96E3}"

def dec.n1550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1548(U32.is_lt(c, 64102), c)
    case False{}:
      dec.n1549(U32.is_lt(c, 64104), c)

def dec.n1551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{97FF}"
    case False{}:
      "\u{983B}"

def dec.n1552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{242EE}"
    case False{}:
      "\u{8218}"

def dec.n1553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6075}"
    case False{}:
      dec.n1552(U32.is_lt(c, 64109), c)

def dec.n1554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1551(U32.is_lt(c, 64106), c)
    case False{}:
      dec.n1553(U32.is_lt(c, 64108), c)

def dec.n1555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1550(U32.is_lt(c, 64103), c)
    case False{}:
      dec.n1554(U32.is_lt(c, 64107), c)

def dec.n1556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4E26}"

def dec.n1557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51B5}"
    case False{}:
      "\u{5168}"

def dec.n1558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1556(U32.is_lt(c, 64112), c)
    case False{}:
      dec.n1557(U32.is_lt(c, 64114), c)

def dec.n1559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F80}"
    case False{}:
      "\u{5145}"

def dec.n1560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52C7}"
    case False{}:
      "\u{52FA}"

def dec.n1561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5180}"
    case False{}:
      dec.n1560(U32.is_lt(c, 64119), c)

def dec.n1562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1559(U32.is_lt(c, 64116), c)
    case False{}:
      dec.n1561(U32.is_lt(c, 64118), c)

def dec.n1563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1558(U32.is_lt(c, 64113), c)
    case False{}:
      dec.n1562(U32.is_lt(c, 64117), c)

def dec.n1564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1555(U32.is_lt(c, 64105), c)
    case False{}:
      dec.n1563(U32.is_lt(c, 64115), c)

def dec.n1565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{559D}"
    case False{}:
      "\u{5555}"

def dec.n1566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5599}"
    case False{}:
      "\u{55E2}"

def dec.n1567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1565(U32.is_lt(c, 64121), c)
    case False{}:
      dec.n1566(U32.is_lt(c, 64123), c)

def dec.n1568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{585A}"
    case False{}:
      "\u{58B3}"

def dec.n1569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5954}"
    case False{}:
      "\u{5A62}"

def dec.n1570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5944}"
    case False{}:
      dec.n1569(U32.is_lt(c, 64128), c)

def dec.n1571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1568(U32.is_lt(c, 64125), c)
    case False{}:
      dec.n1570(U32.is_lt(c, 64127), c)

def dec.n1572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1567(U32.is_lt(c, 64122), c)
    case False{}:
      dec.n1571(U32.is_lt(c, 64126), c)

def dec.n1573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5B28}"
    case False{}:
      "\u{5ED2}"

def dec.n1574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5ED9}"
    case False{}:
      "\u{5F69}"

def dec.n1575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1573(U32.is_lt(c, 64130), c)
    case False{}:
      dec.n1574(U32.is_lt(c, 64132), c)

def dec.n1576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5FAD}"
    case False{}:
      "\u{60D8}"

def dec.n1577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6108}"
    case False{}:
      "\u{618E}"

def dec.n1578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{614E}"
    case False{}:
      dec.n1577(U32.is_lt(c, 64137), c)

def dec.n1579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1576(U32.is_lt(c, 64134), c)
    case False{}:
      dec.n1578(U32.is_lt(c, 64136), c)

def dec.n1580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1575(U32.is_lt(c, 64131), c)
    case False{}:
      dec.n1579(U32.is_lt(c, 64135), c)

def dec.n1581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1572(U32.is_lt(c, 64124), c)
    case False{}:
      dec.n1580(U32.is_lt(c, 64133), c)

def dec.n1582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1564(U32.is_lt(c, 64110), c)
    case False{}:
      dec.n1581(U32.is_lt(c, 64129), c)

def dec.n1583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1547(U32.is_lt(c, 64082), c)
    case False{}:
      dec.n1582(U32.is_lt(c, 64120), c)

def dec.n1584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1512(U32.is_lt(c, 64025), c)
    case False{}:
      dec.n1583(U32.is_lt(c, 64101), c)

def dec.n1585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6160}"
    case False{}:
      "\u{61F2}"

def dec.n1586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6234}"
    case False{}:
      "\u{63C4}"

def dec.n1587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1585(U32.is_lt(c, 64139), c)
    case False{}:
      dec.n1586(U32.is_lt(c, 64141), c)

def dec.n1588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{641C}"
    case False{}:
      "\u{6452}"

def dec.n1589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6674}"
    case False{}:
      "\u{6717}"

def dec.n1590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6556}"
    case False{}:
      dec.n1589(U32.is_lt(c, 64146), c)

def dec.n1591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1588(U32.is_lt(c, 64143), c)
    case False{}:
      dec.n1590(U32.is_lt(c, 64145), c)

def dec.n1592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1587(U32.is_lt(c, 64140), c)
    case False{}:
      dec.n1591(U32.is_lt(c, 64144), c)

def dec.n1593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{671B}"
    case False{}:
      "\u{6756}"

def dec.n1594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B79}"
    case False{}:
      "\u{6BBA}"

def dec.n1595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1593(U32.is_lt(c, 64148), c)
    case False{}:
      dec.n1594(U32.is_lt(c, 64150), c)

def dec.n1596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D41}"
    case False{}:
      "\u{6EDB}"

def dec.n1597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F22}"
    case False{}:
      "\u{701E}"

def dec.n1598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6ECB}"
    case False{}:
      dec.n1597(U32.is_lt(c, 64155), c)

def dec.n1599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1596(U32.is_lt(c, 64152), c)
    case False{}:
      dec.n1598(U32.is_lt(c, 64154), c)

def dec.n1600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1595(U32.is_lt(c, 64149), c)
    case False{}:
      dec.n1599(U32.is_lt(c, 64153), c)

def dec.n1601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1592(U32.is_lt(c, 64142), c)
    case False{}:
      dec.n1600(U32.is_lt(c, 64151), c)

def dec.n1602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{716E}"
    case False{}:
      "\u{77A7}"

def dec.n1603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7235}"
    case False{}:
      "\u{72AF}"

def dec.n1604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1602(U32.is_lt(c, 64157), c)
    case False{}:
      dec.n1603(U32.is_lt(c, 64159), c)

def dec.n1605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{732A}"
    case False{}:
      "\u{7471}"

def dec.n1606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{753B}"
    case False{}:
      "\u{761D}"

def dec.n1607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7506}"
    case False{}:
      dec.n1606(U32.is_lt(c, 64164), c)

def dec.n1608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1605(U32.is_lt(c, 64161), c)
    case False{}:
      dec.n1607(U32.is_lt(c, 64163), c)

def dec.n1609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1604(U32.is_lt(c, 64158), c)
    case False{}:
      dec.n1608(U32.is_lt(c, 64162), c)

def dec.n1610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{761F}"
    case False{}:
      "\u{76CA}"

def dec.n1611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76DB}"
    case False{}:
      "\u{76F4}"

def dec.n1612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1610(U32.is_lt(c, 64166), c)
    case False{}:
      dec.n1611(U32.is_lt(c, 64168), c)

def dec.n1613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{774A}"
    case False{}:
      "\u{7740}"

def dec.n1614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7AB1}"
    case False{}:
      "\u{7BC0}"

def dec.n1615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{78CC}"
    case False{}:
      dec.n1614(U32.is_lt(c, 64173), c)

def dec.n1616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1613(U32.is_lt(c, 64170), c)
    case False{}:
      dec.n1615(U32.is_lt(c, 64172), c)

def dec.n1617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1612(U32.is_lt(c, 64167), c)
    case False{}:
      dec.n1616(U32.is_lt(c, 64171), c)

def dec.n1618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1609(U32.is_lt(c, 64160), c)
    case False{}:
      dec.n1617(U32.is_lt(c, 64169), c)

def dec.n1619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1601(U32.is_lt(c, 64147), c)
    case False{}:
      dec.n1618(U32.is_lt(c, 64165), c)

def dec.n1620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7C7B}"
    case False{}:
      "\u{7D5B}"

def dec.n1621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7DF4}"
    case False{}:
      "\u{7F3E}"

def dec.n1622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1620(U32.is_lt(c, 64175), c)
    case False{}:
      dec.n1621(U32.is_lt(c, 64177), c)

def dec.n1623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8005}"
    case False{}:
      "\u{8352}"

def dec.n1624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8779}"
    case False{}:
      "\u{8941}"

def dec.n1625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{83EF}"
    case False{}:
      dec.n1624(U32.is_lt(c, 64182), c)

def dec.n1626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1623(U32.is_lt(c, 64179), c)
    case False{}:
      dec.n1625(U32.is_lt(c, 64181), c)

def dec.n1627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1622(U32.is_lt(c, 64176), c)
    case False{}:
      dec.n1626(U32.is_lt(c, 64180), c)

def dec.n1628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8986}"
    case False{}:
      "\u{8996}"

def dec.n1629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8ABF}"
    case False{}:
      "\u{8AF8}"

def dec.n1630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1628(U32.is_lt(c, 64184), c)
    case False{}:
      dec.n1629(U32.is_lt(c, 64186), c)

def dec.n1631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8ACB}"
    case False{}:
      "\u{8B01}"

def dec.n1632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AED}"
    case False{}:
      "\u{8B39}"

def dec.n1633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AFE}"
    case False{}:
      dec.n1632(U32.is_lt(c, 64191), c)

def dec.n1634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1631(U32.is_lt(c, 64188), c)
    case False{}:
      dec.n1633(U32.is_lt(c, 64190), c)

def dec.n1635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1630(U32.is_lt(c, 64185), c)
    case False{}:
      dec.n1634(U32.is_lt(c, 64189), c)

def dec.n1636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1627(U32.is_lt(c, 64178), c)
    case False{}:
      dec.n1635(U32.is_lt(c, 64187), c)

def dec.n1637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8B8A}"
    case False{}:
      "\u{8D08}"

def dec.n1638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F38}"
    case False{}:
      "\u{9072}"

def dec.n1639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1637(U32.is_lt(c, 64193), c)
    case False{}:
      dec.n1638(U32.is_lt(c, 64195), c)

def dec.n1640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9199}"
    case False{}:
      "\u{9276}"

def dec.n1641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{96E3}"
    case False{}:
      "\u{9756}"

def dec.n1642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{967C}"
    case False{}:
      dec.n1641(U32.is_lt(c, 64200), c)

def dec.n1643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1640(U32.is_lt(c, 64197), c)
    case False{}:
      dec.n1642(U32.is_lt(c, 64199), c)

def dec.n1644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1639(U32.is_lt(c, 64194), c)
    case False{}:
      dec.n1643(U32.is_lt(c, 64198), c)

def dec.n1645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{97DB}"
    case False{}:
      "\u{97FF}"

def dec.n1646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{980B}"
    case False{}:
      "\u{983B}"

def dec.n1647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1645(U32.is_lt(c, 64202), c)
    case False{}:
      dec.n1646(U32.is_lt(c, 64204), c)

def dec.n1648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9B12}"
    case False{}:
      "\u{9F9C}"

def dec.n1649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22844}"
    case False{}:
      "\u{233D5}"

def dec.n1650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2284A}"
    case False{}:
      dec.n1649(U32.is_lt(c, 64209), c)

def dec.n1651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1648(U32.is_lt(c, 64206), c)
    case False{}:
      dec.n1650(U32.is_lt(c, 64208), c)

def dec.n1652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1647(U32.is_lt(c, 64203), c)
    case False{}:
      dec.n1651(U32.is_lt(c, 64207), c)

def dec.n1653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1644(U32.is_lt(c, 64196), c)
    case False{}:
      dec.n1652(U32.is_lt(c, 64205), c)

def dec.n1654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1636(U32.is_lt(c, 64183), c)
    case False{}:
      dec.n1653(U32.is_lt(c, 64201), c)

def dec.n1655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1619(U32.is_lt(c, 64156), c)
    case False{}:
      dec.n1654(U32.is_lt(c, 64192), c)

def dec.n1656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9D}"
    case False{}:
      "\u{4018}"

def dec.n1657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4039}"
    case False{}:
      "\u{25249}"

def dec.n1658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1656(U32.is_lt(c, 64211), c)
    case False{}:
      dec.n1657(U32.is_lt(c, 64213), c)

def dec.n1659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25CD0}"
    case False{}:
      "\u{27ED3}"

def dec.n1660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9F8E}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9F43}"
    case False{}:
      dec.n1660(U32.is_lt(c, 64218), c)

def dec.n1662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1659(U32.is_lt(c, 64215), c)
    case False{}:
      dec.n1661(U32.is_lt(c, 64217), c)

def dec.n1663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1658(U32.is_lt(c, 64212), c)
    case False{}:
      dec.n1662(U32.is_lt(c, 64216), c)

def dec.n1664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D9}\u{5B4}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5F2}\u{5B7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1664(U32.is_lt(c, 64286), c)
    case False{}:
      dec.n1665(U32.is_lt(c, 64288), c)

def dec.n1667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E9}\u{5C1}"
    case False{}:
      "\u{5E9}\u{5C2}"

def dec.n1668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E9}\u{5BC}\u{5C2}"
    case False{}:
      "\u{5D0}\u{5B7}"

def dec.n1669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E9}\u{5BC}\u{5C1}"
    case False{}:
      dec.n1668(U32.is_lt(c, 64302), c)

def dec.n1670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1667(U32.is_lt(c, 64299), c)
    case False{}:
      dec.n1669(U32.is_lt(c, 64301), c)

def dec.n1671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1666(U32.is_lt(c, 64287), c)
    case False{}:
      dec.n1670(U32.is_lt(c, 64300), c)

def dec.n1672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1663(U32.is_lt(c, 64214), c)
    case False{}:
      dec.n1671(U32.is_lt(c, 64298), c)

def dec.n1673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D0}\u{5B8}"
    case False{}:
      "\u{5D0}\u{5BC}"

def dec.n1674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D1}\u{5BC}"
    case False{}:
      "\u{5D2}\u{5BC}"

def dec.n1675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1673(U32.is_lt(c, 64304), c)
    case False{}:
      dec.n1674(U32.is_lt(c, 64306), c)

def dec.n1676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D3}\u{5BC}"
    case False{}:
      "\u{5D4}\u{5BC}"

def dec.n1677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D6}\u{5BC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D5}\u{5BC}"
    case False{}:
      dec.n1677(U32.is_lt(c, 64311), c)

def dec.n1679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1676(U32.is_lt(c, 64308), c)
    case False{}:
      dec.n1678(U32.is_lt(c, 64310), c)

def dec.n1680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1675(U32.is_lt(c, 64305), c)
    case False{}:
      dec.n1679(U32.is_lt(c, 64309), c)

def dec.n1681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D8}\u{5BC}"
    case False{}:
      "\u{5D9}\u{5BC}"

def dec.n1682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DA}\u{5BC}"
    case False{}:
      "\u{5DB}\u{5BC}"

def dec.n1683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1681(U32.is_lt(c, 64313), c)
    case False{}:
      dec.n1682(U32.is_lt(c, 64315), c)

def dec.n1684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DC}\u{5BC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{5E0}\u{5BC}"

def dec.n1686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DE}\u{5BC}"
    case False{}:
      dec.n1685(U32.is_lt(c, 64320), c)

def dec.n1687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1684(U32.is_lt(c, 64317), c)
    case False{}:
      dec.n1686(U32.is_lt(c, 64319), c)

def dec.n1688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1683(U32.is_lt(c, 64314), c)
    case False{}:
      dec.n1687(U32.is_lt(c, 64318), c)

def dec.n1689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1680(U32.is_lt(c, 64307), c)
    case False{}:
      dec.n1688(U32.is_lt(c, 64316), c)

def dec.n1690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1672(U32.is_lt(c, 64285), c)
    case False{}:
      dec.n1689(U32.is_lt(c, 64312), c)

def dec.n1691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E1}\u{5BC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E3}\u{5BC}"
    case False{}:
      "\u{5E4}\u{5BC}"

def dec.n1693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1691(U32.is_lt(c, 64322), c)
    case False{}:
      dec.n1692(U32.is_lt(c, 64324), c)

def dec.n1694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{5E6}\u{5BC}"

def dec.n1695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E8}\u{5BC}"
    case False{}:
      "\u{5E9}\u{5BC}"

def dec.n1696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E7}\u{5BC}"
    case False{}:
      dec.n1695(U32.is_lt(c, 64329), c)

def dec.n1697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1694(U32.is_lt(c, 64326), c)
    case False{}:
      dec.n1696(U32.is_lt(c, 64328), c)

def dec.n1698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1693(U32.is_lt(c, 64323), c)
    case False{}:
      dec.n1697(U32.is_lt(c, 64327), c)

def dec.n1699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5EA}\u{5BC}"
    case False{}:
      "\u{5D5}\u{5B9}"

def dec.n1700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D1}\u{5BF}"
    case False{}:
      "\u{5DB}\u{5BF}"

def dec.n1701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1699(U32.is_lt(c, 64331), c)
    case False{}:
      dec.n1700(U32.is_lt(c, 64333), c)

def dec.n1702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E4}\u{5BF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{105DA}\u{307}"

def dec.n1704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105D2}\u{307}"
    case False{}:
      dec.n1703(U32.is_lt(c, 67044), c)

def dec.n1705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1702(U32.is_lt(c, 64335), c)
    case False{}:
      dec.n1704(U32.is_lt(c, 67018), c)

def dec.n1706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1701(U32.is_lt(c, 64332), c)
    case False{}:
      dec.n1705(U32.is_lt(c, 67017), c)

def dec.n1707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1698(U32.is_lt(c, 64325), c)
    case False{}:
      dec.n1706(U32.is_lt(c, 64334), c)

def dec.n1708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11099}\u{110BA}"

def dec.n1709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1109B}\u{110BA}"

def dec.n1710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1708(U32.is_lt(c, 69786), c)
    case False{}:
      dec.n1709(U32.is_lt(c, 69788), c)

def dec.n1711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{110A5}\u{110BA}"

def dec.n1712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{11131}\u{11127}"
    case False{}:
      "\u{11132}\u{11127}"

def dec.n1713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1712(U32.is_lt(c, 69935), c)

def dec.n1714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1711(U32.is_lt(c, 69803), c)
    case False{}:
      dec.n1713(U32.is_lt(c, 69934), c)

def dec.n1715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1710(U32.is_lt(c, 69787), c)
    case False{}:
      dec.n1714(U32.is_lt(c, 69804), c)

def dec.n1716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11347}\u{1133E}"

def dec.n1717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11382}\u{113C9}"

def dec.n1718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{11347}\u{11357}"
    case False{}:
      dec.n1717(U32.is_lt(c, 70531), c)

def dec.n1719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1716(U32.is_lt(c, 70475), c)
    case False{}:
      dec.n1718(U32.is_lt(c, 70477), c)

def dec.n1720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11384}\u{113BB}"

def dec.n1721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1138B}\u{113C2}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1721(U32.is_lt(c, 70543), c)

def dec.n1723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1720(U32.is_lt(c, 70533), c)
    case False{}:
      dec.n1722(U32.is_lt(c, 70542), c)

def dec.n1724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1719(U32.is_lt(c, 70476), c)
    case False{}:
      dec.n1723(U32.is_lt(c, 70534), c)

def dec.n1725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1715(U32.is_lt(c, 69789), c)
    case False{}:
      dec.n1724(U32.is_lt(c, 70532), c)

def dec.n1726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1707(U32.is_lt(c, 64330), c)
    case False{}:
      dec.n1725(U32.is_lt(c, 69936), c)

def dec.n1727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1690(U32.is_lt(c, 64303), c)
    case False{}:
      dec.n1726(U32.is_lt(c, 67045), c)

def dec.n1728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1655(U32.is_lt(c, 64174), c)
    case False{}:
      dec.n1727(U32.is_lt(c, 64321), c)

def dec.n1729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1584(U32.is_lt(c, 64064), c)
    case False{}:
      dec.n1728(U32.is_lt(c, 64210), c)

def dec.n1730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1441(U32.is_lt(c, 63842), c)
    case False{}:
      dec.n1729(U32.is_lt(c, 64138), c)

def dec.n1731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{11390}\u{113C9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{113C2}\u{113C2}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1731(U32.is_lt(c, 70546), c)
    case False{}:
      dec.n1732(U32.is_lt(c, 70598), c)

def dec.n1734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{113C2}\u{113B8}"
    case False{}:
      "\u{113C2}\u{113C9}"

def dec.n1735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{114B9}\u{114BA}"
    case False{}:
      "\u{114B9}\u{114B0}"

def dec.n1736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      dec.n1735(U32.is_lt(c, 70844), c)

def dec.n1737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1734(U32.is_lt(c, 70600), c)
    case False{}:
      dec.n1736(U32.is_lt(c, 70843), c)

def dec.n1738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1733(U32.is_lt(c, 70597), c)
    case False{}:
      dec.n1737(U32.is_lt(c, 70601), c)

def dec.n1739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{114B9}\u{114BD}"

def dec.n1740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{115B8}\u{115AF}"

def dec.n1741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1739(U32.is_lt(c, 70846), c)
    case False{}:
      dec.n1740(U32.is_lt(c, 71098), c)

def dec.n1742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{115B9}\u{115AF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1611E}\u{1611E}"

def dec.n1744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{11935}\u{11930}"
    case False{}:
      dec.n1743(U32.is_lt(c, 90401), c)

def dec.n1745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1742(U32.is_lt(c, 71100), c)
    case False{}:
      dec.n1744(U32.is_lt(c, 71993), c)

def dec.n1746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1741(U32.is_lt(c, 70847), c)
    case False{}:
      dec.n1745(U32.is_lt(c, 71992), c)

def dec.n1747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1738(U32.is_lt(c, 70599), c)
    case False{}:
      dec.n1746(U32.is_lt(c, 71099), c)

def dec.n1748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1611E}\u{16129}"
    case False{}:
      "\u{1611E}\u{1611F}"

def dec.n1749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16129}\u{1611F}"
    case False{}:
      "\u{1611E}\u{16120}"

def dec.n1750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1748(U32.is_lt(c, 90403), c)
    case False{}:
      dec.n1749(U32.is_lt(c, 90405), c)

def dec.n1751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1611E}\u{1611E}\u{1611F}"
    case False{}:
      "\u{1611E}\u{16129}\u{1611F}"

def dec.n1752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{16D67}\u{16D67}"

def dec.n1753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1611E}\u{1611E}\u{16120}"
    case False{}:
      dec.n1752(U32.is_lt(c, 93544), c)

def dec.n1754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1751(U32.is_lt(c, 90407), c)
    case False{}:
      dec.n1753(U32.is_lt(c, 90409), c)

def dec.n1755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1750(U32.is_lt(c, 90404), c)
    case False{}:
      dec.n1754(U32.is_lt(c, 90408), c)

def dec.n1756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16D63}\u{16D67}"
    case False{}:
      "\u{16D63}\u{16D67}\u{16D67}"

def dec.n1757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1D157}\u{1D165}"

def dec.n1758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1756(U32.is_lt(c, 93546), c)
    case False{}:
      dec.n1757(U32.is_lt(c, 119134), c)

def dec.n1759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D158}\u{1D165}"
    case False{}:
      "\u{1D158}\u{1D165}\u{1D16E}"

def dec.n1760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D158}\u{1D165}\u{1D170}"
    case False{}:
      "\u{1D158}\u{1D165}\u{1D171}"

def dec.n1761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D158}\u{1D165}\u{1D16F}"
    case False{}:
      dec.n1760(U32.is_lt(c, 119139), c)

def dec.n1762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1759(U32.is_lt(c, 119136), c)
    case False{}:
      dec.n1761(U32.is_lt(c, 119138), c)

def dec.n1763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1758(U32.is_lt(c, 93547), c)
    case False{}:
      dec.n1762(U32.is_lt(c, 119137), c)

def dec.n1764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1755(U32.is_lt(c, 90406), c)
    case False{}:
      dec.n1763(U32.is_lt(c, 119135), c)

def dec.n1765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1747(U32.is_lt(c, 70845), c)
    case False{}:
      dec.n1764(U32.is_lt(c, 93545), c)

def dec.n1766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D158}\u{1D165}\u{1D172}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D1B9}\u{1D165}"
    case False{}:
      "\u{1D1BA}\u{1D165}"

def dec.n1768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1766(U32.is_lt(c, 119141), c)
    case False{}:
      dec.n1767(U32.is_lt(c, 119228), c)

def dec.n1769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D1B9}\u{1D165}\u{1D16E}"
    case False{}:
      "\u{1D1BA}\u{1D165}\u{1D16E}"

def dec.n1770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D1BA}\u{1D165}\u{1D16F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n1771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D1B9}\u{1D165}\u{1D16F}"
    case False{}:
      dec.n1770(U32.is_lt(c, 119233), c)

def dec.n1772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1769(U32.is_lt(c, 119230), c)
    case False{}:
      dec.n1771(U32.is_lt(c, 119232), c)

def dec.n1773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1768(U32.is_lt(c, 119227), c)
    case False{}:
      dec.n1772(U32.is_lt(c, 119231), c)

def dec.n1774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E3D}"
    case False{}:
      "\u{4E38}"

def dec.n1775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E41}"
    case False{}:
      "\u{20122}"

def dec.n1776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1774(U32.is_lt(c, 194561), c)
    case False{}:
      dec.n1775(U32.is_lt(c, 194563), c)

def dec.n1777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4F60}"
    case False{}:
      "\u{4FAE}"

def dec.n1778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5002}"
    case False{}:
      "\u{507A}"

def dec.n1779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4FBB}"
    case False{}:
      dec.n1778(U32.is_lt(c, 194568), c)

def dec.n1780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1777(U32.is_lt(c, 194565), c)
    case False{}:
      dec.n1779(U32.is_lt(c, 194567), c)

def dec.n1781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1776(U32.is_lt(c, 194562), c)
    case False{}:
      dec.n1780(U32.is_lt(c, 194566), c)

def dec.n1782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1773(U32.is_lt(c, 119229), c)
    case False{}:
      dec.n1781(U32.is_lt(c, 194564), c)

def dec.n1783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5099}"
    case False{}:
      "\u{50E7}"

def dec.n1784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{50CF}"
    case False{}:
      "\u{349E}"

def dec.n1785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1783(U32.is_lt(c, 194570), c)
    case False{}:
      dec.n1784(U32.is_lt(c, 194572), c)

def dec.n1786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2063A}"
    case False{}:
      "\u{514D}"

def dec.n1787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5164}"
    case False{}:
      "\u{5177}"

def dec.n1788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5154}"
    case False{}:
      dec.n1787(U32.is_lt(c, 194577), c)

def dec.n1789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1786(U32.is_lt(c, 194574), c)
    case False{}:
      dec.n1788(U32.is_lt(c, 194576), c)

def dec.n1790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1785(U32.is_lt(c, 194571), c)
    case False{}:
      dec.n1789(U32.is_lt(c, 194575), c)

def dec.n1791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2051C}"
    case False{}:
      "\u{34B9}"

def dec.n1792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5167}"
    case False{}:
      "\u{518D}"

def dec.n1793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1791(U32.is_lt(c, 194579), c)
    case False{}:
      dec.n1792(U32.is_lt(c, 194581), c)

def dec.n1794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2054B}"
    case False{}:
      "\u{5197}"

def dec.n1795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4ECC}"
    case False{}:
      "\u{51AC}"

def dec.n1796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51A4}"
    case False{}:
      dec.n1795(U32.is_lt(c, 194586), c)

def dec.n1797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1794(U32.is_lt(c, 194583), c)
    case False{}:
      dec.n1796(U32.is_lt(c, 194585), c)

def dec.n1798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1793(U32.is_lt(c, 194580), c)
    case False{}:
      dec.n1797(U32.is_lt(c, 194584), c)

def dec.n1799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1790(U32.is_lt(c, 194573), c)
    case False{}:
      dec.n1798(U32.is_lt(c, 194582), c)

def dec.n1800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1782(U32.is_lt(c, 194560), c)
    case False{}:
      dec.n1799(U32.is_lt(c, 194578), c)

def dec.n1801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1765(U32.is_lt(c, 90402), c)
    case False{}:
      dec.n1800(U32.is_lt(c, 194569), c)

def dec.n1802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51B5}"
    case False{}:
      "\u{291DF}"

def dec.n1803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51F5}"
    case False{}:
      "\u{5203}"

def dec.n1804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1802(U32.is_lt(c, 194588), c)
    case False{}:
      dec.n1803(U32.is_lt(c, 194590), c)

def dec.n1805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{34DF}"
    case False{}:
      "\u{523B}"

def dec.n1806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5272}"
    case False{}:
      "\u{5277}"

def dec.n1807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5246}"
    case False{}:
      dec.n1806(U32.is_lt(c, 194595), c)

def dec.n1808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1805(U32.is_lt(c, 194592), c)
    case False{}:
      dec.n1807(U32.is_lt(c, 194594), c)

def dec.n1809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1804(U32.is_lt(c, 194589), c)
    case False{}:
      dec.n1808(U32.is_lt(c, 194593), c)

def dec.n1810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3515}"
    case False{}:
      "\u{52C7}"

def dec.n1811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52C9}"
    case False{}:
      "\u{52E4}"

def dec.n1812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1810(U32.is_lt(c, 194597), c)
    case False{}:
      dec.n1811(U32.is_lt(c, 194599), c)

def dec.n1813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{52FA}"
    case False{}:
      "\u{5305}"

def dec.n1814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5317}"
    case False{}:
      "\u{5349}"

def dec.n1815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5306}"
    case False{}:
      dec.n1814(U32.is_lt(c, 194604), c)

def dec.n1816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1813(U32.is_lt(c, 194601), c)
    case False{}:
      dec.n1815(U32.is_lt(c, 194603), c)

def dec.n1817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1812(U32.is_lt(c, 194598), c)
    case False{}:
      dec.n1816(U32.is_lt(c, 194602), c)

def dec.n1818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1809(U32.is_lt(c, 194591), c)
    case False{}:
      dec.n1817(U32.is_lt(c, 194600), c)

def dec.n1819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5351}"
    case False{}:
      "\u{535A}"

def dec.n1820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5373}"
    case False{}:
      "\u{537D}"

def dec.n1821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1819(U32.is_lt(c, 194606), c)
    case False{}:
      dec.n1820(U32.is_lt(c, 194608), c)

def dec.n1822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{537F}"
    case False{}:
      "\u{20A2C}"

def dec.n1823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53CA}"
    case False{}:
      "\u{53DF}"

def dec.n1824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7070}"
    case False{}:
      dec.n1823(U32.is_lt(c, 194615), c)

def dec.n1825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1822(U32.is_lt(c, 194612), c)
    case False{}:
      dec.n1824(U32.is_lt(c, 194614), c)

def dec.n1826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1821(U32.is_lt(c, 194607), c)
    case False{}:
      dec.n1825(U32.is_lt(c, 194613), c)

def dec.n1827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20B63}"
    case False{}:
      "\u{53EB}"

def dec.n1828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{53F1}"
    case False{}:
      "\u{5406}"

def dec.n1829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1827(U32.is_lt(c, 194617), c)
    case False{}:
      dec.n1828(U32.is_lt(c, 194619), c)

def dec.n1830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{549E}"
    case False{}:
      "\u{5438}"

def dec.n1831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5468}"
    case False{}:
      "\u{54A2}"

def dec.n1832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5448}"
    case False{}:
      dec.n1831(U32.is_lt(c, 194624), c)

def dec.n1833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1830(U32.is_lt(c, 194621), c)
    case False{}:
      dec.n1832(U32.is_lt(c, 194623), c)

def dec.n1834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1829(U32.is_lt(c, 194618), c)
    case False{}:
      dec.n1833(U32.is_lt(c, 194622), c)

def dec.n1835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1826(U32.is_lt(c, 194609), c)
    case False{}:
      dec.n1834(U32.is_lt(c, 194620), c)

def dec.n1836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1818(U32.is_lt(c, 194596), c)
    case False{}:
      dec.n1835(U32.is_lt(c, 194616), c)

def dec.n1837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{54F6}"
    case False{}:
      "\u{5510}"

def dec.n1838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5553}"
    case False{}:
      "\u{5563}"

def dec.n1839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1837(U32.is_lt(c, 194626), c)
    case False{}:
      dec.n1838(U32.is_lt(c, 194628), c)

def dec.n1840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5584}"
    case False{}:
      "\u{5599}"

def dec.n1841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55B3}"
    case False{}:
      "\u{55C2}"

def dec.n1842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{55AB}"
    case False{}:
      dec.n1841(U32.is_lt(c, 194634), c)

def dec.n1843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1840(U32.is_lt(c, 194631), c)
    case False{}:
      dec.n1842(U32.is_lt(c, 194633), c)

def dec.n1844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1839(U32.is_lt(c, 194627), c)
    case False{}:
      dec.n1843(U32.is_lt(c, 194632), c)

def dec.n1845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5716}"
    case False{}:
      "\u{5606}"

def dec.n1846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5717}"
    case False{}:
      "\u{5651}"

def dec.n1847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1845(U32.is_lt(c, 194636), c)
    case False{}:
      dec.n1846(U32.is_lt(c, 194638), c)

def dec.n1848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5674}"
    case False{}:
      "\u{5207}"

def dec.n1849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57CE}"
    case False{}:
      "\u{57F4}"

def dec.n1850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58EE}"
    case False{}:
      dec.n1849(U32.is_lt(c, 194643), c)

def dec.n1851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1848(U32.is_lt(c, 194640), c)
    case False{}:
      dec.n1850(U32.is_lt(c, 194642), c)

def dec.n1852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1847(U32.is_lt(c, 194637), c)
    case False{}:
      dec.n1851(U32.is_lt(c, 194641), c)

def dec.n1853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1844(U32.is_lt(c, 194629), c)
    case False{}:
      dec.n1852(U32.is_lt(c, 194639), c)

def dec.n1854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{580D}"
    case False{}:
      "\u{578B}"

def dec.n1855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5832}"
    case False{}:
      "\u{5831}"

def dec.n1856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1854(U32.is_lt(c, 194645), c)
    case False{}:
      dec.n1855(U32.is_lt(c, 194647), c)

def dec.n1857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58AC}"
    case False{}:
      "\u{214E4}"

def dec.n1858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58F7}"
    case False{}:
      "\u{5906}"

def dec.n1859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{58F2}"
    case False{}:
      dec.n1858(U32.is_lt(c, 194652), c)

def dec.n1860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1857(U32.is_lt(c, 194649), c)
    case False{}:
      dec.n1859(U32.is_lt(c, 194651), c)

def dec.n1861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1856(U32.is_lt(c, 194646), c)
    case False{}:
      dec.n1860(U32.is_lt(c, 194650), c)

def dec.n1862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{591A}"
    case False{}:
      "\u{5922}"

def dec.n1863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5962}"
    case False{}:
      "\u{216A8}"

def dec.n1864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1862(U32.is_lt(c, 194654), c)
    case False{}:
      dec.n1863(U32.is_lt(c, 194656), c)

def dec.n1865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{216EA}"
    case False{}:
      "\u{59EC}"

def dec.n1866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5A27}"
    case False{}:
      "\u{59D8}"

def dec.n1867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5A1B}"
    case False{}:
      dec.n1866(U32.is_lt(c, 194661), c)

def dec.n1868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1865(U32.is_lt(c, 194658), c)
    case False{}:
      dec.n1867(U32.is_lt(c, 194660), c)

def dec.n1869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1864(U32.is_lt(c, 194655), c)
    case False{}:
      dec.n1868(U32.is_lt(c, 194659), c)

def dec.n1870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1861(U32.is_lt(c, 194648), c)
    case False{}:
      dec.n1869(U32.is_lt(c, 194657), c)

def dec.n1871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1853(U32.is_lt(c, 194635), c)
    case False{}:
      dec.n1870(U32.is_lt(c, 194653), c)

def dec.n1872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1836(U32.is_lt(c, 194605), c)
    case False{}:
      dec.n1871(U32.is_lt(c, 194644), c)

def dec.n1873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1801(U32.is_lt(c, 119140), c)
    case False{}:
      dec.n1872(U32.is_lt(c, 194625), c)

def dec.n1874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5A66}"
    case False{}:
      "\u{36EE}"

def dec.n1875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{36FC}"
    case False{}:
      "\u{5B08}"

def dec.n1876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1874(U32.is_lt(c, 194663), c)
    case False{}:
      dec.n1875(U32.is_lt(c, 194665), c)

def dec.n1877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5B3E}"
    case False{}:
      "\u{219C8}"

def dec.n1878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BD8}"
    case False{}:
      "\u{5BE7}"

def dec.n1879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BC3}"
    case False{}:
      dec.n1878(U32.is_lt(c, 194671), c)

def dec.n1880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1877(U32.is_lt(c, 194668), c)
    case False{}:
      dec.n1879(U32.is_lt(c, 194670), c)

def dec.n1881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1876(U32.is_lt(c, 194664), c)
    case False{}:
      dec.n1880(U32.is_lt(c, 194669), c)

def dec.n1882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BF3}"
    case False{}:
      "\u{21B18}"

def dec.n1883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5BFF}"
    case False{}:
      "\u{5C06}"

def dec.n1884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1882(U32.is_lt(c, 194673), c)
    case False{}:
      dec.n1883(U32.is_lt(c, 194675), c)

def dec.n1885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5F53}"
    case False{}:
      "\u{5C22}"

def dec.n1886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5C60}"
    case False{}:
      "\u{5C6E}"

def dec.n1887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3781}"
    case False{}:
      dec.n1886(U32.is_lt(c, 194680), c)

def dec.n1888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1885(U32.is_lt(c, 194677), c)
    case False{}:
      dec.n1887(U32.is_lt(c, 194679), c)

def dec.n1889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1884(U32.is_lt(c, 194674), c)
    case False{}:
      dec.n1888(U32.is_lt(c, 194678), c)

def dec.n1890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1881(U32.is_lt(c, 194666), c)
    case False{}:
      dec.n1889(U32.is_lt(c, 194676), c)

def dec.n1891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5CC0}"
    case False{}:
      "\u{5C8D}"

def dec.n1892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{21DE4}"
    case False{}:
      "\u{5D43}"

def dec.n1893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1891(U32.is_lt(c, 194682), c)
    case False{}:
      dec.n1892(U32.is_lt(c, 194684), c)

def dec.n1894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{21DE6}"
    case False{}:
      "\u{5D6E}"

def dec.n1895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D7C}"
    case False{}:
      "\u{5DE1}"

def dec.n1896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5D6B}"
    case False{}:
      dec.n1895(U32.is_lt(c, 194689), c)

def dec.n1897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1894(U32.is_lt(c, 194686), c)
    case False{}:
      dec.n1896(U32.is_lt(c, 194688), c)

def dec.n1898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1893(U32.is_lt(c, 194683), c)
    case False{}:
      dec.n1897(U32.is_lt(c, 194687), c)

def dec.n1899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DE2}"
    case False{}:
      "\u{382F}"

def dec.n1900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DFD}"
    case False{}:
      "\u{5E28}"

def dec.n1901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1899(U32.is_lt(c, 194691), c)
    case False{}:
      dec.n1900(U32.is_lt(c, 194693), c)

def dec.n1902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5E3D}"
    case False{}:
      "\u{5E69}"

def dec.n1903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22183}"
    case False{}:
      "\u{387C}"

def dec.n1904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3862}"
    case False{}:
      dec.n1903(U32.is_lt(c, 194698), c)

def dec.n1905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1902(U32.is_lt(c, 194695), c)
    case False{}:
      dec.n1904(U32.is_lt(c, 194697), c)

def dec.n1906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1901(U32.is_lt(c, 194692), c)
    case False{}:
      dec.n1905(U32.is_lt(c, 194696), c)

def dec.n1907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1898(U32.is_lt(c, 194685), c)
    case False{}:
      dec.n1906(U32.is_lt(c, 194694), c)

def dec.n1908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1890(U32.is_lt(c, 194672), c)
    case False{}:
      dec.n1907(U32.is_lt(c, 194690), c)

def dec.n1909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5EB0}"
    case False{}:
      "\u{5EB3}"

def dec.n1910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5EB6}"
    case False{}:
      "\u{5ECA}"

def dec.n1911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1909(U32.is_lt(c, 194700), c)
    case False{}:
      dec.n1910(U32.is_lt(c, 194702), c)

def dec.n1912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2A392}"
    case False{}:
      "\u{5EFE}"

def dec.n1913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8201}"
    case False{}:
      "\u{5F22}"

def dec.n1914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22331}"
    case False{}:
      dec.n1913(U32.is_lt(c, 194708), c)

def dec.n1915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1912(U32.is_lt(c, 194704), c)
    case False{}:
      dec.n1914(U32.is_lt(c, 194707), c)

def dec.n1916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1911(U32.is_lt(c, 194701), c)
    case False{}:
      dec.n1915(U32.is_lt(c, 194705), c)

def dec.n1917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{38C7}"
    case False{}:
      "\u{232B8}"

def dec.n1918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{261DA}"
    case False{}:
      "\u{5F62}"

def dec.n1919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1917(U32.is_lt(c, 194711), c)
    case False{}:
      dec.n1918(U32.is_lt(c, 194713), c)

def dec.n1920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5F6B}"
    case False{}:
      "\u{38E3}"

def dec.n1921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5FCD}"
    case False{}:
      "\u{5FD7}"

def dec.n1922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5F9A}"
    case False{}:
      dec.n1921(U32.is_lt(c, 194718), c)

def dec.n1923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1920(U32.is_lt(c, 194715), c)
    case False{}:
      dec.n1922(U32.is_lt(c, 194717), c)

def dec.n1924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1919(U32.is_lt(c, 194712), c)
    case False{}:
      dec.n1923(U32.is_lt(c, 194716), c)

def dec.n1925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1916(U32.is_lt(c, 194703), c)
    case False{}:
      dec.n1924(U32.is_lt(c, 194714), c)

def dec.n1926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5FF9}"
    case False{}:
      "\u{6081}"

def dec.n1927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{393A}"
    case False{}:
      "\u{391C}"

def dec.n1928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1926(U32.is_lt(c, 194720), c)
    case False{}:
      dec.n1927(U32.is_lt(c, 194722), c)

def dec.n1929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6094}"
    case False{}:
      "\u{226D4}"

def dec.n1930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6148}"
    case False{}:
      "\u{614C}"

def dec.n1931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{60C7}"
    case False{}:
      dec.n1930(U32.is_lt(c, 194727), c)

def dec.n1932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1929(U32.is_lt(c, 194724), c)
    case False{}:
      dec.n1931(U32.is_lt(c, 194726), c)

def dec.n1933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1928(U32.is_lt(c, 194721), c)
    case False{}:
      dec.n1932(U32.is_lt(c, 194725), c)

def dec.n1934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{614E}"
    case False{}:
      "\u{614C}"

def dec.n1935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{617A}"
    case False{}:
      "\u{618E}"

def dec.n1936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1934(U32.is_lt(c, 194729), c)
    case False{}:
      dec.n1935(U32.is_lt(c, 194731), c)

def dec.n1937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61B2}"
    case False{}:
      "\u{61A4}"

def dec.n1938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61DE}"
    case False{}:
      "\u{61F2}"

def dec.n1939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61AF}"
    case False{}:
      dec.n1938(U32.is_lt(c, 194736), c)

def dec.n1940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1937(U32.is_lt(c, 194733), c)
    case False{}:
      dec.n1939(U32.is_lt(c, 194735), c)

def dec.n1941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1936(U32.is_lt(c, 194730), c)
    case False{}:
      dec.n1940(U32.is_lt(c, 194734), c)

def dec.n1942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1933(U32.is_lt(c, 194723), c)
    case False{}:
      dec.n1941(U32.is_lt(c, 194732), c)

def dec.n1943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1925(U32.is_lt(c, 194710), c)
    case False{}:
      dec.n1942(U32.is_lt(c, 194728), c)

def dec.n1944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1908(U32.is_lt(c, 194681), c)
    case False{}:
      dec.n1943(U32.is_lt(c, 194719), c)

def dec.n1945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{61F6}"
    case False{}:
      "\u{6210}"

def dec.n1946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{621B}"
    case False{}:
      "\u{625D}"

def dec.n1947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1945(U32.is_lt(c, 194738), c)
    case False{}:
      dec.n1946(U32.is_lt(c, 194740), c)

def dec.n1948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62B1}"
    case False{}:
      "\u{62D4}"

def dec.n1949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22B0C}"
    case False{}:
      "\u{633D}"

def dec.n1950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6350}"
    case False{}:
      dec.n1949(U32.is_lt(c, 194745), c)

def dec.n1951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1948(U32.is_lt(c, 194742), c)
    case False{}:
      dec.n1950(U32.is_lt(c, 194744), c)

def dec.n1952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1947(U32.is_lt(c, 194739), c)
    case False{}:
      dec.n1951(U32.is_lt(c, 194743), c)

def dec.n1953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62FC}"
    case False{}:
      "\u{6368}"

def dec.n1954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6383}"
    case False{}:
      "\u{63E4}"

def dec.n1955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1953(U32.is_lt(c, 194747), c)
    case False{}:
      dec.n1954(U32.is_lt(c, 194749), c)

def dec.n1956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22BF1}"
    case False{}:
      "\u{6422}"

def dec.n1957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{63A9}"
    case False{}:
      "\u{3A2E}"

def dec.n1958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{63C5}"
    case False{}:
      dec.n1957(U32.is_lt(c, 194754), c)

def dec.n1959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1956(U32.is_lt(c, 194751), c)
    case False{}:
      dec.n1958(U32.is_lt(c, 194753), c)

def dec.n1960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1955(U32.is_lt(c, 194748), c)
    case False{}:
      dec.n1959(U32.is_lt(c, 194752), c)

def dec.n1961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1952(U32.is_lt(c, 194741), c)
    case False{}:
      dec.n1960(U32.is_lt(c, 194750), c)

def dec.n1962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6469}"
    case False{}:
      "\u{647E}"

def dec.n1963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{649D}"
    case False{}:
      "\u{6477}"

def dec.n1964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1962(U32.is_lt(c, 194756), c)
    case False{}:
      dec.n1963(U32.is_lt(c, 194758), c)

def dec.n1965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3A6C}"
    case False{}:
      "\u{654F}"

def dec.n1966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2300A}"
    case False{}:
      "\u{65E3}"

def dec.n1967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{656C}"
    case False{}:
      dec.n1966(U32.is_lt(c, 194763), c)

def dec.n1968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1965(U32.is_lt(c, 194760), c)
    case False{}:
      dec.n1967(U32.is_lt(c, 194762), c)

def dec.n1969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1964(U32.is_lt(c, 194757), c)
    case False{}:
      dec.n1968(U32.is_lt(c, 194761), c)

def dec.n1970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66F8}"
    case False{}:
      "\u{6649}"

def dec.n1971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B19}"
    case False{}:
      "\u{6691}"

def dec.n1972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1970(U32.is_lt(c, 194765), c)
    case False{}:
      dec.n1971(U32.is_lt(c, 194767), c)

def dec.n1973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B08}"
    case False{}:
      "\u{3AE4}"

def dec.n1974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5195}"
    case False{}:
      "\u{6700}"

def dec.n1975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5192}"
    case False{}:
      dec.n1974(U32.is_lt(c, 194772), c)

def dec.n1976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1973(U32.is_lt(c, 194769), c)
    case False{}:
      dec.n1975(U32.is_lt(c, 194771), c)

def dec.n1977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1972(U32.is_lt(c, 194766), c)
    case False{}:
      dec.n1976(U32.is_lt(c, 194770), c)

def dec.n1978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1969(U32.is_lt(c, 194759), c)
    case False{}:
      dec.n1977(U32.is_lt(c, 194768), c)

def dec.n1979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1961(U32.is_lt(c, 194746), c)
    case False{}:
      dec.n1978(U32.is_lt(c, 194764), c)

def dec.n1980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{669C}"
    case False{}:
      "\u{80AD}"

def dec.n1981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43D9}"
    case False{}:
      "\u{6717}"

def dec.n1982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1980(U32.is_lt(c, 194774), c)
    case False{}:
      dec.n1981(U32.is_lt(c, 194776), c)

def dec.n1983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{671B}"
    case False{}:
      "\u{6721}"

def dec.n1984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6753}"
    case False{}:
      "\u{233C3}"

def dec.n1985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{675E}"
    case False{}:
      dec.n1984(U32.is_lt(c, 194781), c)

def dec.n1986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1983(U32.is_lt(c, 194778), c)
    case False{}:
      dec.n1985(U32.is_lt(c, 194780), c)

def dec.n1987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1982(U32.is_lt(c, 194775), c)
    case False{}:
      dec.n1986(U32.is_lt(c, 194779), c)

def dec.n1988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B49}"
    case False{}:
      "\u{67FA}"

def dec.n1989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6785}"
    case False{}:
      "\u{6852}"

def dec.n1990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1988(U32.is_lt(c, 194783), c)
    case False{}:
      dec.n1989(U32.is_lt(c, 194785), c)

def dec.n1991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6885}"
    case False{}:
      "\u{2346D}"

def dec.n1992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{681F}"
    case False{}:
      "\u{6914}"

def dec.n1993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{688E}"
    case False{}:
      dec.n1992(U32.is_lt(c, 194790), c)

def dec.n1994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1991(U32.is_lt(c, 194787), c)
    case False{}:
      dec.n1993(U32.is_lt(c, 194789), c)

def dec.n1995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1990(U32.is_lt(c, 194784), c)
    case False{}:
      dec.n1994(U32.is_lt(c, 194788), c)

def dec.n1996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1987(U32.is_lt(c, 194777), c)
    case False{}:
      dec.n1995(U32.is_lt(c, 194786), c)

def dec.n1997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9D}"
    case False{}:
      "\u{6942}"

def dec.n1998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69A3}"
    case False{}:
      "\u{69EA}"

def dec.n1999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1997(U32.is_lt(c, 194792), c)
    case False{}:
      dec.n1998(U32.is_lt(c, 194794), c)

def dec.n2000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6AA8}"
    case False{}:
      "\u{236A3}"

def dec.n2001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C18}"
    case False{}:
      "\u{6B21}"

def dec.n2002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6ADB}"
    case False{}:
      dec.n2001(U32.is_lt(c, 194799), c)

def dec.n2003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2000(U32.is_lt(c, 194796), c)
    case False{}:
      dec.n2002(U32.is_lt(c, 194798), c)

def dec.n2004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1999(U32.is_lt(c, 194793), c)
    case False{}:
      dec.n2003(U32.is_lt(c, 194797), c)

def dec.n2005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{238A7}"
    case False{}:
      "\u{6B54}"

def dec.n2006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B72}"
    case False{}:
      "\u{6B9F}"

def dec.n2007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C4E}"
    case False{}:
      dec.n2006(U32.is_lt(c, 194804), c)

def dec.n2008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2005(U32.is_lt(c, 194801), c)
    case False{}:
      dec.n2007(U32.is_lt(c, 194803), c)

def dec.n2009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6BBA}"
    case False{}:
      "\u{6BBB}"

def dec.n2010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{21D0B}"
    case False{}:
      "\u{23AFA}"

def dec.n2011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{23A8D}"
    case False{}:
      dec.n2010(U32.is_lt(c, 194809), c)

def dec.n2012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2009(U32.is_lt(c, 194806), c)
    case False{}:
      dec.n2011(U32.is_lt(c, 194808), c)

def dec.n2013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2008(U32.is_lt(c, 194802), c)
    case False{}:
      dec.n2012(U32.is_lt(c, 194807), c)

def dec.n2014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2004(U32.is_lt(c, 194795), c)
    case False{}:
      dec.n2013(U32.is_lt(c, 194805), c)

def dec.n2015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1996(U32.is_lt(c, 194782), c)
    case False{}:
      dec.n2014(U32.is_lt(c, 194800), c)

def dec.n2016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1979(U32.is_lt(c, 194755), c)
    case False{}:
      dec.n2015(U32.is_lt(c, 194791), c)

def dec.n2017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1944(U32.is_lt(c, 194699), c)
    case False{}:
      dec.n2016(U32.is_lt(c, 194773), c)

def dec.n2018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1873(U32.is_lt(c, 194587), c)
    case False{}:
      dec.n2017(U32.is_lt(c, 194737), c)

def dec.n2019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C4E}"
    case False{}:
      "\u{23CBC}"

def dec.n2020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6CBF}"
    case False{}:
      "\u{6CCD}"

def dec.n2021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2019(U32.is_lt(c, 194811), c)
    case False{}:
      dec.n2020(U32.is_lt(c, 194813), c)

def dec.n2022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C67}"
    case False{}:
      "\u{6D16}"

def dec.n2023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D77}"
    case False{}:
      "\u{6D41}"

def dec.n2024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D3E}"
    case False{}:
      dec.n2023(U32.is_lt(c, 194818), c)

def dec.n2025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2022(U32.is_lt(c, 194815), c)
    case False{}:
      dec.n2024(U32.is_lt(c, 194817), c)

def dec.n2026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2021(U32.is_lt(c, 194812), c)
    case False{}:
      dec.n2025(U32.is_lt(c, 194816), c)

def dec.n2027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D69}"
    case False{}:
      "\u{6D78}"

def dec.n2028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D85}"
    case False{}:
      "\u{23D1E}"

def dec.n2029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2027(U32.is_lt(c, 194820), c)
    case False{}:
      dec.n2028(U32.is_lt(c, 194822), c)

def dec.n2030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6D34}"
    case False{}:
      "\u{6E2F}"

def dec.n2031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3D33}"
    case False{}:
      "\u{6ECB}"

def dec.n2032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E6E}"
    case False{}:
      dec.n2031(U32.is_lt(c, 194827), c)

def dec.n2033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2030(U32.is_lt(c, 194824), c)
    case False{}:
      dec.n2032(U32.is_lt(c, 194826), c)

def dec.n2034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2029(U32.is_lt(c, 194821), c)
    case False{}:
      dec.n2033(U32.is_lt(c, 194825), c)

def dec.n2035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2026(U32.is_lt(c, 194814), c)
    case False{}:
      dec.n2034(U32.is_lt(c, 194823), c)

def dec.n2036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6EC7}"
    case False{}:
      "\u{23ED1}"

def dec.n2037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6DF9}"
    case False{}:
      "\u{6F6E}"

def dec.n2038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2036(U32.is_lt(c, 194829), c)
    case False{}:
      dec.n2037(U32.is_lt(c, 194831), c)

def dec.n2039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{23F5E}"
    case False{}:
      "\u{23F8E}"

def dec.n2040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7039}"
    case False{}:
      "\u{701E}"

def dec.n2041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6FC6}"
    case False{}:
      dec.n2040(U32.is_lt(c, 194836), c)

def dec.n2042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2039(U32.is_lt(c, 194833), c)
    case False{}:
      dec.n2041(U32.is_lt(c, 194835), c)

def dec.n2043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2038(U32.is_lt(c, 194830), c)
    case False{}:
      dec.n2042(U32.is_lt(c, 194834), c)

def dec.n2044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{701B}"
    case False{}:
      "\u{3D96}"

def dec.n2045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{704A}"
    case False{}:
      "\u{707D}"

def dec.n2046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2044(U32.is_lt(c, 194838), c)
    case False{}:
      dec.n2045(U32.is_lt(c, 194840), c)

def dec.n2047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7077}"
    case False{}:
      "\u{70AD}"

def dec.n2048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7145}"
    case False{}:
      "\u{24263}"

def dec.n2049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20525}"
    case False{}:
      dec.n2048(U32.is_lt(c, 194845), c)

def dec.n2050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2047(U32.is_lt(c, 194842), c)
    case False{}:
      dec.n2049(U32.is_lt(c, 194844), c)

def dec.n2051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2046(U32.is_lt(c, 194839), c)
    case False{}:
      dec.n2050(U32.is_lt(c, 194843), c)

def dec.n2052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2043(U32.is_lt(c, 194832), c)
    case False{}:
      dec.n2051(U32.is_lt(c, 194841), c)

def dec.n2053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2035(U32.is_lt(c, 194819), c)
    case False{}:
      dec.n2052(U32.is_lt(c, 194837), c)

def dec.n2054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{719C}"
    case False{}:
      "\u{243AB}"

def dec.n2055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7228}"
    case False{}:
      "\u{7235}"

def dec.n2056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2054(U32.is_lt(c, 194847), c)
    case False{}:
      dec.n2055(U32.is_lt(c, 194849), c)

def dec.n2057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7250}"
    case False{}:
      "\u{24608}"

def dec.n2058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7295}"
    case False{}:
      "\u{24735}"

def dec.n2059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7280}"
    case False{}:
      dec.n2058(U32.is_lt(c, 194854), c)

def dec.n2060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2057(U32.is_lt(c, 194851), c)
    case False{}:
      dec.n2059(U32.is_lt(c, 194853), c)

def dec.n2061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2056(U32.is_lt(c, 194848), c)
    case False{}:
      dec.n2060(U32.is_lt(c, 194852), c)

def dec.n2062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24814}"
    case False{}:
      "\u{737A}"

def dec.n2063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{738B}"
    case False{}:
      "\u{3EAC}"

def dec.n2064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2062(U32.is_lt(c, 194856), c)
    case False{}:
      dec.n2063(U32.is_lt(c, 194858), c)

def dec.n2065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73A5}"
    case False{}:
      "\u{3EB8}"

def dec.n2066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{745C}"
    case False{}:
      "\u{7471}"

def dec.n2067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7447}"
    case False{}:
      dec.n2066(U32.is_lt(c, 194864), c)

def dec.n2068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2065(U32.is_lt(c, 194860), c)
    case False{}:
      dec.n2067(U32.is_lt(c, 194863), c)

def dec.n2069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2064(U32.is_lt(c, 194857), c)
    case False{}:
      dec.n2068(U32.is_lt(c, 194862), c)

def dec.n2070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2061(U32.is_lt(c, 194850), c)
    case False{}:
      dec.n2069(U32.is_lt(c, 194859), c)

def dec.n2071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7485}"
    case False{}:
      "\u{74CA}"

def dec.n2072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3F1B}"
    case False{}:
      "\u{7524}"

def dec.n2073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2071(U32.is_lt(c, 194866), c)
    case False{}:
      dec.n2072(U32.is_lt(c, 194868), c)

def dec.n2074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24C36}"
    case False{}:
      "\u{753E}"

def dec.n2075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7570}"
    case False{}:
      "\u{2219F}"

def dec.n2076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24C92}"
    case False{}:
      dec.n2075(U32.is_lt(c, 194873), c)

def dec.n2077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2074(U32.is_lt(c, 194870), c)
    case False{}:
      dec.n2076(U32.is_lt(c, 194872), c)

def dec.n2078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2073(U32.is_lt(c, 194867), c)
    case False{}:
      dec.n2077(U32.is_lt(c, 194871), c)

def dec.n2079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7610}"
    case False{}:
      "\u{24FA1}"

def dec.n2080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24FB8}"
    case False{}:
      "\u{25044}"

def dec.n2081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2079(U32.is_lt(c, 194875), c)
    case False{}:
      dec.n2080(U32.is_lt(c, 194877), c)

def dec.n2082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3FFC}"
    case False{}:
      "\u{4008}"

def dec.n2083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{250F3}"
    case False{}:
      "\u{250F2}"

def dec.n2084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{76F4}"
    case False{}:
      dec.n2083(U32.is_lt(c, 194882), c)

def dec.n2085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2082(U32.is_lt(c, 194879), c)
    case False{}:
      dec.n2084(U32.is_lt(c, 194881), c)

def dec.n2086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2081(U32.is_lt(c, 194876), c)
    case False{}:
      dec.n2085(U32.is_lt(c, 194880), c)

def dec.n2087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2078(U32.is_lt(c, 194869), c)
    case False{}:
      dec.n2086(U32.is_lt(c, 194878), c)

def dec.n2088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2070(U32.is_lt(c, 194855), c)
    case False{}:
      dec.n2087(U32.is_lt(c, 194874), c)

def dec.n2089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2053(U32.is_lt(c, 194828), c)
    case False{}:
      dec.n2088(U32.is_lt(c, 194865), c)

def dec.n2090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25119}"
    case False{}:
      "\u{25133}"

def dec.n2091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{771E}"
    case False{}:
      "\u{771F}"

def dec.n2092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2090(U32.is_lt(c, 194884), c)
    case False{}:
      dec.n2091(U32.is_lt(c, 194886), c)

def dec.n2093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{774A}"
    case False{}:
      "\u{4039}"

def dec.n2094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4046}"
    case False{}:
      "\u{4096}"

def dec.n2095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{778B}"
    case False{}:
      dec.n2094(U32.is_lt(c, 194892), c)

def dec.n2096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2093(U32.is_lt(c, 194889), c)
    case False{}:
      dec.n2095(U32.is_lt(c, 194891), c)

def dec.n2097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2092(U32.is_lt(c, 194885), c)
    case False{}:
      dec.n2096(U32.is_lt(c, 194890), c)

def dec.n2098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2541D}"
    case False{}:
      "\u{784E}"

def dec.n2099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{788C}"
    case False{}:
      "\u{78CC}"

def dec.n2100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2098(U32.is_lt(c, 194894), c)
    case False{}:
      dec.n2099(U32.is_lt(c, 194896), c)

def dec.n2101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{40E3}"
    case False{}:
      "\u{25626}"

def dec.n2102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2569A}"
    case False{}:
      "\u{256C5}"

def dec.n2103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7956}"
    case False{}:
      dec.n2102(U32.is_lt(c, 194901), c)

def dec.n2104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2101(U32.is_lt(c, 194898), c)
    case False{}:
      dec.n2103(U32.is_lt(c, 194900), c)

def dec.n2105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2100(U32.is_lt(c, 194895), c)
    case False{}:
      dec.n2104(U32.is_lt(c, 194899), c)

def dec.n2106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2097(U32.is_lt(c, 194888), c)
    case False{}:
      dec.n2105(U32.is_lt(c, 194897), c)

def dec.n2107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{798F}"
    case False{}:
      "\u{79EB}"

def dec.n2108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{412F}"
    case False{}:
      "\u{7A40}"

def dec.n2109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2107(U32.is_lt(c, 194903), c)
    case False{}:
      dec.n2108(U32.is_lt(c, 194905), c)

def dec.n2110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7A4A}"
    case False{}:
      "\u{7A4F}"

def dec.n2111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25AA7}"
    case False{}:
      "\u{7AEE}"

def dec.n2112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2597C}"
    case False{}:
      dec.n2111(U32.is_lt(c, 194911), c)

def dec.n2113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2110(U32.is_lt(c, 194907), c)
    case False{}:
      dec.n2112(U32.is_lt(c, 194909), c)

def dec.n2114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2109(U32.is_lt(c, 194904), c)
    case False{}:
      dec.n2113(U32.is_lt(c, 194908), c)

def dec.n2115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4202}"
    case False{}:
      "\u{25BAB}"

def dec.n2116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7BC6}"
    case False{}:
      "\u{7BC9}"

def dec.n2117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2115(U32.is_lt(c, 194913), c)
    case False{}:
      dec.n2116(U32.is_lt(c, 194915), c)

def dec.n2118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4227}"
    case False{}:
      "\u{25C80}"

def dec.n2119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{42A0}"
    case False{}:
      "\u{7CE8}"

def dec.n2120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7CD2}"
    case False{}:
      dec.n2119(U32.is_lt(c, 194920), c)

def dec.n2121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2118(U32.is_lt(c, 194917), c)
    case False{}:
      dec.n2120(U32.is_lt(c, 194919), c)

def dec.n2122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2117(U32.is_lt(c, 194914), c)
    case False{}:
      dec.n2121(U32.is_lt(c, 194918), c)

def dec.n2123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2114(U32.is_lt(c, 194906), c)
    case False{}:
      dec.n2122(U32.is_lt(c, 194916), c)

def dec.n2124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2106(U32.is_lt(c, 194893), c)
    case False{}:
      dec.n2123(U32.is_lt(c, 194912), c)

def dec.n2125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7CE3}"
    case False{}:
      "\u{7D00}"

def dec.n2126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25F86}"
    case False{}:
      "\u{7D63}"

def dec.n2127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2125(U32.is_lt(c, 194922), c)
    case False{}:
      dec.n2126(U32.is_lt(c, 194924), c)

def dec.n2128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4301}"
    case False{}:
      "\u{7DC7}"

def dec.n2129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7E45}"
    case False{}:
      "\u{4334}"

def dec.n2130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7E02}"
    case False{}:
      dec.n2129(U32.is_lt(c, 194929), c)

def dec.n2131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2128(U32.is_lt(c, 194926), c)
    case False{}:
      dec.n2130(U32.is_lt(c, 194928), c)

def dec.n2132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2127(U32.is_lt(c, 194923), c)
    case False{}:
      dec.n2131(U32.is_lt(c, 194927), c)

def dec.n2133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{26228}"
    case False{}:
      "\u{26247}"

def dec.n2134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4359}"
    case False{}:
      "\u{262D9}"

def dec.n2135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2133(U32.is_lt(c, 194931), c)
    case False{}:
      dec.n2134(U32.is_lt(c, 194933), c)

def dec.n2136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7F7A}"
    case False{}:
      "\u{2633E}"

def dec.n2137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7FFA}"
    case False{}:
      "\u{8005}"

def dec.n2138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{7F95}"
    case False{}:
      dec.n2137(U32.is_lt(c, 194938), c)

def dec.n2139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2136(U32.is_lt(c, 194935), c)
    case False{}:
      dec.n2138(U32.is_lt(c, 194937), c)

def dec.n2140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2135(U32.is_lt(c, 194932), c)
    case False{}:
      dec.n2139(U32.is_lt(c, 194936), c)

def dec.n2141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2132(U32.is_lt(c, 194925), c)
    case False{}:
      dec.n2140(U32.is_lt(c, 194934), c)

def dec.n2142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{264DA}"
    case False{}:
      "\u{26523}"

def dec.n2143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8060}"
    case False{}:
      "\u{265A8}"

def dec.n2144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2142(U32.is_lt(c, 194940), c)
    case False{}:
      dec.n2143(U32.is_lt(c, 194942), c)

def dec.n2145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8070}"
    case False{}:
      "\u{2335F}"

def dec.n2146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{80B2}"
    case False{}:
      "\u{8103}"

def dec.n2147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43D5}"
    case False{}:
      dec.n2146(U32.is_lt(c, 194947), c)

def dec.n2148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2145(U32.is_lt(c, 194944), c)
    case False{}:
      dec.n2147(U32.is_lt(c, 194946), c)

def dec.n2149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2144(U32.is_lt(c, 194941), c)
    case False{}:
      dec.n2148(U32.is_lt(c, 194945), c)

def dec.n2150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{440B}"
    case False{}:
      "\u{813E}"

def dec.n2151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5AB5}"
    case False{}:
      "\u{267A7}"

def dec.n2152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2150(U32.is_lt(c, 194949), c)
    case False{}:
      dec.n2151(U32.is_lt(c, 194951), c)

def dec.n2153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{267B5}"
    case False{}:
      "\u{23393}"

def dec.n2154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8201}"
    case False{}:
      "\u{8204}"

def dec.n2155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2339C}"
    case False{}:
      dec.n2154(U32.is_lt(c, 194956), c)

def dec.n2156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2153(U32.is_lt(c, 194953), c)
    case False{}:
      dec.n2155(U32.is_lt(c, 194955), c)

def dec.n2157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2152(U32.is_lt(c, 194950), c)
    case False{}:
      dec.n2156(U32.is_lt(c, 194954), c)

def dec.n2158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2149(U32.is_lt(c, 194943), c)
    case False{}:
      dec.n2157(U32.is_lt(c, 194952), c)

def dec.n2159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2141(U32.is_lt(c, 194930), c)
    case False{}:
      dec.n2158(U32.is_lt(c, 194948), c)

def dec.n2160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2124(U32.is_lt(c, 194902), c)
    case False{}:
      dec.n2159(U32.is_lt(c, 194939), c)

def dec.n2161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2089(U32.is_lt(c, 194846), c)
    case False{}:
      dec.n2160(U32.is_lt(c, 194921), c)

def dec.n2162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8F9E}"
    case False{}:
      "\u{446B}"

def dec.n2163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8291}"
    case False{}:
      "\u{828B}"

def dec.n2164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2162(U32.is_lt(c, 194958), c)
    case False{}:
      dec.n2163(U32.is_lt(c, 194960), c)

def dec.n2165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{829D}"
    case False{}:
      "\u{52B3}"

def dec.n2166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{82B3}"
    case False{}:
      "\u{82BD}"

def dec.n2167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{82B1}"
    case False{}:
      dec.n2166(U32.is_lt(c, 194965), c)

def dec.n2168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2165(U32.is_lt(c, 194962), c)
    case False{}:
      dec.n2167(U32.is_lt(c, 194964), c)

def dec.n2169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2164(U32.is_lt(c, 194959), c)
    case False{}:
      dec.n2168(U32.is_lt(c, 194963), c)

def dec.n2170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{82E6}"
    case False{}:
      "\u{26B3C}"

def dec.n2171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{82E5}"
    case False{}:
      "\u{831D}"

def dec.n2172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2170(U32.is_lt(c, 194967), c)
    case False{}:
      dec.n2171(U32.is_lt(c, 194969), c)

def dec.n2173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8363}"
    case False{}:
      "\u{83AD}"

def dec.n2174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{83BD}"
    case False{}:
      "\u{83E7}"

def dec.n2175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8323}"
    case False{}:
      dec.n2174(U32.is_lt(c, 194974), c)

def dec.n2176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2173(U32.is_lt(c, 194971), c)
    case False{}:
      dec.n2175(U32.is_lt(c, 194973), c)

def dec.n2177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2172(U32.is_lt(c, 194968), c)
    case False{}:
      dec.n2176(U32.is_lt(c, 194972), c)

def dec.n2178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2169(U32.is_lt(c, 194961), c)
    case False{}:
      dec.n2177(U32.is_lt(c, 194970), c)

def dec.n2179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8457}"
    case False{}:
      "\u{8353}"

def dec.n2180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{83CA}"
    case False{}:
      "\u{83CC}"

def dec.n2181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2179(U32.is_lt(c, 194976), c)
    case False{}:
      dec.n2180(U32.is_lt(c, 194978), c)

def dec.n2182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{83DC}"
    case False{}:
      "\u{26C36}"

def dec.n2183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{26CD5}"
    case False{}:
      "\u{452B}"

def dec.n2184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{26D6B}"
    case False{}:
      dec.n2183(U32.is_lt(c, 194983), c)

def dec.n2185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2182(U32.is_lt(c, 194980), c)
    case False{}:
      dec.n2184(U32.is_lt(c, 194982), c)

def dec.n2186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2181(U32.is_lt(c, 194977), c)
    case False{}:
      dec.n2185(U32.is_lt(c, 194981), c)

def dec.n2187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{84F1}"
    case False{}:
      "\u{84F3}"

def dec.n2188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8516}"
    case False{}:
      "\u{273CA}"

def dec.n2189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2187(U32.is_lt(c, 194985), c)
    case False{}:
      dec.n2188(U32.is_lt(c, 194987), c)

def dec.n2190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8564}"
    case False{}:
      "\u{26F2C}"

def dec.n2191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4561}"
    case False{}:
      "\u{26FB1}"

def dec.n2192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{455D}"
    case False{}:
      dec.n2191(U32.is_lt(c, 194992), c)

def dec.n2193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2190(U32.is_lt(c, 194989), c)
    case False{}:
      dec.n2192(U32.is_lt(c, 194991), c)

def dec.n2194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2189(U32.is_lt(c, 194986), c)
    case False{}:
      dec.n2193(U32.is_lt(c, 194990), c)

def dec.n2195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2186(U32.is_lt(c, 194979), c)
    case False{}:
      dec.n2194(U32.is_lt(c, 194988), c)

def dec.n2196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2178(U32.is_lt(c, 194966), c)
    case False{}:
      dec.n2195(U32.is_lt(c, 194984), c)

def dec.n2197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{270D2}"
    case False{}:
      "\u{456B}"

def dec.n2198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8650}"
    case False{}:
      "\u{865C}"

def dec.n2199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2197(U32.is_lt(c, 194994), c)
    case False{}:
      dec.n2198(U32.is_lt(c, 194996), c)

def dec.n2200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8667}"
    case False{}:
      "\u{8669}"

def dec.n2201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8688}"
    case False{}:
      "\u{870E}"

def dec.n2202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{86A9}"
    case False{}:
      dec.n2201(U32.is_lt(c, 195001), c)

def dec.n2203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2200(U32.is_lt(c, 194998), c)
    case False{}:
      dec.n2202(U32.is_lt(c, 195000), c)

def dec.n2204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2199(U32.is_lt(c, 194995), c)
    case False{}:
      dec.n2203(U32.is_lt(c, 194999), c)

def dec.n2205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{86E2}"
    case False{}:
      "\u{8779}"

def dec.n2206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8728}"
    case False{}:
      "\u{876B}"

def dec.n2207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2205(U32.is_lt(c, 195003), c)
    case False{}:
      dec.n2206(U32.is_lt(c, 195005), c)

def dec.n2208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8786}"
    case False{}:
      "\u{45D7}"

def dec.n2209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8801}"
    case False{}:
      "\u{45F9}"

def dec.n2210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{87E1}"
    case False{}:
      dec.n2209(U32.is_lt(c, 195010), c)

def dec.n2211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2208(U32.is_lt(c, 195007), c)
    case False{}:
      dec.n2210(U32.is_lt(c, 195009), c)

def dec.n2212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2207(U32.is_lt(c, 195004), c)
    case False{}:
      dec.n2211(U32.is_lt(c, 195008), c)

def dec.n2213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2204(U32.is_lt(c, 194997), c)
    case False{}:
      dec.n2212(U32.is_lt(c, 195006), c)

def dec.n2214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8860}"
    case False{}:
      "\u{8863}"

def dec.n2215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{27667}"
    case False{}:
      "\u{88D7}"

def dec.n2216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2214(U32.is_lt(c, 195012), c)
    case False{}:
      dec.n2215(U32.is_lt(c, 195014), c)

def dec.n2217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{88DE}"
    case False{}:
      "\u{4635}"

def dec.n2218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{34BB}"
    case False{}:
      "\u{278AE}"

def dec.n2219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{88FA}"
    case False{}:
      dec.n2218(U32.is_lt(c, 195019), c)

def dec.n2220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2217(U32.is_lt(c, 195016), c)
    case False{}:
      dec.n2219(U32.is_lt(c, 195018), c)

def dec.n2221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2216(U32.is_lt(c, 195013), c)
    case False{}:
      dec.n2220(U32.is_lt(c, 195017), c)

def dec.n2222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{27966}"
    case False{}:
      "\u{46BE}"

def dec.n2223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{46C7}"
    case False{}:
      "\u{8AA0}"

def dec.n2224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2222(U32.is_lt(c, 195021), c)
    case False{}:
      dec.n2223(U32.is_lt(c, 195023), c)

def dec.n2225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8AED}"
    case False{}:
      "\u{8B8A}"

def dec.n2226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{27CA8}"
    case False{}:
      "\u{8CAB}"

def dec.n2227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8C55}"
    case False{}:
      dec.n2226(U32.is_lt(c, 195028), c)

def dec.n2228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2225(U32.is_lt(c, 195025), c)
    case False{}:
      dec.n2227(U32.is_lt(c, 195027), c)

def dec.n2229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2224(U32.is_lt(c, 195022), c)
    case False{}:
      dec.n2228(U32.is_lt(c, 195026), c)

def dec.n2230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2221(U32.is_lt(c, 195015), c)
    case False{}:
      dec.n2229(U32.is_lt(c, 195024), c)

def dec.n2231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2213(U32.is_lt(c, 195002), c)
    case False{}:
      dec.n2230(U32.is_lt(c, 195020), c)

def dec.n2232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2196(U32.is_lt(c, 194975), c)
    case False{}:
      dec.n2231(U32.is_lt(c, 195011), c)

def dec.n2233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8CC1}"
    case False{}:
      "\u{8D1B}"

def dec.n2234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8D77}"
    case False{}:
      "\u{27F2F}"

def dec.n2235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2233(U32.is_lt(c, 195030), c)
    case False{}:
      dec.n2234(U32.is_lt(c, 195032), c)

def dec.n2236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20804}"
    case False{}:
      "\u{8DCB}"

def dec.n2237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8DF0}"
    case False{}:
      "\u{208DE}"

def dec.n2238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8DBC}"
    case False{}:
      dec.n2237(U32.is_lt(c, 195037), c)

def dec.n2239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2236(U32.is_lt(c, 195034), c)
    case False{}:
      dec.n2238(U32.is_lt(c, 195036), c)

def dec.n2240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2235(U32.is_lt(c, 195031), c)
    case False{}:
      dec.n2239(U32.is_lt(c, 195035), c)

def dec.n2241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{8ED4}"
    case False{}:
      "\u{8F38}"

def dec.n2242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{285D2}"
    case False{}:
      "\u{285ED}"

def dec.n2243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2241(U32.is_lt(c, 195039), c)
    case False{}:
      dec.n2242(U32.is_lt(c, 195041), c)

def dec.n2244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9094}"
    case False{}:
      "\u{90F1}"

def dec.n2245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2872E}"
    case False{}:
      "\u{911B}"

def dec.n2246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9111}"
    case False{}:
      dec.n2245(U32.is_lt(c, 195046), c)

def dec.n2247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2244(U32.is_lt(c, 195043), c)
    case False{}:
      dec.n2246(U32.is_lt(c, 195045), c)

def dec.n2248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2243(U32.is_lt(c, 195040), c)
    case False{}:
      dec.n2247(U32.is_lt(c, 195044), c)

def dec.n2249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2240(U32.is_lt(c, 195033), c)
    case False{}:
      dec.n2248(U32.is_lt(c, 195042), c)

def dec.n2250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9238}"
    case False{}:
      "\u{92D7}"

def dec.n2251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{92D8}"
    case False{}:
      "\u{927C}"

def dec.n2252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2250(U32.is_lt(c, 195048), c)
    case False{}:
      dec.n2251(U32.is_lt(c, 195050), c)

def dec.n2253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{93F9}"
    case False{}:
      "\u{9415}"

def dec.n2254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{958B}"
    case False{}:
      "\u{4995}"

def dec.n2255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{28BFA}"
    case False{}:
      dec.n2254(U32.is_lt(c, 195055), c)

def dec.n2256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2253(U32.is_lt(c, 195052), c)
    case False{}:
      dec.n2255(U32.is_lt(c, 195054), c)

def dec.n2257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2252(U32.is_lt(c, 195049), c)
    case False{}:
      dec.n2256(U32.is_lt(c, 195053), c)

def dec.n2258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{95B7}"
    case False{}:
      "\u{28D77}"

def dec.n2259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49E6}"
    case False{}:
      "\u{96C3}"

def dec.n2260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2258(U32.is_lt(c, 195057), c)
    case False{}:
      dec.n2259(U32.is_lt(c, 195059), c)

def dec.n2261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{5DB2}"
    case False{}:
      "\u{9723}"

def dec.n2262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2921A}"
    case False{}:
      "\u{4A6E}"

def dec.n2263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{29145}"
    case False{}:
      dec.n2262(U32.is_lt(c, 195064), c)

def dec.n2264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2261(U32.is_lt(c, 195061), c)
    case False{}:
      dec.n2263(U32.is_lt(c, 195063), c)

def dec.n2265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2260(U32.is_lt(c, 195058), c)
    case False{}:
      dec.n2264(U32.is_lt(c, 195062), c)

def dec.n2266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2257(U32.is_lt(c, 195051), c)
    case False{}:
      dec.n2265(U32.is_lt(c, 195060), c)

def dec.n2267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2249(U32.is_lt(c, 195038), c)
    case False{}:
      dec.n2266(U32.is_lt(c, 195056), c)

def dec.n2268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A76}"
    case False{}:
      "\u{97E0}"

def dec.n2269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2940A}"
    case False{}:
      "\u{4AB2}"

def dec.n2270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2268(U32.is_lt(c, 195066), c)
    case False{}:
      dec.n2269(U32.is_lt(c, 195068), c)

def dec.n2271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{29496}"
    case False{}:
      "\u{980B}"

def dec.n2272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{295B6}"
    case False{}:
      "\u{98E2}"

def dec.n2273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9829}"
    case False{}:
      dec.n2272(U32.is_lt(c, 195074), c)

def dec.n2274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2271(U32.is_lt(c, 195070), c)
    case False{}:
      dec.n2273(U32.is_lt(c, 195073), c)

def dec.n2275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2270(U32.is_lt(c, 195067), c)
    case False{}:
      dec.n2274(U32.is_lt(c, 195072), c)

def dec.n2276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4B33}"
    case False{}:
      "\u{9929}"

def dec.n2277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{99A7}"
    case False{}:
      "\u{99C2}"

def dec.n2278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2276(U32.is_lt(c, 195076), c)
    case False{}:
      dec.n2277(U32.is_lt(c, 195078), c)

def dec.n2279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{99FE}"
    case False{}:
      "\u{4BCE}"

def dec.n2280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9B12}"
    case False{}:
      "\u{9C40}"

def dec.n2281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{29B30}"
    case False{}:
      dec.n2280(U32.is_lt(c, 195083), c)

def dec.n2282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2279(U32.is_lt(c, 195080), c)
    case False{}:
      dec.n2281(U32.is_lt(c, 195082), c)

def dec.n2283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2278(U32.is_lt(c, 195077), c)
    case False{}:
      dec.n2282(U32.is_lt(c, 195081), c)

def dec.n2284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2275(U32.is_lt(c, 195069), c)
    case False{}:
      dec.n2283(U32.is_lt(c, 195079), c)

def dec.n2285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9CFD}"
    case False{}:
      "\u{4CCE}"

def dec.n2286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4CED}"
    case False{}:
      "\u{9D67}"

def dec.n2287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2285(U32.is_lt(c, 195085), c)
    case False{}:
      dec.n2286(U32.is_lt(c, 195087), c)

def dec.n2288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2A0CE}"
    case False{}:
      "\u{4CF8}"

def dec.n2289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2A20E}"
    case False{}:
      "\u{2A291}"

def dec.n2290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2A105}"
    case False{}:
      dec.n2289(U32.is_lt(c, 195092), c)

def dec.n2291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2288(U32.is_lt(c, 195089), c)
    case False{}:
      dec.n2290(U32.is_lt(c, 195091), c)

def dec.n2292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2287(U32.is_lt(c, 195086), c)
    case False{}:
      dec.n2291(U32.is_lt(c, 195090), c)

def dec.n2293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9EBB}"
    case False{}:
      "\u{4D56}"

def dec.n2294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9EFE}"
    case False{}:
      "\u{9F05}"

def dec.n2295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9EF9}"
    case False{}:
      dec.n2294(U32.is_lt(c, 195097), c)

def dec.n2296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2293(U32.is_lt(c, 195094), c)
    case False{}:
      dec.n2295(U32.is_lt(c, 195096), c)

def dec.n2297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9F0F}"
    case False{}:
      "\u{9F16}"

def dec.n2298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2A600}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def dec.n2299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{9F3B}"
    case False{}:
      dec.n2298(U32.is_lt(c, 195102), c)

def dec.n2300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2297(U32.is_lt(c, 195099), c)
    case False{}:
      dec.n2299(U32.is_lt(c, 195101), c)

def dec.n2301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2296(U32.is_lt(c, 195095), c)
    case False{}:
      dec.n2300(U32.is_lt(c, 195100), c)

def dec.n2302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2292(U32.is_lt(c, 195088), c)
    case False{}:
      dec.n2301(U32.is_lt(c, 195098), c)

def dec.n2303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2284(U32.is_lt(c, 195075), c)
    case False{}:
      dec.n2302(U32.is_lt(c, 195093), c)

def dec.n2304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2267(U32.is_lt(c, 195047), c)
    case False{}:
      dec.n2303(U32.is_lt(c, 195084), c)

def dec.n2305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2232(U32.is_lt(c, 194993), c)
    case False{}:
      dec.n2304(U32.is_lt(c, 195065), c)

def dec.n2306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2161(U32.is_lt(c, 194883), c)
    case False{}:
      dec.n2305(U32.is_lt(c, 195029), c)

def dec.n2307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n2018(U32.is_lt(c, 194662), c)
    case False{}:
      dec.n2306(U32.is_lt(c, 194957), c)

def dec.n2308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1730(U32.is_lt(c, 63987), c)
    case False{}:
      dec.n2307(U32.is_lt(c, 194810), c)

def dec.n2309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      dec.n1153(U32.is_lt(c, 7733), c)
    case False{}:
      dec.n2308(U32.is_lt(c, 70545), c)

def dec(+c: U32) -> String:
  dec.n2309(U32.is_lt(c, 12467), c)

def comp.b768.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{192}

def comp.b768.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{200}

def comp.b768.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b768.n1(U32.is_lt(a, 69), a)

def comp.b768.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{204}

def comp.b768.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{504}
    case False{}:
      Some{210}

def comp.b768.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n4(U32.is_lt(a, 79), a)

def comp.b768.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n3(U32.is_lt(a, 73), a)
    case False{}:
      comp.b768.n5(U32.is_lt(a, 78), a)

def comp.b768.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n2(U32.is_lt(a, 66), a)
    case False{}:
      comp.b768.n6(U32.is_lt(a, 74), a)

def comp.b768.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{217}

def comp.b768.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7808}

def comp.b768.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n8(U32.is_lt(a, 85), a)
    case False{}:
      comp.b768.n9(U32.is_lt(a, 87), a)

def comp.b768.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7922}

def comp.b768.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{224}
    case False{}:
      None{}

def comp.b768.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n12(U32.is_lt(a, 98), a)

def comp.b768.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n11(U32.is_lt(a, 89), a)
    case False{}:
      comp.b768.n13(U32.is_lt(a, 97), a)

def comp.b768.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n10(U32.is_lt(a, 86), a)
    case False{}:
      comp.b768.n14(U32.is_lt(a, 90), a)

def comp.b768.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n7(U32.is_lt(a, 70), a)
    case False{}:
      comp.b768.n15(U32.is_lt(a, 88), a)

def comp.b768.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{232}
    case False{}:
      None{}

def comp.b768.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{236}
    case False{}:
      None{}

def comp.b768.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n17(U32.is_lt(a, 102), a)
    case False{}:
      comp.b768.n18(U32.is_lt(a, 106), a)

def comp.b768.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{505}
    case False{}:
      Some{242}

def comp.b768.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{249}
    case False{}:
      None{}

def comp.b768.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n21(U32.is_lt(a, 118), a)

def comp.b768.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n20(U32.is_lt(a, 111), a)
    case False{}:
      comp.b768.n22(U32.is_lt(a, 117), a)

def comp.b768.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n19(U32.is_lt(a, 105), a)
    case False{}:
      comp.b768.n23(U32.is_lt(a, 112), a)

def comp.b768.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7809}
    case False{}:
      None{}

def comp.b768.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7923}
    case False{}:
      None{}

def comp.b768.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n25(U32.is_lt(a, 120), a)
    case False{}:
      comp.b768.n26(U32.is_lt(a, 122), a)

def comp.b768.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8173}
    case False{}:
      None{}

def comp.b768.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7872}

def comp.b768.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7846}
    case False{}:
      comp.b768.n29(U32.is_lt(a, 202), a)

def comp.b768.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n28(U32.is_lt(a, 169), a)
    case False{}:
      comp.b768.n30(U32.is_lt(a, 195), a)

def comp.b768.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n27(U32.is_lt(a, 121), a)
    case False{}:
      comp.b768.n31(U32.is_lt(a, 194), a)

def comp.b768.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n24(U32.is_lt(a, 110), a)
    case False{}:
      comp.b768.n32(U32.is_lt(a, 168), a)

def comp.b768.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n16(U32.is_lt(a, 80), a)
    case False{}:
      comp.b768.n33(U32.is_lt(a, 119), a)

def comp.b768.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7890}

def comp.b768.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{475}

def comp.b768.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n35(U32.is_lt(a, 212), a)
    case False{}:
      comp.b768.n36(U32.is_lt(a, 220), a)

def comp.b768.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7847}

def comp.b768.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7873}
    case False{}:
      None{}

def comp.b768.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n39(U32.is_lt(a, 235), a)

def comp.b768.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n38(U32.is_lt(a, 226), a)
    case False{}:
      comp.b768.n40(U32.is_lt(a, 234), a)

def comp.b768.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n37(U32.is_lt(a, 213), a)
    case False{}:
      comp.b768.n41(U32.is_lt(a, 227), a)

def comp.b768.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7891}
    case False{}:
      None{}

def comp.b768.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{476}
    case False{}:
      None{}

def comp.b768.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n43(U32.is_lt(a, 245), a)
    case False{}:
      comp.b768.n44(U32.is_lt(a, 253), a)

def comp.b768.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7856}
    case False{}:
      Some{7857}

def comp.b768.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7700}
    case False{}:
      Some{7701}

def comp.b768.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n47(U32.is_lt(a, 275), a)

def comp.b768.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n46(U32.is_lt(a, 259), a)
    case False{}:
      comp.b768.n48(U32.is_lt(a, 274), a)

def comp.b768.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n45(U32.is_lt(a, 252), a)
    case False{}:
      comp.b768.n49(U32.is_lt(a, 260), a)

def comp.b768.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n42(U32.is_lt(a, 221), a)
    case False{}:
      comp.b768.n50(U32.is_lt(a, 258), a)

def comp.b768.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7760}

def comp.b768.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7761}
    case False{}:
      None{}

def comp.b768.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n52(U32.is_lt(a, 332), a)
    case False{}:
      comp.b768.n53(U32.is_lt(a, 334), a)

def comp.b768.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7900}
    case False{}:
      Some{7901}

def comp.b768.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7914}
    case False{}:
      Some{7915}

def comp.b768.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n56(U32.is_lt(a, 432), a)

def comp.b768.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n55(U32.is_lt(a, 417), a)
    case False{}:
      comp.b768.n57(U32.is_lt(a, 431), a)

def comp.b768.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n54(U32.is_lt(a, 333), a)
    case False{}:
      comp.b768.n58(U32.is_lt(a, 418), a)

def comp.b768.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8122}

def comp.b768.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8136}
    case False{}:
      None{}

def comp.b768.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n61(U32.is_lt(a, 918), a)

def comp.b768.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n60(U32.is_lt(a, 913), a)
    case False{}:
      comp.b768.n62(U32.is_lt(a, 917), a)

def comp.b768.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8138}
    case False{}:
      None{}

def comp.b768.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8184}

def comp.b768.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8154}
    case False{}:
      comp.b768.n65(U32.is_lt(a, 927), a)

def comp.b768.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n64(U32.is_lt(a, 920), a)
    case False{}:
      comp.b768.n66(U32.is_lt(a, 922), a)

def comp.b768.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n63(U32.is_lt(a, 914), a)
    case False{}:
      comp.b768.n67(U32.is_lt(a, 921), a)

def comp.b768.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n59(U32.is_lt(a, 416), a)
    case False{}:
      comp.b768.n68(U32.is_lt(a, 919), a)

def comp.b768.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n51(U32.is_lt(a, 244), a)
    case False{}:
      comp.b768.n69(U32.is_lt(a, 433), a)

def comp.b768.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n34(U32.is_lt(a, 101), a)
    case False{}:
      comp.b768.n70(U32.is_lt(a, 276), a)

def comp.b768.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8170}

def comp.b768.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8186}

def comp.b768.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n72(U32.is_lt(a, 933), a)
    case False{}:
      comp.b768.n73(U32.is_lt(a, 937), a)

def comp.b768.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8048}

def comp.b768.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8050}
    case False{}:
      None{}

def comp.b768.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n76(U32.is_lt(a, 950), a)

def comp.b768.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n75(U32.is_lt(a, 945), a)
    case False{}:
      comp.b768.n77(U32.is_lt(a, 949), a)

def comp.b768.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n74(U32.is_lt(a, 934), a)
    case False{}:
      comp.b768.n78(U32.is_lt(a, 946), a)

def comp.b768.n80(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8052}
    case False{}:
      None{}

def comp.b768.n81(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8054}
    case False{}:
      None{}

def comp.b768.n82(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n80(U32.is_lt(a, 952), a)
    case False{}:
      comp.b768.n81(U32.is_lt(a, 954), a)

def comp.b768.n83(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8056}
    case False{}:
      None{}

def comp.b768.n84(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8060}

def comp.b768.n85(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8058}
    case False{}:
      comp.b768.n84(U32.is_lt(a, 969), a)

def comp.b768.n86(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n83(U32.is_lt(a, 960), a)
    case False{}:
      comp.b768.n85(U32.is_lt(a, 966), a)

def comp.b768.n87(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n82(U32.is_lt(a, 953), a)
    case False{}:
      comp.b768.n86(U32.is_lt(a, 965), a)

def comp.b768.n88(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n79(U32.is_lt(a, 938), a)
    case False{}:
      comp.b768.n87(U32.is_lt(a, 959), a)

def comp.b768.n89(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8146}
    case False{}:
      Some{8162}

def comp.b768.n90(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1024}

def comp.b768.n91(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n89(U32.is_lt(a, 971), a)
    case False{}:
      comp.b768.n90(U32.is_lt(a, 1045), a)

def comp.b768.n92(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1037}

def comp.b768.n93(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1104}
    case False{}:
      None{}

def comp.b768.n94(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n93(U32.is_lt(a, 1078), a)

def comp.b768.n95(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n92(U32.is_lt(a, 1048), a)
    case False{}:
      comp.b768.n94(U32.is_lt(a, 1077), a)

def comp.b768.n96(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n91(U32.is_lt(a, 972), a)
    case False{}:
      comp.b768.n95(U32.is_lt(a, 1049), a)

def comp.b768.n97(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1117}
    case False{}:
      None{}

def comp.b768.n98(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7939}
    case False{}:
      None{}

def comp.b768.n99(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7938}
    case False{}:
      comp.b768.n98(U32.is_lt(a, 7938), a)

def comp.b768.n100(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n97(U32.is_lt(a, 1081), a)
    case False{}:
      comp.b768.n99(U32.is_lt(a, 7937), a)

def comp.b768.n101(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7946}
    case False{}:
      Some{7947}

def comp.b768.n102(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7954}
    case False{}:
      Some{7955}

def comp.b768.n103(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n102(U32.is_lt(a, 7953), a)

def comp.b768.n104(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n101(U32.is_lt(a, 7945), a)
    case False{}:
      comp.b768.n103(U32.is_lt(a, 7952), a)

def comp.b768.n105(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n100(U32.is_lt(a, 7936), a)
    case False{}:
      comp.b768.n104(U32.is_lt(a, 7946), a)

def comp.b768.n106(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n96(U32.is_lt(a, 1046), a)
    case False{}:
      comp.b768.n105(U32.is_lt(a, 7944), a)

def comp.b768.n107(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n88(U32.is_lt(a, 951), a)
    case False{}:
      comp.b768.n106(U32.is_lt(a, 1080), a)

def comp.b768.n108(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7962}

def comp.b768.n109(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7963}
    case False{}:
      None{}

def comp.b768.n110(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n108(U32.is_lt(a, 7960), a)
    case False{}:
      comp.b768.n109(U32.is_lt(a, 7962), a)

def comp.b768.n111(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7970}
    case False{}:
      Some{7971}

def comp.b768.n112(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7978}
    case False{}:
      Some{7979}

def comp.b768.n113(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n112(U32.is_lt(a, 7977), a)

def comp.b768.n114(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n111(U32.is_lt(a, 7969), a)
    case False{}:
      comp.b768.n113(U32.is_lt(a, 7976), a)

def comp.b768.n115(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n110(U32.is_lt(a, 7961), a)
    case False{}:
      comp.b768.n114(U32.is_lt(a, 7970), a)

def comp.b768.n116(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7986}

def comp.b768.n117(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7987}
    case False{}:
      None{}

def comp.b768.n118(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n116(U32.is_lt(a, 7984), a)
    case False{}:
      comp.b768.n117(U32.is_lt(a, 7986), a)

def comp.b768.n119(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7994}
    case False{}:
      Some{7995}

def comp.b768.n120(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8002}
    case False{}:
      Some{8003}

def comp.b768.n121(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n120(U32.is_lt(a, 8001), a)

def comp.b768.n122(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n119(U32.is_lt(a, 7993), a)
    case False{}:
      comp.b768.n121(U32.is_lt(a, 8000), a)

def comp.b768.n123(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n118(U32.is_lt(a, 7985), a)
    case False{}:
      comp.b768.n122(U32.is_lt(a, 7994), a)

def comp.b768.n124(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n115(U32.is_lt(a, 7968), a)
    case False{}:
      comp.b768.n123(U32.is_lt(a, 7992), a)

def comp.b768.n125(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8010}

def comp.b768.n126(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8011}
    case False{}:
      None{}

def comp.b768.n127(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n125(U32.is_lt(a, 8008), a)
    case False{}:
      comp.b768.n126(U32.is_lt(a, 8010), a)

def comp.b768.n128(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8018}
    case False{}:
      Some{8019}

def comp.b768.n129(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8027}
    case False{}:
      None{}

def comp.b768.n130(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n129(U32.is_lt(a, 8026), a)

def comp.b768.n131(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n128(U32.is_lt(a, 8017), a)
    case False{}:
      comp.b768.n130(U32.is_lt(a, 8025), a)

def comp.b768.n132(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n127(U32.is_lt(a, 8009), a)
    case False{}:
      comp.b768.n131(U32.is_lt(a, 8018), a)

def comp.b768.n133(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8034}
    case False{}:
      Some{8035}

def comp.b768.n134(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8042}
    case False{}:
      Some{8043}

def comp.b768.n135(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n134(U32.is_lt(a, 8041), a)

def comp.b768.n136(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n133(U32.is_lt(a, 8033), a)
    case False{}:
      comp.b768.n135(U32.is_lt(a, 8040), a)

def comp.b768.n137(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8141}

def comp.b768.n138(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8157}
    case False{}:
      None{}

def comp.b768.n139(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b768.n138(U32.is_lt(a, 8191), a)

def comp.b768.n140(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n137(U32.is_lt(a, 8127), a)
    case False{}:
      comp.b768.n139(U32.is_lt(a, 8190), a)

def comp.b768.n141(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n136(U32.is_lt(a, 8034), a)
    case False{}:
      comp.b768.n140(U32.is_lt(a, 8128), a)

def comp.b768.n142(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n132(U32.is_lt(a, 8016), a)
    case False{}:
      comp.b768.n141(U32.is_lt(a, 8042), a)

def comp.b768.n143(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n124(U32.is_lt(a, 7978), a)
    case False{}:
      comp.b768.n142(U32.is_lt(a, 8032), a)

def comp.b768.n144(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n107(U32.is_lt(a, 970), a)
    case False{}:
      comp.b768.n143(U32.is_lt(a, 8002), a)

def comp.b768.n145(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768.n71(U32.is_lt(a, 203), a)
    case False{}:
      comp.b768.n144(U32.is_lt(a, 7954), a)

def comp.b768(+a: U32) -> Maybe<&2, U32>:
  comp.b768.n145(U32.is_lt(a, 928), a)

def comp.b769.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{193}
    case False{}:
      None{}

def comp.b769.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n0(U32.is_lt(a, 66), a)

def comp.b769.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{201}

def comp.b769.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{262}
    case False{}:
      comp.b769.n2(U32.is_lt(a, 69), a)

def comp.b769.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b769.n3(U32.is_lt(a, 68), a)

def comp.b769.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{500}
    case False{}:
      None{}

def comp.b769.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n5(U32.is_lt(a, 72), a)

def comp.b769.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7728}

def comp.b769.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{205}
    case False{}:
      comp.b769.n7(U32.is_lt(a, 75), a)

def comp.b769.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n6(U32.is_lt(a, 71), a)
    case False{}:
      comp.b769.n8(U32.is_lt(a, 74), a)

def comp.b769.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n4(U32.is_lt(a, 67), a)
    case False{}:
      comp.b769.n9(U32.is_lt(a, 73), a)

def comp.b769.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7742}
    case False{}:
      Some{323}

def comp.b769.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{313}
    case False{}:
      comp.b769.n11(U32.is_lt(a, 78), a)

def comp.b769.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7764}
    case False{}:
      None{}

def comp.b769.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{211}
    case False{}:
      comp.b769.n13(U32.is_lt(a, 81), a)

def comp.b769.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n12(U32.is_lt(a, 77), a)
    case False{}:
      comp.b769.n14(U32.is_lt(a, 80), a)

def comp.b769.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{346}
    case False{}:
      None{}

def comp.b769.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{340}
    case False{}:
      comp.b769.n16(U32.is_lt(a, 84), a)

def comp.b769.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7810}

def comp.b769.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{218}
    case False{}:
      comp.b769.n18(U32.is_lt(a, 87), a)

def comp.b769.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n17(U32.is_lt(a, 83), a)
    case False{}:
      comp.b769.n19(U32.is_lt(a, 86), a)

def comp.b769.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n15(U32.is_lt(a, 79), a)
    case False{}:
      comp.b769.n20(U32.is_lt(a, 85), a)

def comp.b769.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n10(U32.is_lt(a, 70), a)
    case False{}:
      comp.b769.n21(U32.is_lt(a, 82), a)

def comp.b769.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{221}
    case False{}:
      Some{377}

def comp.b769.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n23(U32.is_lt(a, 90), a)

def comp.b769.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{225}
    case False{}:
      None{}

def comp.b769.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n25(U32.is_lt(a, 98), a)

def comp.b769.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n24(U32.is_lt(a, 89), a)
    case False{}:
      comp.b769.n26(U32.is_lt(a, 97), a)

def comp.b769.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{233}

def comp.b769.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{263}
    case False{}:
      comp.b769.n28(U32.is_lt(a, 101), a)

def comp.b769.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{501}
    case False{}:
      None{}

def comp.b769.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n30(U32.is_lt(a, 104), a)

def comp.b769.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n29(U32.is_lt(a, 100), a)
    case False{}:
      comp.b769.n31(U32.is_lt(a, 103), a)

def comp.b769.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n27(U32.is_lt(a, 91), a)
    case False{}:
      comp.b769.n32(U32.is_lt(a, 102), a)

def comp.b769.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7729}

def comp.b769.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{237}
    case False{}:
      comp.b769.n34(U32.is_lt(a, 107), a)

def comp.b769.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7743}
    case False{}:
      Some{324}

def comp.b769.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{314}
    case False{}:
      comp.b769.n36(U32.is_lt(a, 110), a)

def comp.b769.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n35(U32.is_lt(a, 106), a)
    case False{}:
      comp.b769.n37(U32.is_lt(a, 109), a)

def comp.b769.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7765}
    case False{}:
      None{}

def comp.b769.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{243}
    case False{}:
      comp.b769.n39(U32.is_lt(a, 113), a)

def comp.b769.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{347}
    case False{}:
      None{}

def comp.b769.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{341}
    case False{}:
      comp.b769.n41(U32.is_lt(a, 116), a)

def comp.b769.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n40(U32.is_lt(a, 112), a)
    case False{}:
      comp.b769.n42(U32.is_lt(a, 115), a)

def comp.b769.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n38(U32.is_lt(a, 108), a)
    case False{}:
      comp.b769.n43(U32.is_lt(a, 114), a)

def comp.b769.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n33(U32.is_lt(a, 99), a)
    case False{}:
      comp.b769.n44(U32.is_lt(a, 111), a)

def comp.b769.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n22(U32.is_lt(a, 76), a)
    case False{}:
      comp.b769.n45(U32.is_lt(a, 105), a)

def comp.b769.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7811}

def comp.b769.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{250}
    case False{}:
      comp.b769.n47(U32.is_lt(a, 119), a)

def comp.b769.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{253}
    case False{}:
      Some{378}

def comp.b769.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n49(U32.is_lt(a, 122), a)

def comp.b769.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n48(U32.is_lt(a, 118), a)
    case False{}:
      comp.b769.n50(U32.is_lt(a, 121), a)

def comp.b769.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{901}
    case False{}:
      None{}

def comp.b769.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n52(U32.is_lt(a, 169), a)

def comp.b769.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{506}

def comp.b769.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7844}
    case False{}:
      comp.b769.n54(U32.is_lt(a, 197), a)

def comp.b769.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n53(U32.is_lt(a, 168), a)
    case False{}:
      comp.b769.n55(U32.is_lt(a, 195), a)

def comp.b769.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n51(U32.is_lt(a, 120), a)
    case False{}:
      comp.b769.n56(U32.is_lt(a, 194), a)

def comp.b769.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7688}
    case False{}:
      None{}

def comp.b769.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{508}
    case False{}:
      comp.b769.n58(U32.is_lt(a, 200), a)

def comp.b769.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7726}

def comp.b769.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7870}
    case False{}:
      comp.b769.n60(U32.is_lt(a, 207), a)

def comp.b769.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n59(U32.is_lt(a, 199), a)
    case False{}:
      comp.b769.n61(U32.is_lt(a, 203), a)

def comp.b769.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7888}
    case False{}:
      Some{7756}

def comp.b769.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n63(U32.is_lt(a, 213), a)

def comp.b769.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{510}
    case False{}:
      None{}

def comp.b769.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n65(U32.is_lt(a, 217), a)

def comp.b769.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n64(U32.is_lt(a, 212), a)
    case False{}:
      comp.b769.n66(U32.is_lt(a, 216), a)

def comp.b769.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n62(U32.is_lt(a, 202), a)
    case False{}:
      comp.b769.n67(U32.is_lt(a, 214), a)

def comp.b769.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n57(U32.is_lt(a, 123), a)
    case False{}:
      comp.b769.n68(U32.is_lt(a, 208), a)

def comp.b769.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7845}

def comp.b769.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{471}
    case False{}:
      comp.b769.n70(U32.is_lt(a, 226), a)

def comp.b769.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{507}
    case False{}:
      Some{509}

def comp.b769.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n72(U32.is_lt(a, 230), a)

def comp.b769.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n71(U32.is_lt(a, 221), a)
    case False{}:
      comp.b769.n73(U32.is_lt(a, 229), a)

def comp.b769.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7871}

def comp.b769.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7689}
    case False{}:
      comp.b769.n75(U32.is_lt(a, 234), a)

def comp.b769.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7727}
    case False{}:
      None{}

def comp.b769.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n77(U32.is_lt(a, 240), a)

def comp.b769.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n76(U32.is_lt(a, 232), a)
    case False{}:
      comp.b769.n78(U32.is_lt(a, 239), a)

def comp.b769.n80(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n74(U32.is_lt(a, 227), a)
    case False{}:
      comp.b769.n79(U32.is_lt(a, 235), a)

def comp.b769.n81(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7757}
    case False{}:
      None{}

def comp.b769.n82(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7889}
    case False{}:
      comp.b769.n81(U32.is_lt(a, 246), a)

def comp.b769.n83(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{472}

def comp.b769.n84(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{511}
    case False{}:
      comp.b769.n83(U32.is_lt(a, 252), a)

def comp.b769.n85(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n82(U32.is_lt(a, 245), a)
    case False{}:
      comp.b769.n84(U32.is_lt(a, 249), a)

def comp.b769.n86(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7854}
    case False{}:
      Some{7855}

def comp.b769.n87(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n86(U32.is_lt(a, 259), a)

def comp.b769.n88(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7702}

def comp.b769.n89(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7703}
    case False{}:
      None{}

def comp.b769.n90(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n88(U32.is_lt(a, 274), a)
    case False{}:
      comp.b769.n89(U32.is_lt(a, 276), a)

def comp.b769.n91(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n87(U32.is_lt(a, 258), a)
    case False{}:
      comp.b769.n90(U32.is_lt(a, 275), a)

def comp.b769.n92(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n85(U32.is_lt(a, 248), a)
    case False{}:
      comp.b769.n91(U32.is_lt(a, 260), a)

def comp.b769.n93(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n80(U32.is_lt(a, 231), a)
    case False{}:
      comp.b769.n92(U32.is_lt(a, 253), a)

def comp.b769.n94(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n69(U32.is_lt(a, 198), a)
    case False{}:
      comp.b769.n93(U32.is_lt(a, 244), a)

def comp.b769.n95(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n46(U32.is_lt(a, 88), a)
    case False{}:
      comp.b769.n94(U32.is_lt(a, 220), a)

def comp.b769.n96(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7763}
    case False{}:
      None{}

def comp.b769.n97(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7762}
    case False{}:
      comp.b769.n96(U32.is_lt(a, 334), a)

def comp.b769.n98(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7801}
    case False{}:
      None{}

def comp.b769.n99(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7800}
    case False{}:
      comp.b769.n98(U32.is_lt(a, 362), a)

def comp.b769.n100(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n97(U32.is_lt(a, 333), a)
    case False{}:
      comp.b769.n99(U32.is_lt(a, 361), a)

def comp.b769.n101(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7899}
    case False{}:
      None{}

def comp.b769.n102(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7898}
    case False{}:
      comp.b769.n101(U32.is_lt(a, 418), a)

def comp.b769.n103(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7913}
    case False{}:
      None{}

def comp.b769.n104(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7912}
    case False{}:
      comp.b769.n103(U32.is_lt(a, 433), a)

def comp.b769.n105(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n102(U32.is_lt(a, 417), a)
    case False{}:
      comp.b769.n104(U32.is_lt(a, 432), a)

def comp.b769.n106(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n100(U32.is_lt(a, 360), a)
    case False{}:
      comp.b769.n105(U32.is_lt(a, 431), a)

def comp.b769.n107(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{904}

def comp.b769.n108(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{902}
    case False{}:
      comp.b769.n107(U32.is_lt(a, 917), a)

def comp.b769.n109(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{905}
    case False{}:
      None{}

def comp.b769.n110(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n109(U32.is_lt(a, 920), a)

def comp.b769.n111(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n108(U32.is_lt(a, 914), a)
    case False{}:
      comp.b769.n110(U32.is_lt(a, 919), a)

def comp.b769.n112(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{908}

def comp.b769.n113(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{906}
    case False{}:
      comp.b769.n112(U32.is_lt(a, 927), a)

def comp.b769.n114(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{910}
    case False{}:
      None{}

def comp.b769.n115(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n114(U32.is_lt(a, 934), a)

def comp.b769.n116(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n113(U32.is_lt(a, 922), a)
    case False{}:
      comp.b769.n115(U32.is_lt(a, 933), a)

def comp.b769.n117(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n111(U32.is_lt(a, 918), a)
    case False{}:
      comp.b769.n116(U32.is_lt(a, 928), a)

def comp.b769.n118(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n106(U32.is_lt(a, 416), a)
    case False{}:
      comp.b769.n117(U32.is_lt(a, 921), a)

def comp.b769.n119(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{940}

def comp.b769.n120(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{911}
    case False{}:
      comp.b769.n119(U32.is_lt(a, 945), a)

def comp.b769.n121(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{941}
    case False{}:
      None{}

def comp.b769.n122(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n121(U32.is_lt(a, 950), a)

def comp.b769.n123(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n120(U32.is_lt(a, 938), a)
    case False{}:
      comp.b769.n122(U32.is_lt(a, 949), a)

def comp.b769.n124(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{943}

def comp.b769.n125(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{942}
    case False{}:
      comp.b769.n124(U32.is_lt(a, 953), a)

def comp.b769.n126(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{972}
    case False{}:
      None{}

def comp.b769.n127(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n126(U32.is_lt(a, 960), a)

def comp.b769.n128(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n125(U32.is_lt(a, 952), a)
    case False{}:
      comp.b769.n127(U32.is_lt(a, 959), a)

def comp.b769.n129(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n123(U32.is_lt(a, 946), a)
    case False{}:
      comp.b769.n128(U32.is_lt(a, 954), a)

def comp.b769.n130(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{974}

def comp.b769.n131(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{973}
    case False{}:
      comp.b769.n130(U32.is_lt(a, 969), a)

def comp.b769.n132(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{944}
    case False{}:
      None{}

def comp.b769.n133(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{912}
    case False{}:
      comp.b769.n132(U32.is_lt(a, 972), a)

def comp.b769.n134(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n131(U32.is_lt(a, 966), a)
    case False{}:
      comp.b769.n133(U32.is_lt(a, 971), a)

def comp.b769.n135(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1027}

def comp.b769.n136(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{979}
    case False{}:
      comp.b769.n135(U32.is_lt(a, 1043), a)

def comp.b769.n137(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1036}
    case False{}:
      None{}

def comp.b769.n138(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n137(U32.is_lt(a, 1051), a)

def comp.b769.n139(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n136(U32.is_lt(a, 979), a)
    case False{}:
      comp.b769.n138(U32.is_lt(a, 1050), a)

def comp.b769.n140(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n134(U32.is_lt(a, 970), a)
    case False{}:
      comp.b769.n139(U32.is_lt(a, 1044), a)

def comp.b769.n141(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n129(U32.is_lt(a, 951), a)
    case False{}:
      comp.b769.n140(U32.is_lt(a, 978), a)

def comp.b769.n142(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n118(U32.is_lt(a, 913), a)
    case False{}:
      comp.b769.n141(U32.is_lt(a, 965), a)

def comp.b769.n143(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1116}

def comp.b769.n144(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1107}
    case False{}:
      comp.b769.n143(U32.is_lt(a, 1082), a)

def comp.b769.n145(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7940}
    case False{}:
      Some{7941}

def comp.b769.n146(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n145(U32.is_lt(a, 7937), a)

def comp.b769.n147(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n144(U32.is_lt(a, 1076), a)
    case False{}:
      comp.b769.n146(U32.is_lt(a, 7936), a)

def comp.b769.n148(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7948}
    case False{}:
      Some{7949}

def comp.b769.n149(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n148(U32.is_lt(a, 7945), a)

def comp.b769.n150(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7956}
    case False{}:
      Some{7957}

def comp.b769.n151(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n150(U32.is_lt(a, 7953), a)

def comp.b769.n152(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n149(U32.is_lt(a, 7944), a)
    case False{}:
      comp.b769.n151(U32.is_lt(a, 7952), a)

def comp.b769.n153(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n147(U32.is_lt(a, 1083), a)
    case False{}:
      comp.b769.n152(U32.is_lt(a, 7946), a)

def comp.b769.n154(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7964}
    case False{}:
      Some{7965}

def comp.b769.n155(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n154(U32.is_lt(a, 7961), a)

def comp.b769.n156(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7972}
    case False{}:
      Some{7973}

def comp.b769.n157(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n156(U32.is_lt(a, 7969), a)

def comp.b769.n158(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n155(U32.is_lt(a, 7960), a)
    case False{}:
      comp.b769.n157(U32.is_lt(a, 7968), a)

def comp.b769.n159(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7980}
    case False{}:
      Some{7981}

def comp.b769.n160(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n159(U32.is_lt(a, 7977), a)

def comp.b769.n161(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7988}
    case False{}:
      Some{7989}

def comp.b769.n162(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n161(U32.is_lt(a, 7985), a)

def comp.b769.n163(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n160(U32.is_lt(a, 7976), a)
    case False{}:
      comp.b769.n162(U32.is_lt(a, 7984), a)

def comp.b769.n164(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n158(U32.is_lt(a, 7962), a)
    case False{}:
      comp.b769.n163(U32.is_lt(a, 7978), a)

def comp.b769.n165(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n153(U32.is_lt(a, 7938), a)
    case False{}:
      comp.b769.n164(U32.is_lt(a, 7970), a)

def comp.b769.n166(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7996}
    case False{}:
      Some{7997}

def comp.b769.n167(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n166(U32.is_lt(a, 7993), a)

def comp.b769.n168(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8004}
    case False{}:
      Some{8005}

def comp.b769.n169(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n168(U32.is_lt(a, 8001), a)

def comp.b769.n170(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n167(U32.is_lt(a, 7992), a)
    case False{}:
      comp.b769.n169(U32.is_lt(a, 8000), a)

def comp.b769.n171(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8012}
    case False{}:
      Some{8013}

def comp.b769.n172(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n171(U32.is_lt(a, 8009), a)

def comp.b769.n173(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8020}
    case False{}:
      Some{8021}

def comp.b769.n174(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n173(U32.is_lt(a, 8017), a)

def comp.b769.n175(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n172(U32.is_lt(a, 8008), a)
    case False{}:
      comp.b769.n174(U32.is_lt(a, 8016), a)

def comp.b769.n176(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n170(U32.is_lt(a, 7994), a)
    case False{}:
      comp.b769.n175(U32.is_lt(a, 8010), a)

def comp.b769.n177(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8029}
    case False{}:
      None{}

def comp.b769.n178(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b769.n177(U32.is_lt(a, 8026), a)

def comp.b769.n179(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8037}
    case False{}:
      None{}

def comp.b769.n180(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8036}
    case False{}:
      comp.b769.n179(U32.is_lt(a, 8034), a)

def comp.b769.n181(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n178(U32.is_lt(a, 8025), a)
    case False{}:
      comp.b769.n180(U32.is_lt(a, 8033), a)

def comp.b769.n182(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8045}
    case False{}:
      None{}

def comp.b769.n183(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8044}
    case False{}:
      comp.b769.n182(U32.is_lt(a, 8042), a)

def comp.b769.n184(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8142}
    case False{}:
      None{}

def comp.b769.n185(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8158}
    case False{}:
      None{}

def comp.b769.n186(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n184(U32.is_lt(a, 8128), a)
    case False{}:
      comp.b769.n185(U32.is_lt(a, 8191), a)

def comp.b769.n187(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n183(U32.is_lt(a, 8041), a)
    case False{}:
      comp.b769.n186(U32.is_lt(a, 8190), a)

def comp.b769.n188(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n181(U32.is_lt(a, 8032), a)
    case False{}:
      comp.b769.n187(U32.is_lt(a, 8127), a)

def comp.b769.n189(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n176(U32.is_lt(a, 8002), a)
    case False{}:
      comp.b769.n188(U32.is_lt(a, 8040), a)

def comp.b769.n190(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n165(U32.is_lt(a, 7954), a)
    case False{}:
      comp.b769.n189(U32.is_lt(a, 8018), a)

def comp.b769.n191(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n142(U32.is_lt(a, 937), a)
    case False{}:
      comp.b769.n190(U32.is_lt(a, 7986), a)

def comp.b769.n192(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b769.n95(U32.is_lt(a, 117), a)
    case False{}:
      comp.b769.n191(U32.is_lt(a, 1075), a)

def comp.b769(+a: U32) -> Maybe<&2, U32>:
  comp.b769.n192(U32.is_lt(a, 332), a)

def comp.b770.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{194}
    case False{}:
      None{}

def comp.b770.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b770.n0(U32.is_lt(a, 66), a)

def comp.b770.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{202}

def comp.b770.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{264}
    case False{}:
      comp.b770.n2(U32.is_lt(a, 69), a)

def comp.b770.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b770.n3(U32.is_lt(a, 68), a)

def comp.b770.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{284}
    case False{}:
      Some{292}

def comp.b770.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b770.n5(U32.is_lt(a, 72), a)

def comp.b770.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{206}
    case False{}:
      Some{308}

def comp.b770.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{212}

def comp.b770.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n7(U32.is_lt(a, 74), a)
    case False{}:
      comp.b770.n8(U32.is_lt(a, 79), a)

def comp.b770.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n6(U32.is_lt(a, 71), a)
    case False{}:
      comp.b770.n9(U32.is_lt(a, 75), a)

def comp.b770.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n4(U32.is_lt(a, 67), a)
    case False{}:
      comp.b770.n10(U32.is_lt(a, 73), a)

def comp.b770.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{348}
    case False{}:
      None{}

def comp.b770.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b770.n12(U32.is_lt(a, 84), a)

def comp.b770.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{219}
    case False{}:
      None{}

def comp.b770.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{372}
    case False{}:
      None{}

def comp.b770.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n14(U32.is_lt(a, 86), a)
    case False{}:
      comp.b770.n15(U32.is_lt(a, 88), a)

def comp.b770.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n13(U32.is_lt(a, 83), a)
    case False{}:
      comp.b770.n16(U32.is_lt(a, 87), a)

def comp.b770.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7824}
    case False{}:
      None{}

def comp.b770.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{374}
    case False{}:
      comp.b770.n18(U32.is_lt(a, 91), a)

def comp.b770.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{226}
    case False{}:
      None{}

def comp.b770.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{265}
    case False{}:
      None{}

def comp.b770.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n20(U32.is_lt(a, 98), a)
    case False{}:
      comp.b770.n21(U32.is_lt(a, 100), a)

def comp.b770.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n19(U32.is_lt(a, 90), a)
    case False{}:
      comp.b770.n22(U32.is_lt(a, 99), a)

def comp.b770.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n17(U32.is_lt(a, 85), a)
    case False{}:
      comp.b770.n23(U32.is_lt(a, 97), a)

def comp.b770.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n11(U32.is_lt(a, 70), a)
    case False{}:
      comp.b770.n24(U32.is_lt(a, 89), a)

def comp.b770.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{285}

def comp.b770.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{234}
    case False{}:
      comp.b770.n26(U32.is_lt(a, 103), a)

def comp.b770.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{238}
    case False{}:
      Some{309}

def comp.b770.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{293}
    case False{}:
      comp.b770.n28(U32.is_lt(a, 106), a)

def comp.b770.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n27(U32.is_lt(a, 102), a)
    case False{}:
      comp.b770.n29(U32.is_lt(a, 105), a)

def comp.b770.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{244}
    case False{}:
      None{}

def comp.b770.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b770.n31(U32.is_lt(a, 112), a)

def comp.b770.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{349}
    case False{}:
      None{}

def comp.b770.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{251}
    case False{}:
      None{}

def comp.b770.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n33(U32.is_lt(a, 116), a)
    case False{}:
      comp.b770.n34(U32.is_lt(a, 118), a)

def comp.b770.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n32(U32.is_lt(a, 111), a)
    case False{}:
      comp.b770.n35(U32.is_lt(a, 117), a)

def comp.b770.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n30(U32.is_lt(a, 104), a)
    case False{}:
      comp.b770.n36(U32.is_lt(a, 115), a)

def comp.b770.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{375}

def comp.b770.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{373}
    case False{}:
      comp.b770.n38(U32.is_lt(a, 121), a)

def comp.b770.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7825}
    case False{}:
      None{}

def comp.b770.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7852}
    case False{}:
      Some{7853}

def comp.b770.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n40(U32.is_lt(a, 123), a)
    case False{}:
      comp.b770.n41(U32.is_lt(a, 7841), a)

def comp.b770.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n39(U32.is_lt(a, 120), a)
    case False{}:
      comp.b770.n42(U32.is_lt(a, 7840), a)

def comp.b770.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7878}
    case False{}:
      Some{7879}

def comp.b770.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b770.n44(U32.is_lt(a, 7865), a)

def comp.b770.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7896}

def comp.b770.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7897}
    case False{}:
      None{}

def comp.b770.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n46(U32.is_lt(a, 7884), a)
    case False{}:
      comp.b770.n47(U32.is_lt(a, 7886), a)

def comp.b770.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n45(U32.is_lt(a, 7864), a)
    case False{}:
      comp.b770.n48(U32.is_lt(a, 7885), a)

def comp.b770.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n43(U32.is_lt(a, 122), a)
    case False{}:
      comp.b770.n49(U32.is_lt(a, 7866), a)

def comp.b770.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n37(U32.is_lt(a, 107), a)
    case False{}:
      comp.b770.n50(U32.is_lt(a, 7842), a)

def comp.b770.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770.n25(U32.is_lt(a, 80), a)
    case False{}:
      comp.b770.n51(U32.is_lt(a, 119), a)

def comp.b770(+a: U32) -> Maybe<&2, U32>:
  comp.b770.n52(U32.is_lt(a, 101), a)

def comp.b771.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{195}
    case False{}:
      None{}

def comp.b771.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n0(U32.is_lt(a, 66), a)

def comp.b771.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{296}

def comp.b771.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7868}
    case False{}:
      comp.b771.n2(U32.is_lt(a, 73), a)

def comp.b771.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b771.n3(U32.is_lt(a, 70), a)

def comp.b771.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{209}
    case False{}:
      Some{213}

def comp.b771.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n5(U32.is_lt(a, 79), a)

def comp.b771.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{360}
    case False{}:
      Some{7804}

def comp.b771.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n7(U32.is_lt(a, 86), a)

def comp.b771.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n6(U32.is_lt(a, 78), a)
    case False{}:
      comp.b771.n8(U32.is_lt(a, 85), a)

def comp.b771.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n4(U32.is_lt(a, 69), a)
    case False{}:
      comp.b771.n9(U32.is_lt(a, 80), a)

def comp.b771.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7928}
    case False{}:
      None{}

def comp.b771.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n11(U32.is_lt(a, 90), a)

def comp.b771.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7869}

def comp.b771.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{227}
    case False{}:
      comp.b771.n13(U32.is_lt(a, 101), a)

def comp.b771.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n12(U32.is_lt(a, 89), a)
    case False{}:
      comp.b771.n14(U32.is_lt(a, 98), a)

def comp.b771.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{297}
    case False{}:
      None{}

def comp.b771.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n16(U32.is_lt(a, 106), a)

def comp.b771.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{241}
    case False{}:
      Some{245}

def comp.b771.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{361}

def comp.b771.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n18(U32.is_lt(a, 111), a)
    case False{}:
      comp.b771.n19(U32.is_lt(a, 117), a)

def comp.b771.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n17(U32.is_lt(a, 105), a)
    case False{}:
      comp.b771.n20(U32.is_lt(a, 112), a)

def comp.b771.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n15(U32.is_lt(a, 97), a)
    case False{}:
      comp.b771.n21(U32.is_lt(a, 110), a)

def comp.b771.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n10(U32.is_lt(a, 74), a)
    case False{}:
      comp.b771.n22(U32.is_lt(a, 102), a)

def comp.b771.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7929}

def comp.b771.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7805}
    case False{}:
      comp.b771.n24(U32.is_lt(a, 121), a)

def comp.b771.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7850}
    case False{}:
      None{}

def comp.b771.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n26(U32.is_lt(a, 195), a)

def comp.b771.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n25(U32.is_lt(a, 119), a)
    case False{}:
      comp.b771.n27(U32.is_lt(a, 194), a)

def comp.b771.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7894}

def comp.b771.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7876}
    case False{}:
      comp.b771.n29(U32.is_lt(a, 212), a)

def comp.b771.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7851}
    case False{}:
      None{}

def comp.b771.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n31(U32.is_lt(a, 227), a)

def comp.b771.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n30(U32.is_lt(a, 203), a)
    case False{}:
      comp.b771.n32(U32.is_lt(a, 226), a)

def comp.b771.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n28(U32.is_lt(a, 122), a)
    case False{}:
      comp.b771.n33(U32.is_lt(a, 213), a)

def comp.b771.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7895}

def comp.b771.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7877}
    case False{}:
      comp.b771.n35(U32.is_lt(a, 244), a)

def comp.b771.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7860}
    case False{}:
      Some{7861}

def comp.b771.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n37(U32.is_lt(a, 259), a)

def comp.b771.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n36(U32.is_lt(a, 235), a)
    case False{}:
      comp.b771.n38(U32.is_lt(a, 258), a)

def comp.b771.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7904}
    case False{}:
      Some{7905}

def comp.b771.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b771.n40(U32.is_lt(a, 417), a)

def comp.b771.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7918}

def comp.b771.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7919}
    case False{}:
      None{}

def comp.b771.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n42(U32.is_lt(a, 431), a)
    case False{}:
      comp.b771.n43(U32.is_lt(a, 433), a)

def comp.b771.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n41(U32.is_lt(a, 416), a)
    case False{}:
      comp.b771.n44(U32.is_lt(a, 432), a)

def comp.b771.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n39(U32.is_lt(a, 245), a)
    case False{}:
      comp.b771.n45(U32.is_lt(a, 418), a)

def comp.b771.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n34(U32.is_lt(a, 202), a)
    case False{}:
      comp.b771.n46(U32.is_lt(a, 260), a)

def comp.b771.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b771.n23(U32.is_lt(a, 87), a)
    case False{}:
      comp.b771.n47(U32.is_lt(a, 234), a)

def comp.b771(+a: U32) -> Maybe<&2, U32>:
  comp.b771.n48(U32.is_lt(a, 118), a)

def comp.b772.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{256}

def comp.b772.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{274}
    case False{}:
      None{}

def comp.b772.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n1(U32.is_lt(a, 70), a)

def comp.b772.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b772.n2(U32.is_lt(a, 69), a)

def comp.b772.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7712}
    case False{}:
      None{}

def comp.b772.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{332}

def comp.b772.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{298}
    case False{}:
      comp.b772.n5(U32.is_lt(a, 79), a)

def comp.b772.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n4(U32.is_lt(a, 72), a)
    case False{}:
      comp.b772.n6(U32.is_lt(a, 74), a)

def comp.b772.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n3(U32.is_lt(a, 66), a)
    case False{}:
      comp.b772.n7(U32.is_lt(a, 73), a)

def comp.b772.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{362}

def comp.b772.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{562}
    case False{}:
      None{}

def comp.b772.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n10(U32.is_lt(a, 90), a)

def comp.b772.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n9(U32.is_lt(a, 85), a)
    case False{}:
      comp.b772.n11(U32.is_lt(a, 89), a)

def comp.b772.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{257}
    case False{}:
      None{}

def comp.b772.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7713}

def comp.b772.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{275}
    case False{}:
      comp.b772.n14(U32.is_lt(a, 103), a)

def comp.b772.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n13(U32.is_lt(a, 98), a)
    case False{}:
      comp.b772.n15(U32.is_lt(a, 102), a)

def comp.b772.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n12(U32.is_lt(a, 86), a)
    case False{}:
      comp.b772.n16(U32.is_lt(a, 101), a)

def comp.b772.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n8(U32.is_lt(a, 71), a)
    case False{}:
      comp.b772.n17(U32.is_lt(a, 97), a)

def comp.b772.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{299}

def comp.b772.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{333}
    case False{}:
      None{}

def comp.b772.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n20(U32.is_lt(a, 112), a)

def comp.b772.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n19(U32.is_lt(a, 105), a)
    case False{}:
      comp.b772.n21(U32.is_lt(a, 111), a)

def comp.b772.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{363}
    case False{}:
      None{}

def comp.b772.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{478}

def comp.b772.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{563}
    case False{}:
      comp.b772.n24(U32.is_lt(a, 196), a)

def comp.b772.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n23(U32.is_lt(a, 118), a)
    case False{}:
      comp.b772.n25(U32.is_lt(a, 122), a)

def comp.b772.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n22(U32.is_lt(a, 106), a)
    case False{}:
      comp.b772.n26(U32.is_lt(a, 121), a)

def comp.b772.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{482}

def comp.b772.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{556}
    case False{}:
      Some{554}

def comp.b772.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n29(U32.is_lt(a, 214), a)

def comp.b772.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n28(U32.is_lt(a, 198), a)
    case False{}:
      comp.b772.n30(U32.is_lt(a, 213), a)

def comp.b772.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{469}
    case False{}:
      None{}

def comp.b772.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n32(U32.is_lt(a, 221), a)

def comp.b772.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{483}

def comp.b772.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{479}
    case False{}:
      comp.b772.n34(U32.is_lt(a, 230), a)

def comp.b772.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n33(U32.is_lt(a, 220), a)
    case False{}:
      comp.b772.n35(U32.is_lt(a, 229), a)

def comp.b772.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n31(U32.is_lt(a, 199), a)
    case False{}:
      comp.b772.n36(U32.is_lt(a, 228), a)

def comp.b772.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n27(U32.is_lt(a, 117), a)
    case False{}:
      comp.b772.n37(U32.is_lt(a, 215), a)

def comp.b772.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n18(U32.is_lt(a, 80), a)
    case False{}:
      comp.b772.n38(U32.is_lt(a, 197), a)

def comp.b772.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{557}

def comp.b772.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{470}

def comp.b772.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{555}
    case False{}:
      comp.b772.n41(U32.is_lt(a, 252), a)

def comp.b772.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n40(U32.is_lt(a, 245), a)
    case False{}:
      comp.b772.n42(U32.is_lt(a, 247), a)

def comp.b772.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{492}

def comp.b772.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{480}

def comp.b772.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{493}
    case False{}:
      comp.b772.n45(U32.is_lt(a, 550), a)

def comp.b772.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n44(U32.is_lt(a, 490), a)
    case False{}:
      comp.b772.n46(U32.is_lt(a, 492), a)

def comp.b772.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n43(U32.is_lt(a, 246), a)
    case False{}:
      comp.b772.n47(U32.is_lt(a, 491), a)

def comp.b772.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{481}
    case False{}:
      None{}

def comp.b772.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{561}
    case False{}:
      None{}

def comp.b772.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{560}
    case False{}:
      comp.b772.n50(U32.is_lt(a, 560), a)

def comp.b772.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n49(U32.is_lt(a, 552), a)
    case False{}:
      comp.b772.n51(U32.is_lt(a, 559), a)

def comp.b772.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8121}
    case False{}:
      None{}

def comp.b772.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8169}

def comp.b772.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8153}
    case False{}:
      comp.b772.n54(U32.is_lt(a, 933), a)

def comp.b772.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n53(U32.is_lt(a, 914), a)
    case False{}:
      comp.b772.n55(U32.is_lt(a, 922), a)

def comp.b772.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n52(U32.is_lt(a, 558), a)
    case False{}:
      comp.b772.n56(U32.is_lt(a, 921), a)

def comp.b772.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n48(U32.is_lt(a, 253), a)
    case False{}:
      comp.b772.n57(U32.is_lt(a, 913), a)

def comp.b772.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8113}

def comp.b772.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8145}
    case False{}:
      None{}

def comp.b772.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n60(U32.is_lt(a, 954), a)

def comp.b772.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n59(U32.is_lt(a, 945), a)
    case False{}:
      comp.b772.n61(U32.is_lt(a, 953), a)

def comp.b772.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8161}
    case False{}:
      None{}

def comp.b772.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1262}

def comp.b772.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1250}
    case False{}:
      comp.b772.n64(U32.is_lt(a, 1059), a)

def comp.b772.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n63(U32.is_lt(a, 966), a)
    case False{}:
      comp.b772.n65(U32.is_lt(a, 1049), a)

def comp.b772.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n62(U32.is_lt(a, 946), a)
    case False{}:
      comp.b772.n66(U32.is_lt(a, 1048), a)

def comp.b772.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1251}

def comp.b772.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1263}
    case False{}:
      None{}

def comp.b772.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b772.n69(U32.is_lt(a, 1092), a)

def comp.b772.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n68(U32.is_lt(a, 1080), a)
    case False{}:
      comp.b772.n70(U32.is_lt(a, 1091), a)

def comp.b772.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7737}
    case False{}:
      None{}

def comp.b772.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7736}
    case False{}:
      comp.b772.n72(U32.is_lt(a, 7736), a)

def comp.b772.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7773}
    case False{}:
      None{}

def comp.b772.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7772}
    case False{}:
      comp.b772.n74(U32.is_lt(a, 7772), a)

def comp.b772.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n73(U32.is_lt(a, 7735), a)
    case False{}:
      comp.b772.n75(U32.is_lt(a, 7771), a)

def comp.b772.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n71(U32.is_lt(a, 1081), a)
    case False{}:
      comp.b772.n76(U32.is_lt(a, 7770), a)

def comp.b772.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n67(U32.is_lt(a, 965), a)
    case False{}:
      comp.b772.n77(U32.is_lt(a, 7734), a)

def comp.b772.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n58(U32.is_lt(a, 551), a)
    case False{}:
      comp.b772.n78(U32.is_lt(a, 1060), a)

def comp.b772.n80(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772.n39(U32.is_lt(a, 104), a)
    case False{}:
      comp.b772.n79(U32.is_lt(a, 934), a)

def comp.b772(+a: U32) -> Maybe<&2, U32>:
  comp.b772.n80(U32.is_lt(a, 231), a)

def comp.b774.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{258}
    case False{}:
      None{}

def comp.b774.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b774.n0(U32.is_lt(a, 66), a)

def comp.b774.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{276}
    case False{}:
      None{}

def comp.b774.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{286}
    case False{}:
      None{}

def comp.b774.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n2(U32.is_lt(a, 70), a)
    case False{}:
      comp.b774.n3(U32.is_lt(a, 72), a)

def comp.b774.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b774.n4(U32.is_lt(a, 71), a)

def comp.b774.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{300}
    case False{}:
      None{}

def comp.b774.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{334}
    case False{}:
      None{}

def comp.b774.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n6(U32.is_lt(a, 74), a)
    case False{}:
      comp.b774.n7(U32.is_lt(a, 80), a)

def comp.b774.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{364}
    case False{}:
      None{}

def comp.b774.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{259}
    case False{}:
      None{}

def comp.b774.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n9(U32.is_lt(a, 86), a)
    case False{}:
      comp.b774.n10(U32.is_lt(a, 98), a)

def comp.b774.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n8(U32.is_lt(a, 79), a)
    case False{}:
      comp.b774.n11(U32.is_lt(a, 97), a)

def comp.b774.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n5(U32.is_lt(a, 69), a)
    case False{}:
      comp.b774.n12(U32.is_lt(a, 85), a)

def comp.b774.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{287}

def comp.b774.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{277}
    case False{}:
      comp.b774.n14(U32.is_lt(a, 103), a)

def comp.b774.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{301}

def comp.b774.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{335}

def comp.b774.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n16(U32.is_lt(a, 105), a)
    case False{}:
      comp.b774.n17(U32.is_lt(a, 111), a)

def comp.b774.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n15(U32.is_lt(a, 102), a)
    case False{}:
      comp.b774.n18(U32.is_lt(a, 106), a)

def comp.b774.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{365}

def comp.b774.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7708}

def comp.b774.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n20(U32.is_lt(a, 117), a)
    case False{}:
      comp.b774.n21(U32.is_lt(a, 552), a)

def comp.b774.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7709}
    case False{}:
      None{}

def comp.b774.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8120}
    case False{}:
      None{}

def comp.b774.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n23(U32.is_lt(a, 554), a)
    case False{}:
      comp.b774.n24(U32.is_lt(a, 914), a)

def comp.b774.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n22(U32.is_lt(a, 118), a)
    case False{}:
      comp.b774.n25(U32.is_lt(a, 913), a)

def comp.b774.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n19(U32.is_lt(a, 104), a)
    case False{}:
      comp.b774.n26(U32.is_lt(a, 553), a)

def comp.b774.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n13(U32.is_lt(a, 73), a)
    case False{}:
      comp.b774.n27(U32.is_lt(a, 112), a)

def comp.b774.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8168}

def comp.b774.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8152}
    case False{}:
      comp.b774.n29(U32.is_lt(a, 933), a)

def comp.b774.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8112}

def comp.b774.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8144}

def comp.b774.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n31(U32.is_lt(a, 945), a)
    case False{}:
      comp.b774.n32(U32.is_lt(a, 953), a)

def comp.b774.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n30(U32.is_lt(a, 922), a)
    case False{}:
      comp.b774.n33(U32.is_lt(a, 946), a)

def comp.b774.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8160}

def comp.b774.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1232}

def comp.b774.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n35(U32.is_lt(a, 965), a)
    case False{}:
      comp.b774.n36(U32.is_lt(a, 1040), a)

def comp.b774.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1238}

def comp.b774.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1217}
    case False{}:
      None{}

def comp.b774.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n38(U32.is_lt(a, 1045), a)
    case False{}:
      comp.b774.n39(U32.is_lt(a, 1047), a)

def comp.b774.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n37(U32.is_lt(a, 966), a)
    case False{}:
      comp.b774.n40(U32.is_lt(a, 1046), a)

def comp.b774.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n34(U32.is_lt(a, 934), a)
    case False{}:
      comp.b774.n41(U32.is_lt(a, 1041), a)

def comp.b774.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1049}
    case False{}:
      None{}

def comp.b774.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1038}
    case False{}:
      None{}

def comp.b774.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n43(U32.is_lt(a, 1049), a)
    case False{}:
      comp.b774.n44(U32.is_lt(a, 1060), a)

def comp.b774.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1233}
    case False{}:
      None{}

def comp.b774.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1239}
    case False{}:
      Some{1218}

def comp.b774.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n46(U32.is_lt(a, 1073), a)
    case False{}:
      comp.b774.n47(U32.is_lt(a, 1078), a)

def comp.b774.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n45(U32.is_lt(a, 1059), a)
    case False{}:
      comp.b774.n48(U32.is_lt(a, 1077), a)

def comp.b774.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1081}

def comp.b774.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1118}

def comp.b774.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n50(U32.is_lt(a, 1080), a)
    case False{}:
      comp.b774.n51(U32.is_lt(a, 1091), a)

def comp.b774.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7862}

def comp.b774.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7863}
    case False{}:
      None{}

def comp.b774.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n53(U32.is_lt(a, 7840), a)
    case False{}:
      comp.b774.n54(U32.is_lt(a, 7842), a)

def comp.b774.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n52(U32.is_lt(a, 1081), a)
    case False{}:
      comp.b774.n55(U32.is_lt(a, 7841), a)

def comp.b774.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n49(U32.is_lt(a, 1072), a)
    case False{}:
      comp.b774.n56(U32.is_lt(a, 1092), a)

def comp.b774.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n42(U32.is_lt(a, 954), a)
    case False{}:
      comp.b774.n57(U32.is_lt(a, 1079), a)

def comp.b774.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774.n28(U32.is_lt(a, 101), a)
    case False{}:
      comp.b774.n58(U32.is_lt(a, 1048), a)

def comp.b774(+a: U32) -> Maybe<&2, U32>:
  comp.b774.n59(U32.is_lt(a, 921), a)

def comp.b775.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{550}
    case False{}:
      Some{7682}

def comp.b775.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b775.n0(U32.is_lt(a, 66), a)

def comp.b775.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{266}
    case False{}:
      Some{7690}

def comp.b775.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{278}
    case False{}:
      Some{7710}

def comp.b775.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n2(U32.is_lt(a, 68), a)
    case False{}:
      comp.b775.n3(U32.is_lt(a, 70), a)

def comp.b775.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b775.n4(U32.is_lt(a, 69), a)

def comp.b775.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{288}
    case False{}:
      Some{7714}

def comp.b775.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{304}
    case False{}:
      None{}

def comp.b775.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n6(U32.is_lt(a, 72), a)
    case False{}:
      comp.b775.n7(U32.is_lt(a, 74), a)

def comp.b775.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7744}
    case False{}:
      Some{7748}

def comp.b775.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{558}
    case False{}:
      Some{7766}

def comp.b775.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n9(U32.is_lt(a, 78), a)
    case False{}:
      comp.b775.n10(U32.is_lt(a, 80), a)

def comp.b775.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n8(U32.is_lt(a, 73), a)
    case False{}:
      comp.b775.n11(U32.is_lt(a, 79), a)

def comp.b775.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n5(U32.is_lt(a, 67), a)
    case False{}:
      comp.b775.n12(U32.is_lt(a, 77), a)

def comp.b775.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7768}

def comp.b775.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7776}
    case False{}:
      Some{7786}

def comp.b775.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n14(U32.is_lt(a, 82), a)
    case False{}:
      comp.b775.n15(U32.is_lt(a, 84), a)

def comp.b775.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7814}

def comp.b775.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7818}
    case False{}:
      Some{7822}

def comp.b775.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n17(U32.is_lt(a, 87), a)
    case False{}:
      comp.b775.n18(U32.is_lt(a, 89), a)

def comp.b775.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n16(U32.is_lt(a, 83), a)
    case False{}:
      comp.b775.n19(U32.is_lt(a, 88), a)

def comp.b775.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{379}
    case False{}:
      None{}

def comp.b775.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{551}
    case False{}:
      Some{7683}

def comp.b775.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n21(U32.is_lt(a, 91), a)
    case False{}:
      comp.b775.n22(U32.is_lt(a, 98), a)

def comp.b775.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{267}
    case False{}:
      Some{7691}

def comp.b775.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{279}
    case False{}:
      Some{7711}

def comp.b775.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n24(U32.is_lt(a, 100), a)
    case False{}:
      comp.b775.n25(U32.is_lt(a, 102), a)

def comp.b775.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n23(U32.is_lt(a, 97), a)
    case False{}:
      comp.b775.n26(U32.is_lt(a, 101), a)

def comp.b775.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n20(U32.is_lt(a, 85), a)
    case False{}:
      comp.b775.n27(U32.is_lt(a, 99), a)

def comp.b775.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n13(U32.is_lt(a, 71), a)
    case False{}:
      comp.b775.n28(U32.is_lt(a, 90), a)

def comp.b775.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{289}
    case False{}:
      Some{7715}

def comp.b775.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7745}

def comp.b775.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n30(U32.is_lt(a, 104), a)
    case False{}:
      comp.b775.n31(U32.is_lt(a, 109), a)

def comp.b775.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7749}
    case False{}:
      Some{559}

def comp.b775.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7767}
    case False{}:
      None{}

def comp.b775.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n33(U32.is_lt(a, 111), a)
    case False{}:
      comp.b775.n34(U32.is_lt(a, 113), a)

def comp.b775.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n32(U32.is_lt(a, 105), a)
    case False{}:
      comp.b775.n35(U32.is_lt(a, 112), a)

def comp.b775.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7769}
    case False{}:
      Some{7777}

def comp.b775.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7787}
    case False{}:
      None{}

def comp.b775.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n37(U32.is_lt(a, 115), a)
    case False{}:
      comp.b775.n38(U32.is_lt(a, 117), a)

def comp.b775.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7815}
    case False{}:
      Some{7819}

def comp.b775.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7823}
    case False{}:
      Some{380}

def comp.b775.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n40(U32.is_lt(a, 120), a)
    case False{}:
      comp.b775.n41(U32.is_lt(a, 122), a)

def comp.b775.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n39(U32.is_lt(a, 116), a)
    case False{}:
      comp.b775.n42(U32.is_lt(a, 121), a)

def comp.b775.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n36(U32.is_lt(a, 110), a)
    case False{}:
      comp.b775.n43(U32.is_lt(a, 119), a)

def comp.b775.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7780}

def comp.b775.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7781}
    case False{}:
      None{}

def comp.b775.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n45(U32.is_lt(a, 346), a)
    case False{}:
      comp.b775.n46(U32.is_lt(a, 348), a)

def comp.b775.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7782}
    case False{}:
      Some{7783}

def comp.b775.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7835}

def comp.b775.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n48(U32.is_lt(a, 353), a)
    case False{}:
      comp.b775.n49(U32.is_lt(a, 383), a)

def comp.b775.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n47(U32.is_lt(a, 347), a)
    case False{}:
      comp.b775.n50(U32.is_lt(a, 354), a)

def comp.b775.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7784}

def comp.b775.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7785}
    case False{}:
      None{}

def comp.b775.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n52(U32.is_lt(a, 7778), a)
    case False{}:
      comp.b775.n53(U32.is_lt(a, 7780), a)

def comp.b775.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{67017}
    case False{}:
      None{}

def comp.b775.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{67044}
    case False{}:
      None{}

def comp.b775.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n55(U32.is_lt(a, 67027), a)
    case False{}:
      comp.b775.n56(U32.is_lt(a, 67035), a)

def comp.b775.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n54(U32.is_lt(a, 7779), a)
    case False{}:
      comp.b775.n57(U32.is_lt(a, 67034), a)

def comp.b775.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n51(U32.is_lt(a, 352), a)
    case False{}:
      comp.b775.n58(U32.is_lt(a, 67026), a)

def comp.b775.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n44(U32.is_lt(a, 114), a)
    case False{}:
      comp.b775.n59(U32.is_lt(a, 384), a)

def comp.b775.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b775.n29(U32.is_lt(a, 81), a)
    case False{}:
      comp.b775.n60(U32.is_lt(a, 123), a)

def comp.b775(+a: U32) -> Maybe<&2, U32>:
  comp.b775.n61(U32.is_lt(a, 103), a)

def comp.b776.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{196}

def comp.b776.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{203}
    case False{}:
      None{}

def comp.b776.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n1(U32.is_lt(a, 70), a)

def comp.b776.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b776.n2(U32.is_lt(a, 69), a)

def comp.b776.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{207}
    case False{}:
      None{}

def comp.b776.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7718}
    case False{}:
      comp.b776.n4(U32.is_lt(a, 74), a)

def comp.b776.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{220}

def comp.b776.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{214}
    case False{}:
      comp.b776.n6(U32.is_lt(a, 85), a)

def comp.b776.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n5(U32.is_lt(a, 73), a)
    case False{}:
      comp.b776.n7(U32.is_lt(a, 80), a)

def comp.b776.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n3(U32.is_lt(a, 66), a)
    case False{}:
      comp.b776.n8(U32.is_lt(a, 79), a)

def comp.b776.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7812}
    case False{}:
      Some{7820}

def comp.b776.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n10(U32.is_lt(a, 88), a)

def comp.b776.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{228}

def comp.b776.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{376}
    case False{}:
      comp.b776.n12(U32.is_lt(a, 97), a)

def comp.b776.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n11(U32.is_lt(a, 87), a)
    case False{}:
      comp.b776.n13(U32.is_lt(a, 90), a)

def comp.b776.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{235}
    case False{}:
      None{}

def comp.b776.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n15(U32.is_lt(a, 102), a)

def comp.b776.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{239}
    case False{}:
      None{}

def comp.b776.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7719}
    case False{}:
      comp.b776.n17(U32.is_lt(a, 106), a)

def comp.b776.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n16(U32.is_lt(a, 101), a)
    case False{}:
      comp.b776.n18(U32.is_lt(a, 105), a)

def comp.b776.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n14(U32.is_lt(a, 89), a)
    case False{}:
      comp.b776.n19(U32.is_lt(a, 104), a)

def comp.b776.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n9(U32.is_lt(a, 72), a)
    case False{}:
      comp.b776.n20(U32.is_lt(a, 98), a)

def comp.b776.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{246}
    case False{}:
      None{}

def comp.b776.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{252}
    case False{}:
      None{}

def comp.b776.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7831}
    case False{}:
      comp.b776.n23(U32.is_lt(a, 118), a)

def comp.b776.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n22(U32.is_lt(a, 112), a)
    case False{}:
      comp.b776.n24(U32.is_lt(a, 117), a)

def comp.b776.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7821}
    case False{}:
      Some{255}

def comp.b776.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7813}
    case False{}:
      comp.b776.n26(U32.is_lt(a, 121), a)

def comp.b776.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7758}
    case False{}:
      None{}

def comp.b776.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n28(U32.is_lt(a, 214), a)

def comp.b776.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n27(U32.is_lt(a, 120), a)
    case False{}:
      comp.b776.n29(U32.is_lt(a, 213), a)

def comp.b776.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n25(U32.is_lt(a, 116), a)
    case False{}:
      comp.b776.n30(U32.is_lt(a, 122), a)

def comp.b776.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7802}

def comp.b776.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7759}
    case False{}:
      comp.b776.n32(U32.is_lt(a, 362), a)

def comp.b776.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{938}

def comp.b776.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7803}
    case False{}:
      comp.b776.n34(U32.is_lt(a, 921), a)

def comp.b776.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n33(U32.is_lt(a, 246), a)
    case False{}:
      comp.b776.n35(U32.is_lt(a, 364), a)

def comp.b776.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{939}
    case False{}:
      None{}

def comp.b776.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n37(U32.is_lt(a, 934), a)

def comp.b776.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{971}

def comp.b776.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{970}
    case False{}:
      comp.b776.n39(U32.is_lt(a, 965), a)

def comp.b776.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n38(U32.is_lt(a, 933), a)
    case False{}:
      comp.b776.n40(U32.is_lt(a, 954), a)

def comp.b776.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n36(U32.is_lt(a, 363), a)
    case False{}:
      comp.b776.n41(U32.is_lt(a, 953), a)

def comp.b776.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n31(U32.is_lt(a, 119), a)
    case False{}:
      comp.b776.n42(U32.is_lt(a, 922), a)

def comp.b776.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n21(U32.is_lt(a, 86), a)
    case False{}:
      comp.b776.n43(U32.is_lt(a, 245), a)

def comp.b776.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{980}

def comp.b776.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1031}
    case False{}:
      None{}

def comp.b776.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n46(U32.is_lt(a, 1031), a)

def comp.b776.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n45(U32.is_lt(a, 978), a)
    case False{}:
      comp.b776.n47(U32.is_lt(a, 1030), a)

def comp.b776.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1025}

def comp.b776.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1234}
    case False{}:
      comp.b776.n49(U32.is_lt(a, 1045), a)

def comp.b776.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1246}
    case False{}:
      Some{1252}

def comp.b776.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1244}
    case False{}:
      comp.b776.n51(U32.is_lt(a, 1048), a)

def comp.b776.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n50(U32.is_lt(a, 1041), a)
    case False{}:
      comp.b776.n52(U32.is_lt(a, 1047), a)

def comp.b776.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n48(U32.is_lt(a, 979), a)
    case False{}:
      comp.b776.n53(U32.is_lt(a, 1046), a)

def comp.b776.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1254}
    case False{}:
      None{}

def comp.b776.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n55(U32.is_lt(a, 1055), a)

def comp.b776.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1268}

def comp.b776.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1264}
    case False{}:
      comp.b776.n57(U32.is_lt(a, 1063), a)

def comp.b776.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n56(U32.is_lt(a, 1054), a)
    case False{}:
      comp.b776.n58(U32.is_lt(a, 1060), a)

def comp.b776.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1272}
    case False{}:
      None{}

def comp.b776.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n60(U32.is_lt(a, 1068), a)

def comp.b776.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1235}

def comp.b776.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1260}
    case False{}:
      comp.b776.n62(U32.is_lt(a, 1072), a)

def comp.b776.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n61(U32.is_lt(a, 1067), a)
    case False{}:
      comp.b776.n63(U32.is_lt(a, 1070), a)

def comp.b776.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n59(U32.is_lt(a, 1059), a)
    case False{}:
      comp.b776.n64(U32.is_lt(a, 1069), a)

def comp.b776.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n54(U32.is_lt(a, 1040), a)
    case False{}:
      comp.b776.n65(U32.is_lt(a, 1064), a)

def comp.b776.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1105}
    case False{}:
      Some{1245}

def comp.b776.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n67(U32.is_lt(a, 1078), a)

def comp.b776.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1253}
    case False{}:
      None{}

def comp.b776.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1247}
    case False{}:
      comp.b776.n69(U32.is_lt(a, 1081), a)

def comp.b776.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n68(U32.is_lt(a, 1077), a)
    case False{}:
      comp.b776.n70(U32.is_lt(a, 1080), a)

def comp.b776.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1265}

def comp.b776.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1255}
    case False{}:
      comp.b776.n72(U32.is_lt(a, 1091), a)

def comp.b776.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1269}
    case False{}:
      None{}

def comp.b776.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n74(U32.is_lt(a, 1096), a)

def comp.b776.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n73(U32.is_lt(a, 1087), a)
    case False{}:
      comp.b776.n75(U32.is_lt(a, 1095), a)

def comp.b776.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n71(U32.is_lt(a, 1079), a)
    case False{}:
      comp.b776.n76(U32.is_lt(a, 1092), a)

def comp.b776.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1261}

def comp.b776.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1273}
    case False{}:
      comp.b776.n78(U32.is_lt(a, 1101), a)

def comp.b776.n80(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1111}
    case False{}:
      None{}

def comp.b776.n81(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b776.n80(U32.is_lt(a, 1111), a)

def comp.b776.n82(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n79(U32.is_lt(a, 1100), a)
    case False{}:
      comp.b776.n81(U32.is_lt(a, 1110), a)

def comp.b776.n83(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1243}
    case False{}:
      None{}

def comp.b776.n84(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1242}
    case False{}:
      comp.b776.n83(U32.is_lt(a, 1242), a)

def comp.b776.n85(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1259}
    case False{}:
      None{}

def comp.b776.n86(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1258}
    case False{}:
      comp.b776.n85(U32.is_lt(a, 1258), a)

def comp.b776.n87(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n84(U32.is_lt(a, 1241), a)
    case False{}:
      comp.b776.n86(U32.is_lt(a, 1257), a)

def comp.b776.n88(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n82(U32.is_lt(a, 1102), a)
    case False{}:
      comp.b776.n87(U32.is_lt(a, 1256), a)

def comp.b776.n89(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n77(U32.is_lt(a, 1086), a)
    case False{}:
      comp.b776.n88(U32.is_lt(a, 1240), a)

def comp.b776.n90(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n66(U32.is_lt(a, 1049), a)
    case False{}:
      comp.b776.n89(U32.is_lt(a, 1099), a)

def comp.b776.n91(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776.n44(U32.is_lt(a, 111), a)
    case False{}:
      comp.b776.n90(U32.is_lt(a, 1073), a)

def comp.b776(+a: U32) -> Maybe<&2, U32>:
  comp.b776.n91(U32.is_lt(a, 966), a)

def comp.b777.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7842}

def comp.b777.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7866}
    case False{}:
      None{}

def comp.b777.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n1(U32.is_lt(a, 70), a)

def comp.b777.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b777.n2(U32.is_lt(a, 69), a)

def comp.b777.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7886}

def comp.b777.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7880}
    case False{}:
      comp.b777.n4(U32.is_lt(a, 79), a)

def comp.b777.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7910}
    case False{}:
      None{}

def comp.b777.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n6(U32.is_lt(a, 86), a)

def comp.b777.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n5(U32.is_lt(a, 74), a)
    case False{}:
      comp.b777.n7(U32.is_lt(a, 85), a)

def comp.b777.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n3(U32.is_lt(a, 66), a)
    case False{}:
      comp.b777.n8(U32.is_lt(a, 80), a)

def comp.b777.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7843}

def comp.b777.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7926}
    case False{}:
      comp.b777.n10(U32.is_lt(a, 97), a)

def comp.b777.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7867}
    case False{}:
      None{}

def comp.b777.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n12(U32.is_lt(a, 102), a)

def comp.b777.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n11(U32.is_lt(a, 90), a)
    case False{}:
      comp.b777.n13(U32.is_lt(a, 101), a)

def comp.b777.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7887}

def comp.b777.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7881}
    case False{}:
      comp.b777.n15(U32.is_lt(a, 111), a)

def comp.b777.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7911}
    case False{}:
      None{}

def comp.b777.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n17(U32.is_lt(a, 118), a)

def comp.b777.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n16(U32.is_lt(a, 106), a)
    case False{}:
      comp.b777.n18(U32.is_lt(a, 117), a)

def comp.b777.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n14(U32.is_lt(a, 98), a)
    case False{}:
      comp.b777.n19(U32.is_lt(a, 112), a)

def comp.b777.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n9(U32.is_lt(a, 73), a)
    case False{}:
      comp.b777.n20(U32.is_lt(a, 105), a)

def comp.b777.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7927}
    case False{}:
      None{}

def comp.b777.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7874}

def comp.b777.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7848}
    case False{}:
      comp.b777.n23(U32.is_lt(a, 202), a)

def comp.b777.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n22(U32.is_lt(a, 122), a)
    case False{}:
      comp.b777.n24(U32.is_lt(a, 195), a)

def comp.b777.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7892}
    case False{}:
      None{}

def comp.b777.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n26(U32.is_lt(a, 213), a)

def comp.b777.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7875}

def comp.b777.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7849}
    case False{}:
      comp.b777.n28(U32.is_lt(a, 234), a)

def comp.b777.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n27(U32.is_lt(a, 212), a)
    case False{}:
      comp.b777.n29(U32.is_lt(a, 227), a)

def comp.b777.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n25(U32.is_lt(a, 194), a)
    case False{}:
      comp.b777.n30(U32.is_lt(a, 226), a)

def comp.b777.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7893}
    case False{}:
      None{}

def comp.b777.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b777.n32(U32.is_lt(a, 245), a)

def comp.b777.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7859}
    case False{}:
      None{}

def comp.b777.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7858}
    case False{}:
      comp.b777.n34(U32.is_lt(a, 260), a)

def comp.b777.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n33(U32.is_lt(a, 244), a)
    case False{}:
      comp.b777.n35(U32.is_lt(a, 259), a)

def comp.b777.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7903}
    case False{}:
      None{}

def comp.b777.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7902}
    case False{}:
      comp.b777.n37(U32.is_lt(a, 418), a)

def comp.b777.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7917}
    case False{}:
      None{}

def comp.b777.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7916}
    case False{}:
      comp.b777.n39(U32.is_lt(a, 433), a)

def comp.b777.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n38(U32.is_lt(a, 417), a)
    case False{}:
      comp.b777.n40(U32.is_lt(a, 432), a)

def comp.b777.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n36(U32.is_lt(a, 258), a)
    case False{}:
      comp.b777.n41(U32.is_lt(a, 431), a)

def comp.b777.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n31(U32.is_lt(a, 203), a)
    case False{}:
      comp.b777.n42(U32.is_lt(a, 416), a)

def comp.b777.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b777.n21(U32.is_lt(a, 89), a)
    case False{}:
      comp.b777.n43(U32.is_lt(a, 235), a)

def comp.b777(+a: U32) -> Maybe<&2, U32>:
  comp.b777.n44(U32.is_lt(a, 121), a)

def comp.b778.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{197}
    case False{}:
      None{}

def comp.b778.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b778.n0(U32.is_lt(a, 66), a)

def comp.b778.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{229}

def comp.b778.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{366}
    case False{}:
      comp.b778.n2(U32.is_lt(a, 97), a)

def comp.b778.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b778.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b778.n3(U32.is_lt(a, 86), a)

def comp.b778.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{367}
    case False{}:
      None{}

def comp.b778.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b778.n5(U32.is_lt(a, 118), a)

def comp.b778.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7832}
    case False{}:
      None{}

def comp.b778.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7833}
    case False{}:
      None{}

def comp.b778.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b778.n7(U32.is_lt(a, 120), a)
    case False{}:
      comp.b778.n8(U32.is_lt(a, 122), a)

def comp.b778.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b778.n6(U32.is_lt(a, 117), a)
    case False{}:
      comp.b778.n9(U32.is_lt(a, 121), a)

def comp.b778.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b778.n4(U32.is_lt(a, 85), a)
    case False{}:
      comp.b778.n10(U32.is_lt(a, 119), a)

def comp.b778(+a: U32) -> Maybe<&2, U32>:
  comp.b778.n11(U32.is_lt(a, 98), a)

def comp.b779.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{336}
    case False{}:
      None{}

def comp.b779.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b779.n0(U32.is_lt(a, 80), a)

def comp.b779.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{337}

def comp.b779.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{368}
    case False{}:
      comp.b779.n2(U32.is_lt(a, 111), a)

def comp.b779.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b779.n1(U32.is_lt(a, 79), a)
    case False{}:
      comp.b779.n3(U32.is_lt(a, 86), a)

def comp.b779.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{369}
    case False{}:
      None{}

def comp.b779.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b779.n5(U32.is_lt(a, 118), a)

def comp.b779.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1266}
    case False{}:
      None{}

def comp.b779.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1267}
    case False{}:
      None{}

def comp.b779.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b779.n7(U32.is_lt(a, 1060), a)
    case False{}:
      comp.b779.n8(U32.is_lt(a, 1092), a)

def comp.b779.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b779.n6(U32.is_lt(a, 117), a)
    case False{}:
      comp.b779.n9(U32.is_lt(a, 1091), a)

def comp.b779.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b779.n4(U32.is_lt(a, 85), a)
    case False{}:
      comp.b779.n10(U32.is_lt(a, 1059), a)

def comp.b779(+a: U32) -> Maybe<&2, U32>:
  comp.b779.n11(U32.is_lt(a, 112), a)

def comp.b780.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{461}
    case False{}:
      None{}

def comp.b780.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b780.n0(U32.is_lt(a, 66), a)

def comp.b780.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{270}
    case False{}:
      Some{282}

def comp.b780.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{268}
    case False{}:
      comp.b780.n2(U32.is_lt(a, 69), a)

def comp.b780.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b780.n3(U32.is_lt(a, 68), a)

def comp.b780.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{486}
    case False{}:
      Some{542}

def comp.b780.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b780.n5(U32.is_lt(a, 72), a)

def comp.b780.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{463}
    case False{}:
      None{}

def comp.b780.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{488}
    case False{}:
      Some{317}

def comp.b780.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n7(U32.is_lt(a, 74), a)
    case False{}:
      comp.b780.n8(U32.is_lt(a, 76), a)

def comp.b780.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n6(U32.is_lt(a, 71), a)
    case False{}:
      comp.b780.n9(U32.is_lt(a, 75), a)

def comp.b780.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n4(U32.is_lt(a, 67), a)
    case False{}:
      comp.b780.n10(U32.is_lt(a, 73), a)

def comp.b780.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{327}
    case False{}:
      Some{465}

def comp.b780.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b780.n12(U32.is_lt(a, 79), a)

def comp.b780.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{344}

def comp.b780.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{352}
    case False{}:
      Some{356}

def comp.b780.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n14(U32.is_lt(a, 82), a)
    case False{}:
      comp.b780.n15(U32.is_lt(a, 84), a)

def comp.b780.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n13(U32.is_lt(a, 78), a)
    case False{}:
      comp.b780.n16(U32.is_lt(a, 83), a)

def comp.b780.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{381}

def comp.b780.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{467}
    case False{}:
      comp.b780.n18(U32.is_lt(a, 90), a)

def comp.b780.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{462}

def comp.b780.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{269}

def comp.b780.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n20(U32.is_lt(a, 97), a)
    case False{}:
      comp.b780.n21(U32.is_lt(a, 99), a)

def comp.b780.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n19(U32.is_lt(a, 86), a)
    case False{}:
      comp.b780.n22(U32.is_lt(a, 98), a)

def comp.b780.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n17(U32.is_lt(a, 80), a)
    case False{}:
      comp.b780.n23(U32.is_lt(a, 91), a)

def comp.b780.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n11(U32.is_lt(a, 70), a)
    case False{}:
      comp.b780.n24(U32.is_lt(a, 85), a)

def comp.b780.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{283}
    case False{}:
      None{}

def comp.b780.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{271}
    case False{}:
      comp.b780.n26(U32.is_lt(a, 102), a)

def comp.b780.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{487}
    case False{}:
      Some{543}

def comp.b780.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{464}
    case False{}:
      Some{496}

def comp.b780.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n28(U32.is_lt(a, 104), a)
    case False{}:
      comp.b780.n29(U32.is_lt(a, 106), a)

def comp.b780.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n27(U32.is_lt(a, 101), a)
    case False{}:
      comp.b780.n30(U32.is_lt(a, 105), a)

def comp.b780.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{318}
    case False{}:
      None{}

def comp.b780.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{489}
    case False{}:
      comp.b780.n32(U32.is_lt(a, 109), a)

def comp.b780.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{328}
    case False{}:
      Some{466}

def comp.b780.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{345}

def comp.b780.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n34(U32.is_lt(a, 111), a)
    case False{}:
      comp.b780.n35(U32.is_lt(a, 114), a)

def comp.b780.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n33(U32.is_lt(a, 108), a)
    case False{}:
      comp.b780.n36(U32.is_lt(a, 112), a)

def comp.b780.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n31(U32.is_lt(a, 103), a)
    case False{}:
      comp.b780.n37(U32.is_lt(a, 110), a)

def comp.b780.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{357}
    case False{}:
      Some{468}

def comp.b780.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{353}
    case False{}:
      comp.b780.n39(U32.is_lt(a, 117), a)

def comp.b780.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{382}

def comp.b780.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{473}

def comp.b780.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n41(U32.is_lt(a, 122), a)
    case False{}:
      comp.b780.n42(U32.is_lt(a, 220), a)

def comp.b780.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n40(U32.is_lt(a, 116), a)
    case False{}:
      comp.b780.n43(U32.is_lt(a, 123), a)

def comp.b780.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{474}
    case False{}:
      None{}

def comp.b780.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b780.n45(U32.is_lt(a, 253), a)

def comp.b780.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{494}
    case False{}:
      None{}

def comp.b780.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{495}
    case False{}:
      None{}

def comp.b780.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n47(U32.is_lt(a, 440), a)
    case False{}:
      comp.b780.n48(U32.is_lt(a, 659), a)

def comp.b780.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n46(U32.is_lt(a, 252), a)
    case False{}:
      comp.b780.n49(U32.is_lt(a, 658), a)

def comp.b780.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n44(U32.is_lt(a, 118), a)
    case False{}:
      comp.b780.n50(U32.is_lt(a, 439), a)

def comp.b780.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n38(U32.is_lt(a, 107), a)
    case False{}:
      comp.b780.n51(U32.is_lt(a, 221), a)

def comp.b780.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780.n25(U32.is_lt(a, 77), a)
    case False{}:
      comp.b780.n52(U32.is_lt(a, 115), a)

def comp.b780(+a: U32) -> Maybe<&2, U32>:
  comp.b780.n53(U32.is_lt(a, 100), a)

def comp.b783.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{512}
    case False{}:
      None{}

def comp.b783.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b783.n0(U32.is_lt(a, 66), a)

def comp.b783.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{516}
    case False{}:
      None{}

def comp.b783.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{520}
    case False{}:
      None{}

def comp.b783.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n2(U32.is_lt(a, 70), a)
    case False{}:
      comp.b783.n3(U32.is_lt(a, 74), a)

def comp.b783.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b783.n4(U32.is_lt(a, 73), a)

def comp.b783.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{528}

def comp.b783.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{524}
    case False{}:
      comp.b783.n6(U32.is_lt(a, 82), a)

def comp.b783.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{532}

def comp.b783.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{513}

def comp.b783.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n8(U32.is_lt(a, 85), a)
    case False{}:
      comp.b783.n9(U32.is_lt(a, 97), a)

def comp.b783.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n7(U32.is_lt(a, 80), a)
    case False{}:
      comp.b783.n10(U32.is_lt(a, 86), a)

def comp.b783.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n5(U32.is_lt(a, 69), a)
    case False{}:
      comp.b783.n11(U32.is_lt(a, 83), a)

def comp.b783.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{517}
    case False{}:
      None{}

def comp.b783.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b783.n13(U32.is_lt(a, 102), a)

def comp.b783.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{521}
    case False{}:
      None{}

def comp.b783.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{525}
    case False{}:
      None{}

def comp.b783.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n15(U32.is_lt(a, 106), a)
    case False{}:
      comp.b783.n16(U32.is_lt(a, 112), a)

def comp.b783.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n14(U32.is_lt(a, 101), a)
    case False{}:
      comp.b783.n17(U32.is_lt(a, 111), a)

def comp.b783.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{533}

def comp.b783.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{529}
    case False{}:
      comp.b783.n19(U32.is_lt(a, 117), a)

def comp.b783.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1142}

def comp.b783.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1143}
    case False{}:
      None{}

def comp.b783.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n21(U32.is_lt(a, 1140), a)
    case False{}:
      comp.b783.n22(U32.is_lt(a, 1142), a)

def comp.b783.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n20(U32.is_lt(a, 115), a)
    case False{}:
      comp.b783.n23(U32.is_lt(a, 1141), a)

def comp.b783.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n18(U32.is_lt(a, 105), a)
    case False{}:
      comp.b783.n24(U32.is_lt(a, 118), a)

def comp.b783.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783.n12(U32.is_lt(a, 79), a)
    case False{}:
      comp.b783.n25(U32.is_lt(a, 114), a)

def comp.b783(+a: U32) -> Maybe<&2, U32>:
  comp.b783.n26(U32.is_lt(a, 98), a)

def comp.b785.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{514}
    case False{}:
      None{}

def comp.b785.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b785.n0(U32.is_lt(a, 66), a)

def comp.b785.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{522}

def comp.b785.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{518}
    case False{}:
      comp.b785.n2(U32.is_lt(a, 73), a)

def comp.b785.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b785.n3(U32.is_lt(a, 70), a)

def comp.b785.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{526}
    case False{}:
      None{}

def comp.b785.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b785.n5(U32.is_lt(a, 80), a)

def comp.b785.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{534}

def comp.b785.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{530}
    case False{}:
      comp.b785.n7(U32.is_lt(a, 85), a)

def comp.b785.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n6(U32.is_lt(a, 79), a)
    case False{}:
      comp.b785.n8(U32.is_lt(a, 83), a)

def comp.b785.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n4(U32.is_lt(a, 69), a)
    case False{}:
      comp.b785.n9(U32.is_lt(a, 82), a)

def comp.b785.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{515}
    case False{}:
      None{}

def comp.b785.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b785.n11(U32.is_lt(a, 98), a)

def comp.b785.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{523}

def comp.b785.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{519}
    case False{}:
      comp.b785.n13(U32.is_lt(a, 105), a)

def comp.b785.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n12(U32.is_lt(a, 97), a)
    case False{}:
      comp.b785.n14(U32.is_lt(a, 102), a)

def comp.b785.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{527}
    case False{}:
      None{}

def comp.b785.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b785.n16(U32.is_lt(a, 112), a)

def comp.b785.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{531}
    case False{}:
      None{}

def comp.b785.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{535}
    case False{}:
      None{}

def comp.b785.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n18(U32.is_lt(a, 115), a)
    case False{}:
      comp.b785.n19(U32.is_lt(a, 118), a)

def comp.b785.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n17(U32.is_lt(a, 111), a)
    case False{}:
      comp.b785.n20(U32.is_lt(a, 117), a)

def comp.b785.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n15(U32.is_lt(a, 101), a)
    case False{}:
      comp.b785.n21(U32.is_lt(a, 114), a)

def comp.b785.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b785.n10(U32.is_lt(a, 74), a)
    case False{}:
      comp.b785.n22(U32.is_lt(a, 106), a)

def comp.b785(+a: U32) -> Maybe<&2, U32>:
  comp.b785.n23(U32.is_lt(a, 86), a)

def comp.b787.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7944}
    case False{}:
      None{}

def comp.b787.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b787.n0(U32.is_lt(a, 914), a)

def comp.b787.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7960}
    case False{}:
      None{}

def comp.b787.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7976}
    case False{}:
      None{}

def comp.b787.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n2(U32.is_lt(a, 918), a)
    case False{}:
      comp.b787.n3(U32.is_lt(a, 920), a)

def comp.b787.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n1(U32.is_lt(a, 913), a)
    case False{}:
      comp.b787.n4(U32.is_lt(a, 919), a)

def comp.b787.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8008}

def comp.b787.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7992}
    case False{}:
      comp.b787.n6(U32.is_lt(a, 927), a)

def comp.b787.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8040}

def comp.b787.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7936}

def comp.b787.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n8(U32.is_lt(a, 937), a)
    case False{}:
      comp.b787.n9(U32.is_lt(a, 945), a)

def comp.b787.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n7(U32.is_lt(a, 922), a)
    case False{}:
      comp.b787.n10(U32.is_lt(a, 938), a)

def comp.b787.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n5(U32.is_lt(a, 917), a)
    case False{}:
      comp.b787.n11(U32.is_lt(a, 928), a)

def comp.b787.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7952}
    case False{}:
      None{}

def comp.b787.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b787.n13(U32.is_lt(a, 950), a)

def comp.b787.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7968}
    case False{}:
      None{}

def comp.b787.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7984}
    case False{}:
      None{}

def comp.b787.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n15(U32.is_lt(a, 952), a)
    case False{}:
      comp.b787.n16(U32.is_lt(a, 954), a)

def comp.b787.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n14(U32.is_lt(a, 949), a)
    case False{}:
      comp.b787.n17(U32.is_lt(a, 953), a)

def comp.b787.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8000}
    case False{}:
      None{}

def comp.b787.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8164}
    case False{}:
      None{}

def comp.b787.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n19(U32.is_lt(a, 960), a)
    case False{}:
      comp.b787.n20(U32.is_lt(a, 962), a)

def comp.b787.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8016}
    case False{}:
      None{}

def comp.b787.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8032}
    case False{}:
      None{}

def comp.b787.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n22(U32.is_lt(a, 966), a)
    case False{}:
      comp.b787.n23(U32.is_lt(a, 970), a)

def comp.b787.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n21(U32.is_lt(a, 961), a)
    case False{}:
      comp.b787.n24(U32.is_lt(a, 969), a)

def comp.b787.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n18(U32.is_lt(a, 951), a)
    case False{}:
      comp.b787.n25(U32.is_lt(a, 965), a)

def comp.b787.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b787.n12(U32.is_lt(a, 921), a)
    case False{}:
      comp.b787.n26(U32.is_lt(a, 959), a)

def comp.b787(+a: U32) -> Maybe<&2, U32>:
  comp.b787.n27(U32.is_lt(a, 946), a)

def comp.b788.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7945}

def comp.b788.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7961}

def comp.b788.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n0(U32.is_lt(a, 913), a)
    case False{}:
      comp.b788.n1(U32.is_lt(a, 917), a)

def comp.b788.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7977}

def comp.b788.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7993}

def comp.b788.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n3(U32.is_lt(a, 919), a)
    case False{}:
      comp.b788.n4(U32.is_lt(a, 921), a)

def comp.b788.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n2(U32.is_lt(a, 914), a)
    case False{}:
      comp.b788.n5(U32.is_lt(a, 920), a)

def comp.b788.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8009}

def comp.b788.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8172}

def comp.b788.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n7(U32.is_lt(a, 927), a)
    case False{}:
      comp.b788.n8(U32.is_lt(a, 929), a)

def comp.b788.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8025}

def comp.b788.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8041}

def comp.b788.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n10(U32.is_lt(a, 933), a)
    case False{}:
      comp.b788.n11(U32.is_lt(a, 937), a)

def comp.b788.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n9(U32.is_lt(a, 928), a)
    case False{}:
      comp.b788.n12(U32.is_lt(a, 934), a)

def comp.b788.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n6(U32.is_lt(a, 918), a)
    case False{}:
      comp.b788.n13(U32.is_lt(a, 930), a)

def comp.b788.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7937}

def comp.b788.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7953}

def comp.b788.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n15(U32.is_lt(a, 945), a)
    case False{}:
      comp.b788.n16(U32.is_lt(a, 949), a)

def comp.b788.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7969}

def comp.b788.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7985}

def comp.b788.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n18(U32.is_lt(a, 951), a)
    case False{}:
      comp.b788.n19(U32.is_lt(a, 953), a)

def comp.b788.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n17(U32.is_lt(a, 946), a)
    case False{}:
      comp.b788.n20(U32.is_lt(a, 952), a)

def comp.b788.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8001}

def comp.b788.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8165}

def comp.b788.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n22(U32.is_lt(a, 959), a)
    case False{}:
      comp.b788.n23(U32.is_lt(a, 961), a)

def comp.b788.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8017}

def comp.b788.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8033}
    case False{}:
      None{}

def comp.b788.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b788.n26(U32.is_lt(a, 970), a)

def comp.b788.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n25(U32.is_lt(a, 965), a)
    case False{}:
      comp.b788.n27(U32.is_lt(a, 969), a)

def comp.b788.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n24(U32.is_lt(a, 960), a)
    case False{}:
      comp.b788.n28(U32.is_lt(a, 966), a)

def comp.b788.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n21(U32.is_lt(a, 950), a)
    case False{}:
      comp.b788.n29(U32.is_lt(a, 962), a)

def comp.b788.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788.n14(U32.is_lt(a, 922), a)
    case False{}:
      comp.b788.n30(U32.is_lt(a, 954), a)

def comp.b788(+a: U32) -> Maybe<&2, U32>:
  comp.b788.n31(U32.is_lt(a, 938), a)

def comp.b795.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{416}

def comp.b795.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{431}

def comp.b795.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b795.n0(U32.is_lt(a, 79), a)
    case False{}:
      comp.b795.n1(U32.is_lt(a, 85), a)

def comp.b795.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{417}

def comp.b795.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{432}
    case False{}:
      None{}

def comp.b795.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b795.n4(U32.is_lt(a, 118), a)

def comp.b795.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b795.n3(U32.is_lt(a, 111), a)
    case False{}:
      comp.b795.n5(U32.is_lt(a, 117), a)

def comp.b795.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b795.n2(U32.is_lt(a, 80), a)
    case False{}:
      comp.b795.n6(U32.is_lt(a, 112), a)

def comp.b795(+a: U32) -> Maybe<&2, U32>:
  comp.b795.n7(U32.is_lt(a, 86), a)

def comp.b803.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7840}
    case False{}:
      Some{7684}

def comp.b803.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b803.n0(U32.is_lt(a, 66), a)

def comp.b803.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7692}

def comp.b803.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7864}
    case False{}:
      None{}

def comp.b803.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n2(U32.is_lt(a, 68), a)
    case False{}:
      comp.b803.n3(U32.is_lt(a, 70), a)

def comp.b803.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n1(U32.is_lt(a, 65), a)
    case False{}:
      comp.b803.n4(U32.is_lt(a, 69), a)

def comp.b803.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7882}
    case False{}:
      None{}

def comp.b803.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7716}
    case False{}:
      comp.b803.n6(U32.is_lt(a, 74), a)

def comp.b803.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7730}
    case False{}:
      Some{7734}

def comp.b803.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7746}
    case False{}:
      Some{7750}

def comp.b803.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n8(U32.is_lt(a, 76), a)
    case False{}:
      comp.b803.n9(U32.is_lt(a, 78), a)

def comp.b803.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n7(U32.is_lt(a, 73), a)
    case False{}:
      comp.b803.n10(U32.is_lt(a, 77), a)

def comp.b803.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n5(U32.is_lt(a, 67), a)
    case False{}:
      comp.b803.n11(U32.is_lt(a, 75), a)

def comp.b803.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7770}

def comp.b803.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7884}
    case False{}:
      comp.b803.n13(U32.is_lt(a, 82), a)

def comp.b803.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7778}
    case False{}:
      Some{7788}

def comp.b803.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7908}
    case False{}:
      Some{7806}

def comp.b803.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n15(U32.is_lt(a, 84), a)
    case False{}:
      comp.b803.n16(U32.is_lt(a, 86), a)

def comp.b803.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n14(U32.is_lt(a, 80), a)
    case False{}:
      comp.b803.n17(U32.is_lt(a, 85), a)

def comp.b803.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7924}

def comp.b803.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7816}
    case False{}:
      comp.b803.n19(U32.is_lt(a, 89), a)

def comp.b803.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7826}
    case False{}:
      None{}

def comp.b803.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7841}
    case False{}:
      Some{7685}

def comp.b803.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n21(U32.is_lt(a, 91), a)
    case False{}:
      comp.b803.n22(U32.is_lt(a, 98), a)

def comp.b803.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n20(U32.is_lt(a, 88), a)
    case False{}:
      comp.b803.n23(U32.is_lt(a, 97), a)

def comp.b803.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n18(U32.is_lt(a, 83), a)
    case False{}:
      comp.b803.n24(U32.is_lt(a, 90), a)

def comp.b803.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n12(U32.is_lt(a, 72), a)
    case False{}:
      comp.b803.n25(U32.is_lt(a, 87), a)

def comp.b803.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7693}
    case False{}:
      Some{7865}

def comp.b803.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b803.n27(U32.is_lt(a, 101), a)

def comp.b803.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7717}

def comp.b803.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7883}
    case False{}:
      None{}

def comp.b803.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n29(U32.is_lt(a, 104), a)
    case False{}:
      comp.b803.n30(U32.is_lt(a, 106), a)

def comp.b803.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n28(U32.is_lt(a, 100), a)
    case False{}:
      comp.b803.n31(U32.is_lt(a, 105), a)

def comp.b803.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7735}
    case False{}:
      Some{7747}

def comp.b803.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7731}
    case False{}:
      comp.b803.n33(U32.is_lt(a, 109), a)

def comp.b803.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7751}
    case False{}:
      Some{7885}

def comp.b803.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7771}

def comp.b803.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n35(U32.is_lt(a, 111), a)
    case False{}:
      comp.b803.n36(U32.is_lt(a, 114), a)

def comp.b803.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n34(U32.is_lt(a, 108), a)
    case False{}:
      comp.b803.n37(U32.is_lt(a, 112), a)

def comp.b803.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n32(U32.is_lt(a, 102), a)
    case False{}:
      comp.b803.n38(U32.is_lt(a, 110), a)

def comp.b803.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7789}
    case False{}:
      Some{7909}

def comp.b803.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7779}
    case False{}:
      comp.b803.n40(U32.is_lt(a, 117), a)

def comp.b803.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7807}
    case False{}:
      Some{7817}

def comp.b803.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7925}

def comp.b803.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n42(U32.is_lt(a, 119), a)
    case False{}:
      comp.b803.n43(U32.is_lt(a, 121), a)

def comp.b803.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n41(U32.is_lt(a, 116), a)
    case False{}:
      comp.b803.n44(U32.is_lt(a, 120), a)

def comp.b803.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7827}
    case False{}:
      None{}

def comp.b803.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7906}
    case False{}:
      Some{7907}

def comp.b803.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n46(U32.is_lt(a, 123), a)
    case False{}:
      comp.b803.n47(U32.is_lt(a, 417), a)

def comp.b803.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7920}

def comp.b803.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7921}
    case False{}:
      None{}

def comp.b803.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n49(U32.is_lt(a, 431), a)
    case False{}:
      comp.b803.n50(U32.is_lt(a, 433), a)

def comp.b803.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n48(U32.is_lt(a, 416), a)
    case False{}:
      comp.b803.n51(U32.is_lt(a, 432), a)

def comp.b803.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n45(U32.is_lt(a, 118), a)
    case False{}:
      comp.b803.n52(U32.is_lt(a, 418), a)

def comp.b803.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n39(U32.is_lt(a, 107), a)
    case False{}:
      comp.b803.n53(U32.is_lt(a, 122), a)

def comp.b803.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803.n26(U32.is_lt(a, 79), a)
    case False{}:
      comp.b803.n54(U32.is_lt(a, 115), a)

def comp.b803(+a: U32) -> Maybe<&2, U32>:
  comp.b803.n55(U32.is_lt(a, 99), a)

def comp.b804.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7794}

def comp.b804.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7795}
    case False{}:
      None{}

def comp.b804.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b804.n1(U32.is_lt(a, 118), a)

def comp.b804.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b804.n0(U32.is_lt(a, 85), a)
    case False{}:
      comp.b804.n2(U32.is_lt(a, 117), a)

def comp.b804(+a: U32) -> Maybe<&2, U32>:
  comp.b804.n3(U32.is_lt(a, 86), a)

def comp.b805.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7680}

def comp.b805.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7681}
    case False{}:
      None{}

def comp.b805.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b805.n1(U32.is_lt(a, 98), a)

def comp.b805.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b805.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b805.n2(U32.is_lt(a, 97), a)

def comp.b805(+a: U32) -> Maybe<&2, U32>:
  comp.b805.n3(U32.is_lt(a, 66), a)

def comp.b806.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{536}
    case False{}:
      Some{538}

def comp.b806.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b806.n0(U32.is_lt(a, 84), a)

def comp.b806.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{537}

def comp.b806.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{539}
    case False{}:
      None{}

def comp.b806.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b806.n2(U32.is_lt(a, 115), a)
    case False{}:
      comp.b806.n3(U32.is_lt(a, 117), a)

def comp.b806.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b806.n1(U32.is_lt(a, 83), a)
    case False{}:
      comp.b806.n4(U32.is_lt(a, 116), a)

def comp.b806(+a: U32) -> Maybe<&2, U32>:
  comp.b806.n5(U32.is_lt(a, 85), a)

def comp.b807.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{199}

def comp.b807.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7696}
    case False{}:
      Some{552}

def comp.b807.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n0(U32.is_lt(a, 67), a)
    case False{}:
      comp.b807.n1(U32.is_lt(a, 69), a)

def comp.b807.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{290}

def comp.b807.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7720}
    case False{}:
      None{}

def comp.b807.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n3(U32.is_lt(a, 71), a)
    case False{}:
      comp.b807.n4(U32.is_lt(a, 73), a)

def comp.b807.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n2(U32.is_lt(a, 68), a)
    case False{}:
      comp.b807.n5(U32.is_lt(a, 72), a)

def comp.b807.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{310}
    case False{}:
      Some{315}

def comp.b807.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{325}

def comp.b807.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n7(U32.is_lt(a, 76), a)
    case False{}:
      comp.b807.n8(U32.is_lt(a, 78), a)

def comp.b807.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{342}

def comp.b807.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{350}
    case False{}:
      Some{354}

def comp.b807.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n10(U32.is_lt(a, 82), a)
    case False{}:
      comp.b807.n11(U32.is_lt(a, 84), a)

def comp.b807.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n9(U32.is_lt(a, 77), a)
    case False{}:
      comp.b807.n12(U32.is_lt(a, 83), a)

def comp.b807.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n6(U32.is_lt(a, 70), a)
    case False{}:
      comp.b807.n13(U32.is_lt(a, 79), a)

def comp.b807.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{231}

def comp.b807.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7697}
    case False{}:
      Some{553}

def comp.b807.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n15(U32.is_lt(a, 99), a)
    case False{}:
      comp.b807.n16(U32.is_lt(a, 101), a)

def comp.b807.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{291}

def comp.b807.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7721}
    case False{}:
      None{}

def comp.b807.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n18(U32.is_lt(a, 103), a)
    case False{}:
      comp.b807.n19(U32.is_lt(a, 105), a)

def comp.b807.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n17(U32.is_lt(a, 100), a)
    case False{}:
      comp.b807.n20(U32.is_lt(a, 104), a)

def comp.b807.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{311}
    case False{}:
      Some{316}

def comp.b807.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{326}

def comp.b807.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n22(U32.is_lt(a, 108), a)
    case False{}:
      comp.b807.n23(U32.is_lt(a, 110), a)

def comp.b807.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{343}

def comp.b807.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{355}
    case False{}:
      None{}

def comp.b807.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{351}
    case False{}:
      comp.b807.n26(U32.is_lt(a, 117), a)

def comp.b807.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n25(U32.is_lt(a, 114), a)
    case False{}:
      comp.b807.n27(U32.is_lt(a, 116), a)

def comp.b807.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n24(U32.is_lt(a, 109), a)
    case False{}:
      comp.b807.n28(U32.is_lt(a, 115), a)

def comp.b807.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n21(U32.is_lt(a, 102), a)
    case False{}:
      comp.b807.n29(U32.is_lt(a, 111), a)

def comp.b807.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807.n14(U32.is_lt(a, 75), a)
    case False{}:
      comp.b807.n30(U32.is_lt(a, 107), a)

def comp.b807(+a: U32) -> Maybe<&2, U32>:
  comp.b807.n31(U32.is_lt(a, 85), a)

def comp.b808.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{260}

def comp.b808.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{280}
    case False{}:
      None{}

def comp.b808.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b808.n1(U32.is_lt(a, 70), a)

def comp.b808.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n0(U32.is_lt(a, 65), a)
    case False{}:
      comp.b808.n2(U32.is_lt(a, 69), a)

def comp.b808.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{302}
    case False{}:
      None{}

def comp.b808.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{370}

def comp.b808.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{490}
    case False{}:
      comp.b808.n5(U32.is_lt(a, 85), a)

def comp.b808.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n4(U32.is_lt(a, 74), a)
    case False{}:
      comp.b808.n6(U32.is_lt(a, 80), a)

def comp.b808.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n3(U32.is_lt(a, 66), a)
    case False{}:
      comp.b808.n7(U32.is_lt(a, 79), a)

def comp.b808.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{261}

def comp.b808.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{281}
    case False{}:
      None{}

def comp.b808.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b808.n10(U32.is_lt(a, 102), a)

def comp.b808.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n9(U32.is_lt(a, 97), a)
    case False{}:
      comp.b808.n11(U32.is_lt(a, 101), a)

def comp.b808.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{491}

def comp.b808.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{303}
    case False{}:
      comp.b808.n13(U32.is_lt(a, 111), a)

def comp.b808.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{371}
    case False{}:
      None{}

def comp.b808.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b808.n15(U32.is_lt(a, 118), a)

def comp.b808.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n14(U32.is_lt(a, 106), a)
    case False{}:
      comp.b808.n16(U32.is_lt(a, 117), a)

def comp.b808.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n12(U32.is_lt(a, 98), a)
    case False{}:
      comp.b808.n17(U32.is_lt(a, 112), a)

def comp.b808.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b808.n8(U32.is_lt(a, 73), a)
    case False{}:
      comp.b808.n18(U32.is_lt(a, 105), a)

def comp.b808(+a: U32) -> Maybe<&2, U32>:
  comp.b808.n19(U32.is_lt(a, 86), a)

def comp.b813.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7698}

def comp.b813.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7740}

def comp.b813.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7704}
    case False{}:
      comp.b813.n1(U32.is_lt(a, 76), a)

def comp.b813.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n0(U32.is_lt(a, 68), a)
    case False{}:
      comp.b813.n2(U32.is_lt(a, 70), a)

def comp.b813.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7754}

def comp.b813.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7792}
    case False{}:
      Some{7798}

def comp.b813.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b813.n5(U32.is_lt(a, 85), a)

def comp.b813.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n4(U32.is_lt(a, 78), a)
    case False{}:
      comp.b813.n6(U32.is_lt(a, 84), a)

def comp.b813.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n3(U32.is_lt(a, 69), a)
    case False{}:
      comp.b813.n7(U32.is_lt(a, 79), a)

def comp.b813.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7699}

def comp.b813.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7741}

def comp.b813.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7705}
    case False{}:
      comp.b813.n10(U32.is_lt(a, 108), a)

def comp.b813.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n9(U32.is_lt(a, 100), a)
    case False{}:
      comp.b813.n11(U32.is_lt(a, 102), a)

def comp.b813.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7755}
    case False{}:
      None{}

def comp.b813.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b813.n13(U32.is_lt(a, 111), a)

def comp.b813.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7799}
    case False{}:
      None{}

def comp.b813.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7793}
    case False{}:
      comp.b813.n15(U32.is_lt(a, 118), a)

def comp.b813.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n14(U32.is_lt(a, 110), a)
    case False{}:
      comp.b813.n16(U32.is_lt(a, 117), a)

def comp.b813.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n12(U32.is_lt(a, 101), a)
    case False{}:
      comp.b813.n17(U32.is_lt(a, 116), a)

def comp.b813.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813.n8(U32.is_lt(a, 77), a)
    case False{}:
      comp.b813.n18(U32.is_lt(a, 109), a)

def comp.b813(+a: U32) -> Maybe<&2, U32>:
  comp.b813.n19(U32.is_lt(a, 86), a)

def comp.b814.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7722}

def comp.b814.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7723}
    case False{}:
      None{}

def comp.b814.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b814.n1(U32.is_lt(a, 105), a)

def comp.b814.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b814.n0(U32.is_lt(a, 72), a)
    case False{}:
      comp.b814.n2(U32.is_lt(a, 104), a)

def comp.b814(+a: U32) -> Maybe<&2, U32>:
  comp.b814.n3(U32.is_lt(a, 73), a)

def comp.b816.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7706}
    case False{}:
      None{}

def comp.b816.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b816.n0(U32.is_lt(a, 70), a)

def comp.b816.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7796}

def comp.b816.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7724}
    case False{}:
      comp.b816.n2(U32.is_lt(a, 85), a)

def comp.b816.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b816.n1(U32.is_lt(a, 69), a)
    case False{}:
      comp.b816.n3(U32.is_lt(a, 74), a)

def comp.b816.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7707}
    case False{}:
      None{}

def comp.b816.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b816.n5(U32.is_lt(a, 102), a)

def comp.b816.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7725}
    case False{}:
      None{}

def comp.b816.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7797}
    case False{}:
      None{}

def comp.b816.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b816.n7(U32.is_lt(a, 106), a)
    case False{}:
      comp.b816.n8(U32.is_lt(a, 118), a)

def comp.b816.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b816.n6(U32.is_lt(a, 101), a)
    case False{}:
      comp.b816.n9(U32.is_lt(a, 117), a)

def comp.b816.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b816.n4(U32.is_lt(a, 73), a)
    case False{}:
      comp.b816.n10(U32.is_lt(a, 105), a)

def comp.b816(+a: U32) -> Maybe<&2, U32>:
  comp.b816.n11(U32.is_lt(a, 86), a)

def comp.b817.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7686}

def comp.b817.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7694}

def comp.b817.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n0(U32.is_lt(a, 66), a)
    case False{}:
      comp.b817.n1(U32.is_lt(a, 68), a)

def comp.b817.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7732}

def comp.b817.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7738}
    case False{}:
      None{}

def comp.b817.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n3(U32.is_lt(a, 75), a)
    case False{}:
      comp.b817.n4(U32.is_lt(a, 77), a)

def comp.b817.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n2(U32.is_lt(a, 67), a)
    case False{}:
      comp.b817.n5(U32.is_lt(a, 76), a)

def comp.b817.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7752}
    case False{}:
      None{}

def comp.b817.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7774}
    case False{}:
      None{}

def comp.b817.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n7(U32.is_lt(a, 79), a)
    case False{}:
      comp.b817.n8(U32.is_lt(a, 83), a)

def comp.b817.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7790}
    case False{}:
      None{}

def comp.b817.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7828}
    case False{}:
      None{}

def comp.b817.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n10(U32.is_lt(a, 85), a)
    case False{}:
      comp.b817.n11(U32.is_lt(a, 91), a)

def comp.b817.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n9(U32.is_lt(a, 82), a)
    case False{}:
      comp.b817.n12(U32.is_lt(a, 90), a)

def comp.b817.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n6(U32.is_lt(a, 69), a)
    case False{}:
      comp.b817.n13(U32.is_lt(a, 84), a)

def comp.b817.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7687}
    case False{}:
      None{}

def comp.b817.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7695}
    case False{}:
      None{}

def comp.b817.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n15(U32.is_lt(a, 99), a)
    case False{}:
      comp.b817.n16(U32.is_lt(a, 101), a)

def comp.b817.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7830}
    case False{}:
      None{}

def comp.b817.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7733}
    case False{}:
      Some{7739}

def comp.b817.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n18(U32.is_lt(a, 105), a)
    case False{}:
      comp.b817.n19(U32.is_lt(a, 108), a)

def comp.b817.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n17(U32.is_lt(a, 100), a)
    case False{}:
      comp.b817.n20(U32.is_lt(a, 107), a)

def comp.b817.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7753}

def comp.b817.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7775}

def comp.b817.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n22(U32.is_lt(a, 110), a)
    case False{}:
      comp.b817.n23(U32.is_lt(a, 114), a)

def comp.b817.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{7791}

def comp.b817.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7829}
    case False{}:
      None{}

def comp.b817.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b817.n26(U32.is_lt(a, 123), a)

def comp.b817.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n25(U32.is_lt(a, 116), a)
    case False{}:
      comp.b817.n27(U32.is_lt(a, 122), a)

def comp.b817.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n24(U32.is_lt(a, 111), a)
    case False{}:
      comp.b817.n28(U32.is_lt(a, 117), a)

def comp.b817.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n21(U32.is_lt(a, 104), a)
    case False{}:
      comp.b817.n29(U32.is_lt(a, 115), a)

def comp.b817.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817.n14(U32.is_lt(a, 78), a)
    case False{}:
      comp.b817.n30(U32.is_lt(a, 109), a)

def comp.b817(+a: U32) -> Maybe<&2, U32>:
  comp.b817.n31(U32.is_lt(a, 98), a)

def comp.b824.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8814}

def comp.b824.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8800}
    case False{}:
      Some{8815}

def comp.b824.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n0(U32.is_lt(a, 60), a)
    case False{}:
      comp.b824.n1(U32.is_lt(a, 62), a)

def comp.b824.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8602}

def comp.b824.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8603}
    case False{}:
      None{}

def comp.b824.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n4(U32.is_lt(a, 8595), a)

def comp.b824.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n3(U32.is_lt(a, 8592), a)
    case False{}:
      comp.b824.n5(U32.is_lt(a, 8594), a)

def comp.b824.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n2(U32.is_lt(a, 61), a)
    case False{}:
      comp.b824.n6(U32.is_lt(a, 8593), a)

def comp.b824.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8622}
    case False{}:
      None{}

def comp.b824.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8653}
    case False{}:
      None{}

def comp.b824.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n8(U32.is_lt(a, 8597), a)
    case False{}:
      comp.b824.n9(U32.is_lt(a, 8657), a)

def comp.b824.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8655}
    case False{}:
      None{}

def comp.b824.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8708}

def comp.b824.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8654}
    case False{}:
      comp.b824.n12(U32.is_lt(a, 8707), a)

def comp.b824.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n11(U32.is_lt(a, 8659), a)
    case False{}:
      comp.b824.n13(U32.is_lt(a, 8661), a)

def comp.b824.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n10(U32.is_lt(a, 8656), a)
    case False{}:
      comp.b824.n14(U32.is_lt(a, 8660), a)

def comp.b824.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n7(U32.is_lt(a, 63), a)
    case False{}:
      comp.b824.n15(U32.is_lt(a, 8658), a)

def comp.b824.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8713}

def comp.b824.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8716}

def comp.b824.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n17(U32.is_lt(a, 8712), a)
    case False{}:
      comp.b824.n18(U32.is_lt(a, 8715), a)

def comp.b824.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8740}

def comp.b824.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8742}
    case False{}:
      None{}

def comp.b824.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n21(U32.is_lt(a, 8742), a)

def comp.b824.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n20(U32.is_lt(a, 8739), a)
    case False{}:
      comp.b824.n22(U32.is_lt(a, 8741), a)

def comp.b824.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n19(U32.is_lt(a, 8713), a)
    case False{}:
      comp.b824.n23(U32.is_lt(a, 8740), a)

def comp.b824.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8769}
    case False{}:
      None{}

def comp.b824.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8775}

def comp.b824.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8772}
    case False{}:
      comp.b824.n26(U32.is_lt(a, 8773), a)

def comp.b824.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n25(U32.is_lt(a, 8765), a)
    case False{}:
      comp.b824.n27(U32.is_lt(a, 8772), a)

def comp.b824.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8777}

def comp.b824.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8813}
    case False{}:
      None{}

def comp.b824.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n30(U32.is_lt(a, 8782), a)

def comp.b824.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n29(U32.is_lt(a, 8776), a)
    case False{}:
      comp.b824.n31(U32.is_lt(a, 8781), a)

def comp.b824.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n28(U32.is_lt(a, 8771), a)
    case False{}:
      comp.b824.n32(U32.is_lt(a, 8777), a)

def comp.b824.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n24(U32.is_lt(a, 8716), a)
    case False{}:
      comp.b824.n33(U32.is_lt(a, 8774), a)

def comp.b824.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n16(U32.is_lt(a, 8596), a)
    case False{}:
      comp.b824.n34(U32.is_lt(a, 8764), a)

def comp.b824.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8802}
    case False{}:
      None{}

def comp.b824.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8816}
    case False{}:
      Some{8817}

def comp.b824.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n36(U32.is_lt(a, 8802), a)
    case False{}:
      comp.b824.n37(U32.is_lt(a, 8805), a)

def comp.b824.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8820}

def comp.b824.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8824}

def comp.b824.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8821}
    case False{}:
      comp.b824.n40(U32.is_lt(a, 8822), a)

def comp.b824.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n39(U32.is_lt(a, 8818), a)
    case False{}:
      comp.b824.n41(U32.is_lt(a, 8820), a)

def comp.b824.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n38(U32.is_lt(a, 8804), a)
    case False{}:
      comp.b824.n42(U32.is_lt(a, 8819), a)

def comp.b824.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8825}
    case False{}:
      None{}

def comp.b824.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8832}
    case False{}:
      Some{8833}

def comp.b824.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n44(U32.is_lt(a, 8824), a)
    case False{}:
      comp.b824.n45(U32.is_lt(a, 8827), a)

def comp.b824.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8928}
    case False{}:
      Some{8929}

def comp.b824.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8836}
    case False{}:
      Some{8837}

def comp.b824.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n48(U32.is_lt(a, 8835), a)

def comp.b824.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n47(U32.is_lt(a, 8829), a)
    case False{}:
      comp.b824.n49(U32.is_lt(a, 8834), a)

def comp.b824.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n46(U32.is_lt(a, 8826), a)
    case False{}:
      comp.b824.n50(U32.is_lt(a, 8830), a)

def comp.b824.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n43(U32.is_lt(a, 8806), a)
    case False{}:
      comp.b824.n51(U32.is_lt(a, 8828), a)

def comp.b824.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8840}

def comp.b824.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8841}
    case False{}:
      None{}

def comp.b824.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n53(U32.is_lt(a, 8838), a)
    case False{}:
      comp.b824.n54(U32.is_lt(a, 8840), a)

def comp.b824.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8930}
    case False{}:
      Some{8931}

def comp.b824.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8876}
    case False{}:
      None{}

def comp.b824.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n57(U32.is_lt(a, 8867), a)

def comp.b824.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n56(U32.is_lt(a, 8850), a)
    case False{}:
      comp.b824.n58(U32.is_lt(a, 8866), a)

def comp.b824.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n55(U32.is_lt(a, 8839), a)
    case False{}:
      comp.b824.n59(U32.is_lt(a, 8851), a)

def comp.b824.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8877}
    case False{}:
      Some{8878}

def comp.b824.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8879}
    case False{}:
      None{}

def comp.b824.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b824.n62(U32.is_lt(a, 8876), a)

def comp.b824.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n61(U32.is_lt(a, 8873), a)
    case False{}:
      comp.b824.n63(U32.is_lt(a, 8875), a)

def comp.b824.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8938}
    case False{}:
      Some{8939}

def comp.b824.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8941}
    case False{}:
      None{}

def comp.b824.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8940}
    case False{}:
      comp.b824.n66(U32.is_lt(a, 8886), a)

def comp.b824.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n65(U32.is_lt(a, 8883), a)
    case False{}:
      comp.b824.n67(U32.is_lt(a, 8885), a)

def comp.b824.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n64(U32.is_lt(a, 8874), a)
    case False{}:
      comp.b824.n68(U32.is_lt(a, 8884), a)

def comp.b824.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n60(U32.is_lt(a, 8849), a)
    case False{}:
      comp.b824.n69(U32.is_lt(a, 8882), a)

def comp.b824.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n52(U32.is_lt(a, 8823), a)
    case False{}:
      comp.b824.n70(U32.is_lt(a, 8872), a)

def comp.b824.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824.n35(U32.is_lt(a, 8708), a)
    case False{}:
      comp.b824.n71(U32.is_lt(a, 8836), a)

def comp.b824(+a: U32) -> Maybe<&2, U32>:
  comp.b824.n72(U32.is_lt(a, 8801), a)

def comp.b834.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8129}
    case False{}:
      None{}

def comp.b834.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b834.n0(U32.is_lt(a, 169), a)

def comp.b834.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8134}

def comp.b834.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8118}
    case False{}:
      comp.b834.n2(U32.is_lt(a, 951), a)

def comp.b834.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n1(U32.is_lt(a, 168), a)
    case False{}:
      comp.b834.n3(U32.is_lt(a, 946), a)

def comp.b834.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8150}
    case False{}:
      None{}

def comp.b834.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b834.n5(U32.is_lt(a, 954), a)

def comp.b834.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8182}

def comp.b834.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8166}
    case False{}:
      comp.b834.n7(U32.is_lt(a, 969), a)

def comp.b834.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n6(U32.is_lt(a, 953), a)
    case False{}:
      comp.b834.n8(U32.is_lt(a, 966), a)

def comp.b834.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n4(U32.is_lt(a, 945), a)
    case False{}:
      comp.b834.n9(U32.is_lt(a, 965), a)

def comp.b834.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8167}
    case False{}:
      None{}

def comp.b834.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8151}
    case False{}:
      comp.b834.n11(U32.is_lt(a, 972), a)

def comp.b834.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7943}
    case False{}:
      None{}

def comp.b834.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7942}
    case False{}:
      comp.b834.n13(U32.is_lt(a, 7938), a)

def comp.b834.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n12(U32.is_lt(a, 971), a)
    case False{}:
      comp.b834.n14(U32.is_lt(a, 7937), a)

def comp.b834.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7951}
    case False{}:
      None{}

def comp.b834.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7950}
    case False{}:
      comp.b834.n16(U32.is_lt(a, 7946), a)

def comp.b834.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7975}
    case False{}:
      None{}

def comp.b834.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7974}
    case False{}:
      comp.b834.n18(U32.is_lt(a, 7970), a)

def comp.b834.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n17(U32.is_lt(a, 7945), a)
    case False{}:
      comp.b834.n19(U32.is_lt(a, 7969), a)

def comp.b834.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n15(U32.is_lt(a, 7936), a)
    case False{}:
      comp.b834.n20(U32.is_lt(a, 7968), a)

def comp.b834.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n10(U32.is_lt(a, 952), a)
    case False{}:
      comp.b834.n21(U32.is_lt(a, 7944), a)

def comp.b834.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7983}
    case False{}:
      None{}

def comp.b834.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7982}
    case False{}:
      comp.b834.n23(U32.is_lt(a, 7978), a)

def comp.b834.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7991}
    case False{}:
      None{}

def comp.b834.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7990}
    case False{}:
      comp.b834.n25(U32.is_lt(a, 7986), a)

def comp.b834.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n24(U32.is_lt(a, 7977), a)
    case False{}:
      comp.b834.n26(U32.is_lt(a, 7985), a)

def comp.b834.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7999}
    case False{}:
      None{}

def comp.b834.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{7998}
    case False{}:
      comp.b834.n28(U32.is_lt(a, 7994), a)

def comp.b834.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8023}
    case False{}:
      None{}

def comp.b834.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8022}
    case False{}:
      comp.b834.n30(U32.is_lt(a, 8018), a)

def comp.b834.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n29(U32.is_lt(a, 7993), a)
    case False{}:
      comp.b834.n31(U32.is_lt(a, 8017), a)

def comp.b834.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n27(U32.is_lt(a, 7984), a)
    case False{}:
      comp.b834.n32(U32.is_lt(a, 8016), a)

def comp.b834.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8038}

def comp.b834.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8031}
    case False{}:
      comp.b834.n34(U32.is_lt(a, 8032), a)

def comp.b834.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8046}

def comp.b834.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8039}
    case False{}:
      comp.b834.n36(U32.is_lt(a, 8040), a)

def comp.b834.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n35(U32.is_lt(a, 8026), a)
    case False{}:
      comp.b834.n37(U32.is_lt(a, 8034), a)

def comp.b834.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8143}

def comp.b834.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8047}
    case False{}:
      comp.b834.n39(U32.is_lt(a, 8127), a)

def comp.b834.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8159}
    case False{}:
      None{}

def comp.b834.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b834.n41(U32.is_lt(a, 8191), a)

def comp.b834.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n40(U32.is_lt(a, 8042), a)
    case False{}:
      comp.b834.n42(U32.is_lt(a, 8190), a)

def comp.b834.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n38(U32.is_lt(a, 8033), a)
    case False{}:
      comp.b834.n43(U32.is_lt(a, 8128), a)

def comp.b834.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n33(U32.is_lt(a, 7992), a)
    case False{}:
      comp.b834.n44(U32.is_lt(a, 8041), a)

def comp.b834.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834.n22(U32.is_lt(a, 970), a)
    case False{}:
      comp.b834.n45(U32.is_lt(a, 8025), a)

def comp.b834(+a: U32) -> Maybe<&2, U32>:
  comp.b834.n46(U32.is_lt(a, 7976), a)

def comp.b837.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8124}

def comp.b837.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8140}
    case False{}:
      None{}

def comp.b837.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b837.n1(U32.is_lt(a, 920), a)

def comp.b837.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n0(U32.is_lt(a, 913), a)
    case False{}:
      comp.b837.n2(U32.is_lt(a, 919), a)

def comp.b837.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8188}
    case False{}:
      None{}

def comp.b837.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8132}

def comp.b837.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8116}
    case False{}:
      comp.b837.n5(U32.is_lt(a, 942), a)

def comp.b837.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n4(U32.is_lt(a, 938), a)
    case False{}:
      comp.b837.n6(U32.is_lt(a, 941), a)

def comp.b837.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n3(U32.is_lt(a, 914), a)
    case False{}:
      comp.b837.n7(U32.is_lt(a, 940), a)

def comp.b837.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8115}

def comp.b837.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8131}
    case False{}:
      None{}

def comp.b837.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b837.n10(U32.is_lt(a, 952), a)

def comp.b837.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n9(U32.is_lt(a, 945), a)
    case False{}:
      comp.b837.n11(U32.is_lt(a, 951), a)

def comp.b837.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8179}
    case False{}:
      None{}

def comp.b837.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8064}

def comp.b837.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8180}
    case False{}:
      comp.b837.n14(U32.is_lt(a, 7936), a)

def comp.b837.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n13(U32.is_lt(a, 970), a)
    case False{}:
      comp.b837.n15(U32.is_lt(a, 975), a)

def comp.b837.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n12(U32.is_lt(a, 946), a)
    case False{}:
      comp.b837.n16(U32.is_lt(a, 974), a)

def comp.b837.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n8(U32.is_lt(a, 937), a)
    case False{}:
      comp.b837.n17(U32.is_lt(a, 969), a)

def comp.b837.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8065}
    case False{}:
      Some{8066}

def comp.b837.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8068}
    case False{}:
      Some{8069}

def comp.b837.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8067}
    case False{}:
      comp.b837.n20(U32.is_lt(a, 7941), a)

def comp.b837.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n19(U32.is_lt(a, 7938), a)
    case False{}:
      comp.b837.n21(U32.is_lt(a, 7940), a)

def comp.b837.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8070}
    case False{}:
      Some{8071}

def comp.b837.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8073}
    case False{}:
      Some{8074}

def comp.b837.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8072}
    case False{}:
      comp.b837.n24(U32.is_lt(a, 7946), a)

def comp.b837.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n23(U32.is_lt(a, 7943), a)
    case False{}:
      comp.b837.n25(U32.is_lt(a, 7945), a)

def comp.b837.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n22(U32.is_lt(a, 7939), a)
    case False{}:
      comp.b837.n26(U32.is_lt(a, 7944), a)

def comp.b837.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8075}
    case False{}:
      Some{8076}

def comp.b837.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8078}
    case False{}:
      Some{8079}

def comp.b837.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8077}
    case False{}:
      comp.b837.n29(U32.is_lt(a, 7951), a)

def comp.b837.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n28(U32.is_lt(a, 7948), a)
    case False{}:
      comp.b837.n30(U32.is_lt(a, 7950), a)

def comp.b837.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8080}

def comp.b837.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8082}
    case False{}:
      Some{8083}

def comp.b837.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8081}
    case False{}:
      comp.b837.n33(U32.is_lt(a, 7971), a)

def comp.b837.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n32(U32.is_lt(a, 7968), a)
    case False{}:
      comp.b837.n34(U32.is_lt(a, 7970), a)

def comp.b837.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n31(U32.is_lt(a, 7949), a)
    case False{}:
      comp.b837.n35(U32.is_lt(a, 7969), a)

def comp.b837.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n27(U32.is_lt(a, 7942), a)
    case False{}:
      comp.b837.n36(U32.is_lt(a, 7952), a)

def comp.b837.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n18(U32.is_lt(a, 943), a)
    case False{}:
      comp.b837.n37(U32.is_lt(a, 7947), a)

def comp.b837.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8084}
    case False{}:
      Some{8085}

def comp.b837.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8087}
    case False{}:
      Some{8088}

def comp.b837.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8086}
    case False{}:
      comp.b837.n40(U32.is_lt(a, 7976), a)

def comp.b837.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n39(U32.is_lt(a, 7973), a)
    case False{}:
      comp.b837.n41(U32.is_lt(a, 7975), a)

def comp.b837.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8089}
    case False{}:
      Some{8090}

def comp.b837.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8092}
    case False{}:
      Some{8093}

def comp.b837.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8091}
    case False{}:
      comp.b837.n44(U32.is_lt(a, 7981), a)

def comp.b837.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n43(U32.is_lt(a, 7978), a)
    case False{}:
      comp.b837.n45(U32.is_lt(a, 7980), a)

def comp.b837.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n42(U32.is_lt(a, 7974), a)
    case False{}:
      comp.b837.n46(U32.is_lt(a, 7979), a)

def comp.b837.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8094}
    case False{}:
      Some{8095}

def comp.b837.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8096}
    case False{}:
      Some{8097}

def comp.b837.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b837.n49(U32.is_lt(a, 8033), a)

def comp.b837.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n48(U32.is_lt(a, 7983), a)
    case False{}:
      comp.b837.n50(U32.is_lt(a, 8032), a)

def comp.b837.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8098}
    case False{}:
      Some{8099}

def comp.b837.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8101}
    case False{}:
      Some{8102}

def comp.b837.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8100}
    case False{}:
      comp.b837.n53(U32.is_lt(a, 8038), a)

def comp.b837.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n52(U32.is_lt(a, 8035), a)
    case False{}:
      comp.b837.n54(U32.is_lt(a, 8037), a)

def comp.b837.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n51(U32.is_lt(a, 7984), a)
    case False{}:
      comp.b837.n55(U32.is_lt(a, 8036), a)

def comp.b837.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n47(U32.is_lt(a, 7977), a)
    case False{}:
      comp.b837.n56(U32.is_lt(a, 8034), a)

def comp.b837.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8103}
    case False{}:
      Some{8104}

def comp.b837.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8106}
    case False{}:
      Some{8107}

def comp.b837.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8105}
    case False{}:
      comp.b837.n59(U32.is_lt(a, 8043), a)

def comp.b837.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n58(U32.is_lt(a, 8040), a)
    case False{}:
      comp.b837.n60(U32.is_lt(a, 8042), a)

def comp.b837.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8108}
    case False{}:
      Some{8109}

def comp.b837.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8111}
    case False{}:
      Some{8114}

def comp.b837.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8110}
    case False{}:
      comp.b837.n63(U32.is_lt(a, 8048), a)

def comp.b837.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n62(U32.is_lt(a, 8045), a)
    case False{}:
      comp.b837.n64(U32.is_lt(a, 8047), a)

def comp.b837.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n61(U32.is_lt(a, 8041), a)
    case False{}:
      comp.b837.n65(U32.is_lt(a, 8046), a)

def comp.b837.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8130}

def comp.b837.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8178}
    case False{}:
      None{}

def comp.b837.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b837.n68(U32.is_lt(a, 8061), a)

def comp.b837.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n67(U32.is_lt(a, 8052), a)
    case False{}:
      comp.b837.n69(U32.is_lt(a, 8060), a)

def comp.b837.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{8135}

def comp.b837.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8119}
    case False{}:
      comp.b837.n71(U32.is_lt(a, 8134), a)

def comp.b837.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{8183}
    case False{}:
      None{}

def comp.b837.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b837.n73(U32.is_lt(a, 8183), a)

def comp.b837.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n72(U32.is_lt(a, 8119), a)
    case False{}:
      comp.b837.n74(U32.is_lt(a, 8182), a)

def comp.b837.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n70(U32.is_lt(a, 8053), a)
    case False{}:
      comp.b837.n75(U32.is_lt(a, 8135), a)

def comp.b837.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n66(U32.is_lt(a, 8044), a)
    case False{}:
      comp.b837.n76(U32.is_lt(a, 8118), a)

def comp.b837.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n57(U32.is_lt(a, 7982), a)
    case False{}:
      comp.b837.n77(U32.is_lt(a, 8049), a)

def comp.b837.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837.n38(U32.is_lt(a, 7937), a)
    case False{}:
      comp.b837.n78(U32.is_lt(a, 8039), a)

def comp.b837(+a: U32) -> Maybe<&2, U32>:
  comp.b837.n79(U32.is_lt(a, 7972), a)

def comp.b1619.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1570}
    case False{}:
      None{}

def comp.b1619.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b1619.n0(U32.is_lt(a, 1576), a)

def comp.b1619(+a: U32) -> Maybe<&2, U32>:
  comp.b1619.n1(U32.is_lt(a, 1575), a)

def comp.b1620.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1571}
    case False{}:
      None{}

def comp.b1620.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b1620.n0(U32.is_lt(a, 1576), a)

def comp.b1620.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{1574}

def comp.b1620.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1572}
    case False{}:
      comp.b1620.n2(U32.is_lt(a, 1610), a)

def comp.b1620.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1620.n1(U32.is_lt(a, 1575), a)
    case False{}:
      comp.b1620.n3(U32.is_lt(a, 1609), a)

def comp.b1620.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1730}
    case False{}:
      None{}

def comp.b1620.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b1620.n5(U32.is_lt(a, 1730), a)

def comp.b1620.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1747}
    case False{}:
      None{}

def comp.b1620.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1728}
    case False{}:
      None{}

def comp.b1620.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1620.n7(U32.is_lt(a, 1747), a)
    case False{}:
      comp.b1620.n8(U32.is_lt(a, 1750), a)

def comp.b1620.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1620.n6(U32.is_lt(a, 1729), a)
    case False{}:
      comp.b1620.n9(U32.is_lt(a, 1749), a)

def comp.b1620.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1620.n4(U32.is_lt(a, 1608), a)
    case False{}:
      comp.b1620.n10(U32.is_lt(a, 1746), a)

def comp.b1620(+a: U32) -> Maybe<&2, U32>:
  comp.b1620.n11(U32.is_lt(a, 1611), a)

def comp.b1621.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{1573}
    case False{}:
      None{}

def comp.b1621.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b1621.n0(U32.is_lt(a, 1576), a)

def comp.b1621(+a: U32) -> Maybe<&2, U32>:
  comp.b1621.n1(U32.is_lt(a, 1575), a)

def comp.b2364.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2345}
    case False{}:
      None{}

def comp.b2364.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2364.n0(U32.is_lt(a, 2345), a)

def comp.b2364.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2353}
    case False{}:
      None{}

def comp.b2364.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2356}
    case False{}:
      None{}

def comp.b2364.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b2364.n2(U32.is_lt(a, 2353), a)
    case False{}:
      comp.b2364.n3(U32.is_lt(a, 2356), a)

def comp.b2364.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b2364.n1(U32.is_lt(a, 2344), a)
    case False{}:
      comp.b2364.n4(U32.is_lt(a, 2355), a)

def comp.b2364(+a: U32) -> Maybe<&2, U32>:
  comp.b2364.n5(U32.is_lt(a, 2352), a)

def comp.b2494.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2507}
    case False{}:
      None{}

def comp.b2494.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2494.n0(U32.is_lt(a, 2504), a)

def comp.b2494(+a: U32) -> Maybe<&2, U32>:
  comp.b2494.n1(U32.is_lt(a, 2503), a)

def comp.b2519.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2508}
    case False{}:
      None{}

def comp.b2519.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2519.n0(U32.is_lt(a, 2504), a)

def comp.b2519(+a: U32) -> Maybe<&2, U32>:
  comp.b2519.n1(U32.is_lt(a, 2503), a)

def comp.b2878.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2891}
    case False{}:
      None{}

def comp.b2878.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2878.n0(U32.is_lt(a, 2888), a)

def comp.b2878(+a: U32) -> Maybe<&2, U32>:
  comp.b2878.n1(U32.is_lt(a, 2887), a)

def comp.b2902.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2888}
    case False{}:
      None{}

def comp.b2902.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2902.n0(U32.is_lt(a, 2888), a)

def comp.b2902(+a: U32) -> Maybe<&2, U32>:
  comp.b2902.n1(U32.is_lt(a, 2887), a)

def comp.b2903.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{2892}
    case False{}:
      None{}

def comp.b2903.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2903.n0(U32.is_lt(a, 2888), a)

def comp.b2903(+a: U32) -> Maybe<&2, U32>:
  comp.b2903.n1(U32.is_lt(a, 2887), a)

def comp.b3006.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{3018}

def comp.b3006.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3019}
    case False{}:
      None{}

def comp.b3006.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3006.n0(U32.is_lt(a, 3014), a)
    case False{}:
      comp.b3006.n1(U32.is_lt(a, 3016), a)

def comp.b3006(+a: U32) -> Maybe<&2, U32>:
  comp.b3006.n2(U32.is_lt(a, 3015), a)

def comp.b3031.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{2964}

def comp.b3031.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3020}
    case False{}:
      None{}

def comp.b3031.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3031.n1(U32.is_lt(a, 3015), a)

def comp.b3031.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3031.n0(U32.is_lt(a, 2962), a)
    case False{}:
      comp.b3031.n2(U32.is_lt(a, 3014), a)

def comp.b3031(+a: U32) -> Maybe<&2, U32>:
  comp.b3031.n3(U32.is_lt(a, 2963), a)

def comp.b3158.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3144}
    case False{}:
      None{}

def comp.b3158.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3158.n0(U32.is_lt(a, 3143), a)

def comp.b3158(+a: U32) -> Maybe<&2, U32>:
  comp.b3158.n1(U32.is_lt(a, 3142), a)

def comp.b3266.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3274}
    case False{}:
      None{}

def comp.b3266.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3266.n0(U32.is_lt(a, 3271), a)

def comp.b3266(+a: U32) -> Maybe<&2, U32>:
  comp.b3266.n1(U32.is_lt(a, 3270), a)

def comp.b3285.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3264}
    case False{}:
      None{}

def comp.b3285.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3285.n0(U32.is_lt(a, 3264), a)

def comp.b3285.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3271}
    case False{}:
      None{}

def comp.b3285.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3275}
    case False{}:
      None{}

def comp.b3285.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3285.n2(U32.is_lt(a, 3271), a)
    case False{}:
      comp.b3285.n3(U32.is_lt(a, 3275), a)

def comp.b3285.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3285.n1(U32.is_lt(a, 3263), a)
    case False{}:
      comp.b3285.n4(U32.is_lt(a, 3274), a)

def comp.b3285(+a: U32) -> Maybe<&2, U32>:
  comp.b3285.n5(U32.is_lt(a, 3270), a)

def comp.b3286.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3272}
    case False{}:
      None{}

def comp.b3286.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3286.n0(U32.is_lt(a, 3271), a)

def comp.b3286(+a: U32) -> Maybe<&2, U32>:
  comp.b3286.n1(U32.is_lt(a, 3270), a)

def comp.b3390.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{3402}

def comp.b3390.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3403}
    case False{}:
      None{}

def comp.b3390.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3390.n0(U32.is_lt(a, 3398), a)
    case False{}:
      comp.b3390.n1(U32.is_lt(a, 3400), a)

def comp.b3390(+a: U32) -> Maybe<&2, U32>:
  comp.b3390.n2(U32.is_lt(a, 3399), a)

def comp.b3415.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3404}
    case False{}:
      None{}

def comp.b3415.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3415.n0(U32.is_lt(a, 3399), a)

def comp.b3415(+a: U32) -> Maybe<&2, U32>:
  comp.b3415.n1(U32.is_lt(a, 3398), a)

def comp.b3530.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{3546}

def comp.b3530.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3549}
    case False{}:
      None{}

def comp.b3530.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3530.n1(U32.is_lt(a, 3549), a)

def comp.b3530.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3530.n0(U32.is_lt(a, 3545), a)
    case False{}:
      comp.b3530.n2(U32.is_lt(a, 3548), a)

def comp.b3530(+a: U32) -> Maybe<&2, U32>:
  comp.b3530.n3(U32.is_lt(a, 3546), a)

def comp.b3535.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3548}
    case False{}:
      None{}

def comp.b3535.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3535.n0(U32.is_lt(a, 3546), a)

def comp.b3535(+a: U32) -> Maybe<&2, U32>:
  comp.b3535.n1(U32.is_lt(a, 3545), a)

def comp.b3551.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{3550}
    case False{}:
      None{}

def comp.b3551.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3551.n0(U32.is_lt(a, 3546), a)

def comp.b3551(+a: U32) -> Maybe<&2, U32>:
  comp.b3551.n1(U32.is_lt(a, 3545), a)

def comp.b4142.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{4134}
    case False{}:
      None{}

def comp.b4142.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b4142.n0(U32.is_lt(a, 4134), a)

def comp.b4142(+a: U32) -> Maybe<&2, U32>:
  comp.b4142.n1(U32.is_lt(a, 4133), a)

def comp.b6965.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{6918}

def comp.b6965.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6920}
    case False{}:
      None{}

def comp.b6965.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b6965.n1(U32.is_lt(a, 6920), a)

def comp.b6965.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n0(U32.is_lt(a, 6917), a)
    case False{}:
      comp.b6965.n2(U32.is_lt(a, 6919), a)

def comp.b6965.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{6924}

def comp.b6965.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6922}
    case False{}:
      comp.b6965.n4(U32.is_lt(a, 6923), a)

def comp.b6965.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6926}
    case False{}:
      None{}

def comp.b6965.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b6965.n6(U32.is_lt(a, 6926), a)

def comp.b6965.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n5(U32.is_lt(a, 6922), a)
    case False{}:
      comp.b6965.n7(U32.is_lt(a, 6925), a)

def comp.b6965.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n3(U32.is_lt(a, 6918), a)
    case False{}:
      comp.b6965.n8(U32.is_lt(a, 6924), a)

def comp.b6965.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6930}
    case False{}:
      None{}

def comp.b6965.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{6973}

def comp.b6965.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6971}
    case False{}:
      comp.b6965.n11(U32.is_lt(a, 6972), a)

def comp.b6965.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n10(U32.is_lt(a, 6930), a)
    case False{}:
      comp.b6965.n12(U32.is_lt(a, 6971), a)

def comp.b6965.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6976}
    case False{}:
      Some{6977}

def comp.b6965.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b6965.n14(U32.is_lt(a, 6975), a)

def comp.b6965.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{6979}
    case False{}:
      None{}

def comp.b6965.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b6965.n16(U32.is_lt(a, 6979), a)

def comp.b6965.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n15(U32.is_lt(a, 6974), a)
    case False{}:
      comp.b6965.n17(U32.is_lt(a, 6978), a)

def comp.b6965.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n13(U32.is_lt(a, 6970), a)
    case False{}:
      comp.b6965.n18(U32.is_lt(a, 6976), a)

def comp.b6965.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b6965.n9(U32.is_lt(a, 6921), a)
    case False{}:
      comp.b6965.n19(U32.is_lt(a, 6973), a)

def comp.b6965(+a: U32) -> Maybe<&2, U32>:
  comp.b6965.n20(U32.is_lt(a, 6929), a)

def comp.b12441.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12436}

def comp.b12441.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12364}
    case False{}:
      None{}

def comp.b12441.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n1(U32.is_lt(a, 12364), a)

def comp.b12441.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n0(U32.is_lt(a, 12358), a)
    case False{}:
      comp.b12441.n2(U32.is_lt(a, 12363), a)

def comp.b12441.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12368}

def comp.b12441.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12366}
    case False{}:
      comp.b12441.n4(U32.is_lt(a, 12367), a)

def comp.b12441.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12370}
    case False{}:
      None{}

def comp.b12441.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n6(U32.is_lt(a, 12370), a)

def comp.b12441.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n5(U32.is_lt(a, 12366), a)
    case False{}:
      comp.b12441.n7(U32.is_lt(a, 12369), a)

def comp.b12441.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n3(U32.is_lt(a, 12359), a)
    case False{}:
      comp.b12441.n8(U32.is_lt(a, 12368), a)

def comp.b12441.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12374}

def comp.b12441.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12372}
    case False{}:
      comp.b12441.n10(U32.is_lt(a, 12373), a)

def comp.b12441.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12376}
    case False{}:
      None{}

def comp.b12441.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n12(U32.is_lt(a, 12376), a)

def comp.b12441.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n11(U32.is_lt(a, 12372), a)
    case False{}:
      comp.b12441.n13(U32.is_lt(a, 12375), a)

def comp.b12441.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12380}

def comp.b12441.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12378}
    case False{}:
      comp.b12441.n15(U32.is_lt(a, 12379), a)

def comp.b12441.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12382}
    case False{}:
      None{}

def comp.b12441.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n17(U32.is_lt(a, 12382), a)

def comp.b12441.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n16(U32.is_lt(a, 12378), a)
    case False{}:
      comp.b12441.n18(U32.is_lt(a, 12381), a)

def comp.b12441.n20(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n14(U32.is_lt(a, 12374), a)
    case False{}:
      comp.b12441.n19(U32.is_lt(a, 12380), a)

def comp.b12441.n21(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n9(U32.is_lt(a, 12365), a)
    case False{}:
      comp.b12441.n20(U32.is_lt(a, 12377), a)

def comp.b12441.n22(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12386}

def comp.b12441.n23(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12384}
    case False{}:
      comp.b12441.n22(U32.is_lt(a, 12385), a)

def comp.b12441.n24(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12389}
    case False{}:
      None{}

def comp.b12441.n25(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n24(U32.is_lt(a, 12389), a)

def comp.b12441.n26(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n23(U32.is_lt(a, 12384), a)
    case False{}:
      comp.b12441.n25(U32.is_lt(a, 12388), a)

def comp.b12441.n27(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12393}

def comp.b12441.n28(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12391}
    case False{}:
      comp.b12441.n27(U32.is_lt(a, 12392), a)

def comp.b12441.n29(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12400}
    case False{}:
      None{}

def comp.b12441.n30(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n29(U32.is_lt(a, 12400), a)

def comp.b12441.n31(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n28(U32.is_lt(a, 12391), a)
    case False{}:
      comp.b12441.n30(U32.is_lt(a, 12399), a)

def comp.b12441.n32(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n26(U32.is_lt(a, 12386), a)
    case False{}:
      comp.b12441.n31(U32.is_lt(a, 12393), a)

def comp.b12441.n33(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12406}

def comp.b12441.n34(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12403}
    case False{}:
      comp.b12441.n33(U32.is_lt(a, 12405), a)

def comp.b12441.n35(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12409}
    case False{}:
      None{}

def comp.b12441.n36(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n35(U32.is_lt(a, 12409), a)

def comp.b12441.n37(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n34(U32.is_lt(a, 12403), a)
    case False{}:
      comp.b12441.n36(U32.is_lt(a, 12408), a)

def comp.b12441.n38(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12446}

def comp.b12441.n39(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12412}
    case False{}:
      comp.b12441.n38(U32.is_lt(a, 12445), a)

def comp.b12441.n40(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12532}
    case False{}:
      None{}

def comp.b12441.n41(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n40(U32.is_lt(a, 12455), a)

def comp.b12441.n42(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n39(U32.is_lt(a, 12412), a)
    case False{}:
      comp.b12441.n41(U32.is_lt(a, 12454), a)

def comp.b12441.n43(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n37(U32.is_lt(a, 12406), a)
    case False{}:
      comp.b12441.n42(U32.is_lt(a, 12446), a)

def comp.b12441.n44(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n32(U32.is_lt(a, 12390), a)
    case False{}:
      comp.b12441.n43(U32.is_lt(a, 12411), a)

def comp.b12441.n45(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n21(U32.is_lt(a, 12371), a)
    case False{}:
      comp.b12441.n44(U32.is_lt(a, 12402), a)

def comp.b12441.n46(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12460}
    case False{}:
      None{}

def comp.b12441.n47(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12464}

def comp.b12441.n48(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12462}
    case False{}:
      comp.b12441.n47(U32.is_lt(a, 12463), a)

def comp.b12441.n49(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n46(U32.is_lt(a, 12460), a)
    case False{}:
      comp.b12441.n48(U32.is_lt(a, 12462), a)

def comp.b12441.n50(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12466}
    case False{}:
      None{}

def comp.b12441.n51(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n50(U32.is_lt(a, 12466), a)

def comp.b12441.n52(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12470}

def comp.b12441.n53(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12468}
    case False{}:
      comp.b12441.n52(U32.is_lt(a, 12469), a)

def comp.b12441.n54(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n51(U32.is_lt(a, 12465), a)
    case False{}:
      comp.b12441.n53(U32.is_lt(a, 12468), a)

def comp.b12441.n55(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n49(U32.is_lt(a, 12461), a)
    case False{}:
      comp.b12441.n54(U32.is_lt(a, 12467), a)

def comp.b12441.n56(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12472}
    case False{}:
      None{}

def comp.b12441.n57(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n56(U32.is_lt(a, 12472), a)

def comp.b12441.n58(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12476}

def comp.b12441.n59(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12474}
    case False{}:
      comp.b12441.n58(U32.is_lt(a, 12475), a)

def comp.b12441.n60(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n57(U32.is_lt(a, 12471), a)
    case False{}:
      comp.b12441.n59(U32.is_lt(a, 12474), a)

def comp.b12441.n61(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12478}
    case False{}:
      None{}

def comp.b12441.n62(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n61(U32.is_lt(a, 12478), a)

def comp.b12441.n63(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12482}

def comp.b12441.n64(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12480}
    case False{}:
      comp.b12441.n63(U32.is_lt(a, 12481), a)

def comp.b12441.n65(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n62(U32.is_lt(a, 12477), a)
    case False{}:
      comp.b12441.n64(U32.is_lt(a, 12480), a)

def comp.b12441.n66(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n60(U32.is_lt(a, 12473), a)
    case False{}:
      comp.b12441.n65(U32.is_lt(a, 12479), a)

def comp.b12441.n67(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n55(U32.is_lt(a, 12464), a)
    case False{}:
      comp.b12441.n66(U32.is_lt(a, 12476), a)

def comp.b12441.n68(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12485}
    case False{}:
      None{}

def comp.b12441.n69(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n68(U32.is_lt(a, 12485), a)

def comp.b12441.n70(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12489}

def comp.b12441.n71(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12487}
    case False{}:
      comp.b12441.n70(U32.is_lt(a, 12488), a)

def comp.b12441.n72(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n69(U32.is_lt(a, 12484), a)
    case False{}:
      comp.b12441.n71(U32.is_lt(a, 12487), a)

def comp.b12441.n73(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12496}
    case False{}:
      None{}

def comp.b12441.n74(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n73(U32.is_lt(a, 12496), a)

def comp.b12441.n75(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12502}

def comp.b12441.n76(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12499}
    case False{}:
      comp.b12441.n75(U32.is_lt(a, 12501), a)

def comp.b12441.n77(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n74(U32.is_lt(a, 12495), a)
    case False{}:
      comp.b12441.n76(U32.is_lt(a, 12499), a)

def comp.b12441.n78(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n72(U32.is_lt(a, 12486), a)
    case False{}:
      comp.b12441.n77(U32.is_lt(a, 12498), a)

def comp.b12441.n79(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12505}
    case False{}:
      None{}

def comp.b12441.n80(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n79(U32.is_lt(a, 12505), a)

def comp.b12441.n81(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12535}

def comp.b12441.n82(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12508}
    case False{}:
      comp.b12441.n81(U32.is_lt(a, 12527), a)

def comp.b12441.n83(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n80(U32.is_lt(a, 12504), a)
    case False{}:
      comp.b12441.n82(U32.is_lt(a, 12508), a)

def comp.b12441.n84(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12537}
    case False{}:
      Some{12538}

def comp.b12441.n85(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12536}
    case False{}:
      comp.b12441.n84(U32.is_lt(a, 12530), a)

def comp.b12441.n86(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12542}
    case False{}:
      None{}

def comp.b12441.n87(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441.n86(U32.is_lt(a, 12542), a)

def comp.b12441.n88(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n85(U32.is_lt(a, 12529), a)
    case False{}:
      comp.b12441.n87(U32.is_lt(a, 12541), a)

def comp.b12441.n89(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n83(U32.is_lt(a, 12507), a)
    case False{}:
      comp.b12441.n88(U32.is_lt(a, 12531), a)

def comp.b12441.n90(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n78(U32.is_lt(a, 12489), a)
    case False{}:
      comp.b12441.n89(U32.is_lt(a, 12528), a)

def comp.b12441.n91(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n67(U32.is_lt(a, 12470), a)
    case False{}:
      comp.b12441.n90(U32.is_lt(a, 12502), a)

def comp.b12441.n92(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12441.n45(U32.is_lt(a, 12383), a)
    case False{}:
      comp.b12441.n91(U32.is_lt(a, 12482), a)

def comp.b12441(+a: U32) -> Maybe<&2, U32>:
  comp.b12441.n92(U32.is_lt(a, 12459), a)

def comp.b12442.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12401}

def comp.b12442.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12404}
    case False{}:
      None{}

def comp.b12442.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12442.n1(U32.is_lt(a, 12403), a)

def comp.b12442.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n0(U32.is_lt(a, 12399), a)
    case False{}:
      comp.b12442.n2(U32.is_lt(a, 12402), a)

def comp.b12442.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12407}
    case False{}:
      None{}

def comp.b12442.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12413}

def comp.b12442.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12410}
    case False{}:
      comp.b12442.n5(U32.is_lt(a, 12411), a)

def comp.b12442.n7(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n4(U32.is_lt(a, 12406), a)
    case False{}:
      comp.b12442.n6(U32.is_lt(a, 12409), a)

def comp.b12442.n8(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n3(U32.is_lt(a, 12400), a)
    case False{}:
      comp.b12442.n7(U32.is_lt(a, 12408), a)

def comp.b12442.n9(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12497}

def comp.b12442.n10(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12500}
    case False{}:
      None{}

def comp.b12442.n11(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12442.n10(U32.is_lt(a, 12499), a)

def comp.b12442.n12(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n9(U32.is_lt(a, 12495), a)
    case False{}:
      comp.b12442.n11(U32.is_lt(a, 12498), a)

def comp.b12442.n13(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{12506}

def comp.b12442.n14(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12503}
    case False{}:
      comp.b12442.n13(U32.is_lt(a, 12504), a)

def comp.b12442.n15(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{12509}
    case False{}:
      None{}

def comp.b12442.n16(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12442.n15(U32.is_lt(a, 12508), a)

def comp.b12442.n17(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n14(U32.is_lt(a, 12502), a)
    case False{}:
      comp.b12442.n16(U32.is_lt(a, 12507), a)

def comp.b12442.n18(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n12(U32.is_lt(a, 12496), a)
    case False{}:
      comp.b12442.n17(U32.is_lt(a, 12505), a)

def comp.b12442.n19(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442.n8(U32.is_lt(a, 12405), a)
    case False{}:
      comp.b12442.n18(U32.is_lt(a, 12501), a)

def comp.b12442(+a: U32) -> Maybe<&2, U32>:
  comp.b12442.n19(U32.is_lt(a, 12412), a)

def comp.b69818.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{69786}
    case False{}:
      None{}

def comp.b69818.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b69818.n0(U32.is_lt(a, 69786), a)

def comp.b69818.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{69788}
    case False{}:
      None{}

def comp.b69818.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{69803}
    case False{}:
      None{}

def comp.b69818.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b69818.n2(U32.is_lt(a, 69788), a)
    case False{}:
      comp.b69818.n3(U32.is_lt(a, 69798), a)

def comp.b69818.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b69818.n1(U32.is_lt(a, 69785), a)
    case False{}:
      comp.b69818.n4(U32.is_lt(a, 69797), a)

def comp.b69818(+a: U32) -> Maybe<&2, U32>:
  comp.b69818.n5(U32.is_lt(a, 69787), a)

def comp.b69927.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{69934}

def comp.b69927.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{69935}
    case False{}:
      None{}

def comp.b69927.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b69927.n0(U32.is_lt(a, 69937), a)
    case False{}:
      comp.b69927.n1(U32.is_lt(a, 69939), a)

def comp.b69927(+a: U32) -> Maybe<&2, U32>:
  comp.b69927.n2(U32.is_lt(a, 69938), a)

def comp.b70462.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70475}
    case False{}:
      None{}

def comp.b70462.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70462.n0(U32.is_lt(a, 70472), a)

def comp.b70462(+a: U32) -> Maybe<&2, U32>:
  comp.b70462.n1(U32.is_lt(a, 70471), a)

def comp.b70487.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70476}
    case False{}:
      None{}

def comp.b70487.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70487.n0(U32.is_lt(a, 70472), a)

def comp.b70487(+a: U32) -> Maybe<&2, U32>:
  comp.b70487.n1(U32.is_lt(a, 70471), a)

def comp.b70584.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70599}
    case False{}:
      None{}

def comp.b70584.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70584.n0(U32.is_lt(a, 70595), a)

def comp.b70584(+a: U32) -> Maybe<&2, U32>:
  comp.b70584.n1(U32.is_lt(a, 70594), a)

def comp.b70587.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70533}
    case False{}:
      None{}

def comp.b70587.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70587.n0(U32.is_lt(a, 70533), a)

def comp.b70587(+a: U32) -> Maybe<&2, U32>:
  comp.b70587.n1(U32.is_lt(a, 70532), a)

def comp.b70594.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{70542}

def comp.b70594.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70597}
    case False{}:
      None{}

def comp.b70594.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70594.n1(U32.is_lt(a, 70595), a)

def comp.b70594.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b70594.n0(U32.is_lt(a, 70539), a)
    case False{}:
      comp.b70594.n2(U32.is_lt(a, 70594), a)

def comp.b70594(+a: U32) -> Maybe<&2, U32>:
  comp.b70594.n3(U32.is_lt(a, 70540), a)

def comp.b70601.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70531}
    case False{}:
      None{}

def comp.b70601.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70601.n0(U32.is_lt(a, 70531), a)

def comp.b70601.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70545}
    case False{}:
      None{}

def comp.b70601.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70600}
    case False{}:
      None{}

def comp.b70601.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b70601.n2(U32.is_lt(a, 70545), a)
    case False{}:
      comp.b70601.n3(U32.is_lt(a, 70595), a)

def comp.b70601.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b70601.n1(U32.is_lt(a, 70530), a)
    case False{}:
      comp.b70601.n4(U32.is_lt(a, 70594), a)

def comp.b70601(+a: U32) -> Maybe<&2, U32>:
  comp.b70601.n5(U32.is_lt(a, 70544), a)

def comp.b70832.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70844}
    case False{}:
      None{}

def comp.b70832.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70832.n0(U32.is_lt(a, 70842), a)

def comp.b70832(+a: U32) -> Maybe<&2, U32>:
  comp.b70832.n1(U32.is_lt(a, 70841), a)

def comp.b70842.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70843}
    case False{}:
      None{}

def comp.b70842.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70842.n0(U32.is_lt(a, 70842), a)

def comp.b70842(+a: U32) -> Maybe<&2, U32>:
  comp.b70842.n1(U32.is_lt(a, 70841), a)

def comp.b70845.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{70846}
    case False{}:
      None{}

def comp.b70845.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70845.n0(U32.is_lt(a, 70842), a)

def comp.b70845(+a: U32) -> Maybe<&2, U32>:
  comp.b70845.n1(U32.is_lt(a, 70841), a)

def comp.b71087.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{71098}

def comp.b71087.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{71099}
    case False{}:
      None{}

def comp.b71087.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b71087.n0(U32.is_lt(a, 71096), a)
    case False{}:
      comp.b71087.n1(U32.is_lt(a, 71098), a)

def comp.b71087(+a: U32) -> Maybe<&2, U32>:
  comp.b71087.n2(U32.is_lt(a, 71097), a)

def comp.b71984.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{71992}
    case False{}:
      None{}

def comp.b71984.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b71984.n0(U32.is_lt(a, 71990), a)

def comp.b71984(+a: U32) -> Maybe<&2, U32>:
  comp.b71984.n1(U32.is_lt(a, 71989), a)

def comp.b90398.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{90401}
    case False{}:
      None{}

def comp.b90398.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b90398.n0(U32.is_lt(a, 90399), a)

def comp.b90398(+a: U32) -> Maybe<&2, U32>:
  comp.b90398.n1(U32.is_lt(a, 90398), a)

def comp.b90399.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{90403}

def comp.b90399.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{90406}

def comp.b90399.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90399.n0(U32.is_lt(a, 90398), a)
    case False{}:
      comp.b90399.n1(U32.is_lt(a, 90401), a)

def comp.b90399.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{90407}
    case False{}:
      None{}

def comp.b90399.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{90404}
    case False{}:
      None{}

def comp.b90399.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90399.n3(U32.is_lt(a, 90403), a)
    case False{}:
      comp.b90399.n4(U32.is_lt(a, 90410), a)

def comp.b90399.n6(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90399.n2(U32.is_lt(a, 90399), a)
    case False{}:
      comp.b90399.n5(U32.is_lt(a, 90409), a)

def comp.b90399(+a: U32) -> Maybe<&2, U32>:
  comp.b90399.n6(U32.is_lt(a, 90402), a)

def comp.b90400.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      Some{90405}

def comp.b90400.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{90408}
    case False{}:
      None{}

def comp.b90400.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b90400.n1(U32.is_lt(a, 90402), a)

def comp.b90400.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90400.n0(U32.is_lt(a, 90398), a)
    case False{}:
      comp.b90400.n2(U32.is_lt(a, 90401), a)

def comp.b90400(+a: U32) -> Maybe<&2, U32>:
  comp.b90400.n3(U32.is_lt(a, 90399), a)

def comp.b90409.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{90402}
    case False{}:
      None{}

def comp.b90409.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b90409.n0(U32.is_lt(a, 90399), a)

def comp.b90409(+a: U32) -> Maybe<&2, U32>:
  comp.b90409.n1(U32.is_lt(a, 90398), a)

def comp.b93543.n0(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{93545}
    case False{}:
      None{}

def comp.b93543.n1(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b93543.n0(U32.is_lt(a, 93540), a)

def comp.b93543.n2(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{93544}
    case False{}:
      None{}

def comp.b93543.n3(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      Some{93546}
    case False{}:
      None{}

def comp.b93543.n4(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b93543.n2(U32.is_lt(a, 93544), a)
    case False{}:
      comp.b93543.n3(U32.is_lt(a, 93546), a)

def comp.b93543.n5(lt: Bool, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b93543.n1(U32.is_lt(a, 93539), a)
    case False{}:
      comp.b93543.n4(U32.is_lt(a, 93545), a)

def comp.b93543(+a: U32) -> Maybe<&2, U32>:
  comp.b93543.n5(U32.is_lt(a, 93543), a)

def comp.n0(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b768(a)
    case False{}:
      comp.b769(a)

def comp.n1(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.n0(U32.is_lt(b, 769), b, a)

def comp.n2(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b770(a)
    case False{}:
      comp.b771(a)

def comp.n3(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b772(a)
    case False{}:
      None{}

def comp.n4(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n2(U32.is_lt(b, 771), b, a)
    case False{}:
      comp.n3(U32.is_lt(b, 773), b, a)

def comp.n5(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n1(U32.is_lt(b, 768), b, a)
    case False{}:
      comp.n4(U32.is_lt(b, 772), b, a)

def comp.n6(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b774(a)
    case False{}:
      comp.b775(a)

def comp.n7(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b776(a)
    case False{}:
      comp.b777(a)

def comp.n8(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n6(U32.is_lt(b, 775), b, a)
    case False{}:
      comp.n7(U32.is_lt(b, 777), b, a)

def comp.n9(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b778(a)
    case False{}:
      comp.b779(a)

def comp.n10(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b780(a)
    case False{}:
      None{}

def comp.n11(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n9(U32.is_lt(b, 779), b, a)
    case False{}:
      comp.n10(U32.is_lt(b, 781), b, a)

def comp.n12(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n8(U32.is_lt(b, 776), b, a)
    case False{}:
      comp.n11(U32.is_lt(b, 780), b, a)

def comp.n13(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n5(U32.is_lt(b, 770), b, a)
    case False{}:
      comp.n12(U32.is_lt(b, 778), b, a)

def comp.n14(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b785(a)

def comp.n15(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b783(a)
    case False{}:
      comp.n14(U32.is_lt(b, 785), b, a)

def comp.n16(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b787(a)

def comp.n17(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b788(a)
    case False{}:
      None{}

def comp.n18(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n16(U32.is_lt(b, 787), b, a)
    case False{}:
      comp.n17(U32.is_lt(b, 789), b, a)

def comp.n19(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n15(U32.is_lt(b, 784), b, a)
    case False{}:
      comp.n18(U32.is_lt(b, 788), b, a)

def comp.n20(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b795(a)
    case False{}:
      None{}

def comp.n21(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b803(a)
    case False{}:
      comp.b804(a)

def comp.n22(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n20(U32.is_lt(b, 796), b, a)
    case False{}:
      comp.n21(U32.is_lt(b, 804), b, a)

def comp.n23(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b805(a)
    case False{}:
      comp.b806(a)

def comp.n24(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b807(a)
    case False{}:
      comp.b808(a)

def comp.n25(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n23(U32.is_lt(b, 806), b, a)
    case False{}:
      comp.n24(U32.is_lt(b, 808), b, a)

def comp.n26(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n22(U32.is_lt(b, 803), b, a)
    case False{}:
      comp.n25(U32.is_lt(b, 807), b, a)

def comp.n27(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n19(U32.is_lt(b, 786), b, a)
    case False{}:
      comp.n26(U32.is_lt(b, 805), b, a)

def comp.n28(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n13(U32.is_lt(b, 774), b, a)
    case False{}:
      comp.n27(U32.is_lt(b, 795), b, a)

def comp.n29(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b813(a)
    case False{}:
      comp.b814(a)

def comp.n30(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.n29(U32.is_lt(b, 814), b, a)

def comp.n31(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b816(a)

def comp.n32(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b817(a)
    case False{}:
      None{}

def comp.n33(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n31(U32.is_lt(b, 816), b, a)
    case False{}:
      comp.n32(U32.is_lt(b, 818), b, a)

def comp.n34(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n30(U32.is_lt(b, 813), b, a)
    case False{}:
      comp.n33(U32.is_lt(b, 817), b, a)

def comp.n35(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b824(a)
    case False{}:
      None{}

def comp.n36(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b834(a)
    case False{}:
      None{}

def comp.n37(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n35(U32.is_lt(b, 825), b, a)
    case False{}:
      comp.n36(U32.is_lt(b, 835), b, a)

def comp.n38(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b837(a)
    case False{}:
      None{}

def comp.n39(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1619(a)
    case False{}:
      comp.b1620(a)

def comp.n40(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n38(U32.is_lt(b, 838), b, a)
    case False{}:
      comp.n39(U32.is_lt(b, 1620), b, a)

def comp.n41(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n37(U32.is_lt(b, 834), b, a)
    case False{}:
      comp.n40(U32.is_lt(b, 1619), b, a)

def comp.n42(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n34(U32.is_lt(b, 815), b, a)
    case False{}:
      comp.n41(U32.is_lt(b, 837), b, a)

def comp.n43(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2364(a)

def comp.n44(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b1621(a)
    case False{}:
      comp.n43(U32.is_lt(b, 2364), b, a)

def comp.n45(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2494(a)

def comp.n46(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2519(a)

def comp.n47(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n45(U32.is_lt(b, 2494), b, a)
    case False{}:
      comp.n46(U32.is_lt(b, 2519), b, a)

def comp.n48(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n44(U32.is_lt(b, 1622), b, a)
    case False{}:
      comp.n47(U32.is_lt(b, 2495), b, a)

def comp.n49(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2878(a)

def comp.n50(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b2902(a)

def comp.n51(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n49(U32.is_lt(b, 2878), b, a)
    case False{}:
      comp.n50(U32.is_lt(b, 2902), b, a)

def comp.n52(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b2903(a)
    case False{}:
      None{}

def comp.n53(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3006(a)
    case False{}:
      None{}

def comp.n54(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n52(U32.is_lt(b, 2904), b, a)
    case False{}:
      comp.n53(U32.is_lt(b, 3007), b, a)

def comp.n55(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n51(U32.is_lt(b, 2879), b, a)
    case False{}:
      comp.n54(U32.is_lt(b, 3006), b, a)

def comp.n56(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n48(U32.is_lt(b, 2365), b, a)
    case False{}:
      comp.n55(U32.is_lt(b, 2903), b, a)

def comp.n57(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n42(U32.is_lt(b, 824), b, a)
    case False{}:
      comp.n56(U32.is_lt(b, 2520), b, a)

def comp.n58(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n28(U32.is_lt(b, 783), b, a)
    case False{}:
      comp.n57(U32.is_lt(b, 1621), b, a)

def comp.n59(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3158(a)

def comp.n60(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3031(a)
    case False{}:
      comp.n59(U32.is_lt(b, 3158), b, a)

def comp.n61(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3266(a)

def comp.n62(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3285(a)

def comp.n63(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n61(U32.is_lt(b, 3266), b, a)
    case False{}:
      comp.n62(U32.is_lt(b, 3285), b, a)

def comp.n64(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n60(U32.is_lt(b, 3032), b, a)
    case False{}:
      comp.n63(U32.is_lt(b, 3267), b, a)

def comp.n65(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3286(a)
    case False{}:
      None{}

def comp.n66(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3390(a)
    case False{}:
      None{}

def comp.n67(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n65(U32.is_lt(b, 3287), b, a)
    case False{}:
      comp.n66(U32.is_lt(b, 3391), b, a)

def comp.n68(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3415(a)
    case False{}:
      None{}

def comp.n69(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3530(a)
    case False{}:
      None{}

def comp.n70(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n68(U32.is_lt(b, 3416), b, a)
    case False{}:
      comp.n69(U32.is_lt(b, 3531), b, a)

def comp.n71(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n67(U32.is_lt(b, 3390), b, a)
    case False{}:
      comp.n70(U32.is_lt(b, 3530), b, a)

def comp.n72(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n64(U32.is_lt(b, 3159), b, a)
    case False{}:
      comp.n71(U32.is_lt(b, 3415), b, a)

def comp.n73(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b3551(a)

def comp.n74(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b3535(a)
    case False{}:
      comp.n73(U32.is_lt(b, 3551), b, a)

def comp.n75(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b4142(a)

def comp.n76(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b6965(a)

def comp.n77(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n75(U32.is_lt(b, 4142), b, a)
    case False{}:
      comp.n76(U32.is_lt(b, 6965), b, a)

def comp.n78(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n74(U32.is_lt(b, 3536), b, a)
    case False{}:
      comp.n77(U32.is_lt(b, 4143), b, a)

def comp.n79(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b12441(a)

def comp.n80(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b12442(a)
    case False{}:
      None{}

def comp.n81(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n79(U32.is_lt(b, 12441), b, a)
    case False{}:
      comp.n80(U32.is_lt(b, 12443), b, a)

def comp.n82(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b69818(a)
    case False{}:
      None{}

def comp.n83(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b69927(a)
    case False{}:
      None{}

def comp.n84(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n82(U32.is_lt(b, 69819), b, a)
    case False{}:
      comp.n83(U32.is_lt(b, 69928), b, a)

def comp.n85(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n81(U32.is_lt(b, 12442), b, a)
    case False{}:
      comp.n84(U32.is_lt(b, 69927), b, a)

def comp.n86(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n78(U32.is_lt(b, 3552), b, a)
    case False{}:
      comp.n85(U32.is_lt(b, 69818), b, a)

def comp.n87(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n72(U32.is_lt(b, 3286), b, a)
    case False{}:
      comp.n86(U32.is_lt(b, 6966), b, a)

def comp.n88(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70487(a)

def comp.n89(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b70462(a)
    case False{}:
      comp.n88(U32.is_lt(b, 70487), b, a)

def comp.n90(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70584(a)

def comp.n91(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70587(a)

def comp.n92(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n90(U32.is_lt(b, 70584), b, a)
    case False{}:
      comp.n91(U32.is_lt(b, 70587), b, a)

def comp.n93(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n89(U32.is_lt(b, 70463), b, a)
    case False{}:
      comp.n92(U32.is_lt(b, 70585), b, a)

def comp.n94(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70594(a)

def comp.n95(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70601(a)

def comp.n96(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n94(U32.is_lt(b, 70594), b, a)
    case False{}:
      comp.n95(U32.is_lt(b, 70601), b, a)

def comp.n97(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70832(a)

def comp.n98(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.b70842(a)

def comp.n99(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n97(U32.is_lt(b, 70832), b, a)
    case False{}:
      comp.n98(U32.is_lt(b, 70842), b, a)

def comp.n100(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n96(U32.is_lt(b, 70595), b, a)
    case False{}:
      comp.n99(U32.is_lt(b, 70833), b, a)

def comp.n101(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n93(U32.is_lt(b, 70488), b, a)
    case False{}:
      comp.n100(U32.is_lt(b, 70602), b, a)

def comp.n102(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b70845(a)
    case False{}:
      None{}

def comp.n103(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      None{}
    case False{}:
      comp.n102(U32.is_lt(b, 70846), b, a)

def comp.n104(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b71087(a)
    case False{}:
      None{}

def comp.n105(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b71984(a)
    case False{}:
      None{}

def comp.n106(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n104(U32.is_lt(b, 71088), b, a)
    case False{}:
      comp.n105(U32.is_lt(b, 71985), b, a)

def comp.n107(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n103(U32.is_lt(b, 70845), b, a)
    case False{}:
      comp.n106(U32.is_lt(b, 71984), b, a)

def comp.n108(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90398(a)
    case False{}:
      comp.b90399(a)

def comp.n109(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90400(a)
    case False{}:
      None{}

def comp.n110(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n108(U32.is_lt(b, 90399), b, a)
    case False{}:
      comp.n109(U32.is_lt(b, 90401), b, a)

def comp.n111(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b90409(a)
    case False{}:
      None{}

def comp.n112(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.b93543(a)
    case False{}:
      None{}

def comp.n113(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n111(U32.is_lt(b, 90410), b, a)
    case False{}:
      comp.n112(U32.is_lt(b, 93544), b, a)

def comp.n114(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n110(U32.is_lt(b, 90400), b, a)
    case False{}:
      comp.n113(U32.is_lt(b, 93543), b, a)

def comp.n115(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n107(U32.is_lt(b, 71087), b, a)
    case False{}:
      comp.n114(U32.is_lt(b, 90409), b, a)

def comp.n116(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n101(U32.is_lt(b, 70588), b, a)
    case False{}:
      comp.n115(U32.is_lt(b, 90398), b, a)

def comp.n117(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n87(U32.is_lt(b, 3535), b, a)
    case False{}:
      comp.n116(U32.is_lt(b, 70843), b, a)

def comp.n118(lt: Bool, +b: U32, +a: U32) -> Maybe<&2, U32>:
  match lt:
    case True{}:
      comp.n58(U32.is_lt(b, 809), b, a)
    case False{}:
      comp.n117(U32.is_lt(b, 70462), b, a)

def comp(+b: U32, +a: U32) -> Maybe<&2, U32>:
  comp.n118(U32.is_lt(b, 3031), b, a)

def fold.n0(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{61}"

def fold.n1(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{62}"
    case False{}:
      "\u{63}"

def fold.n2(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n0(U32.is_lt(c, 65), c)
    case False{}:
      fold.n1(U32.is_lt(c, 67), c)

def fold.n3(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{64}"
    case False{}:
      "\u{65}"

def fold.n4(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66}"
    case False{}:
      "\u{67}"

def fold.n5(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n3(U32.is_lt(c, 69), c)
    case False{}:
      fold.n4(U32.is_lt(c, 71), c)

def fold.n6(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2(U32.is_lt(c, 66), c)
    case False{}:
      fold.n5(U32.is_lt(c, 70), c)

def fold.n7(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{68}"
    case False{}:
      "\u{69}"

def fold.n8(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6A}"
    case False{}:
      "\u{6B}"

def fold.n9(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n7(U32.is_lt(c, 73), c)
    case False{}:
      fold.n8(U32.is_lt(c, 75), c)

def fold.n10(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6C}"
    case False{}:
      "\u{6D}"

def fold.n11(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6F}"
    case False{}:
      "\u{70}"

def fold.n12(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6E}"
    case False{}:
      fold.n11(U32.is_lt(c, 80), c)

def fold.n13(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n10(U32.is_lt(c, 77), c)
    case False{}:
      fold.n12(U32.is_lt(c, 79), c)

def fold.n14(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n9(U32.is_lt(c, 74), c)
    case False{}:
      fold.n13(U32.is_lt(c, 78), c)

def fold.n15(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n6(U32.is_lt(c, 68), c)
    case False{}:
      fold.n14(U32.is_lt(c, 76), c)

def fold.n16(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{71}"
    case False{}:
      "\u{72}"

def fold.n17(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73}"
    case False{}:
      "\u{74}"

def fold.n18(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n16(U32.is_lt(c, 82), c)
    case False{}:
      fold.n17(U32.is_lt(c, 84), c)

def fold.n19(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{75}"
    case False{}:
      "\u{76}"

def fold.n20(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{77}"
    case False{}:
      "\u{78}"

def fold.n21(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n19(U32.is_lt(c, 86), c)
    case False{}:
      fold.n20(U32.is_lt(c, 88), c)

def fold.n22(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n18(U32.is_lt(c, 83), c)
    case False{}:
      fold.n21(U32.is_lt(c, 87), c)

def fold.n23(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}"
    case False{}:
      "\u{7A}"

def fold.n24(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3BC}"

def fold.n25(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n23(U32.is_lt(c, 90), c)
    case False{}:
      fold.n24(U32.is_lt(c, 181), c)

def fold.n26(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{E0}"

def fold.n27(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E2}"
    case False{}:
      "\u{E3}"

def fold.n28(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E1}"
    case False{}:
      fold.n27(U32.is_lt(c, 195), c)

def fold.n29(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n26(U32.is_lt(c, 192), c)
    case False{}:
      fold.n28(U32.is_lt(c, 194), c)

def fold.n30(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n25(U32.is_lt(c, 91), c)
    case False{}:
      fold.n29(U32.is_lt(c, 193), c)

def fold.n31(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n22(U32.is_lt(c, 85), c)
    case False{}:
      fold.n30(U32.is_lt(c, 182), c)

def fold.n32(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n15(U32.is_lt(c, 72), c)
    case False{}:
      fold.n31(U32.is_lt(c, 89), c)

def fold.n33(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E4}"
    case False{}:
      "\u{E5}"

def fold.n34(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E6}"
    case False{}:
      "\u{E7}"

def fold.n35(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n33(U32.is_lt(c, 197), c)
    case False{}:
      fold.n34(U32.is_lt(c, 199), c)

def fold.n36(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{E8}"
    case False{}:
      "\u{E9}"

def fold.n37(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{EA}"
    case False{}:
      "\u{EB}"

def fold.n38(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n36(U32.is_lt(c, 201), c)
    case False{}:
      fold.n37(U32.is_lt(c, 203), c)

def fold.n39(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n35(U32.is_lt(c, 198), c)
    case False{}:
      fold.n38(U32.is_lt(c, 202), c)

def fold.n40(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{EC}"
    case False{}:
      "\u{ED}"

def fold.n41(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{EE}"
    case False{}:
      "\u{EF}"

def fold.n42(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n40(U32.is_lt(c, 205), c)
    case False{}:
      fold.n41(U32.is_lt(c, 207), c)

def fold.n43(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F0}"
    case False{}:
      "\u{F1}"

def fold.n44(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F3}"
    case False{}:
      "\u{F4}"

def fold.n45(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F2}"
    case False{}:
      fold.n44(U32.is_lt(c, 212), c)

def fold.n46(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n43(U32.is_lt(c, 209), c)
    case False{}:
      fold.n45(U32.is_lt(c, 211), c)

def fold.n47(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n42(U32.is_lt(c, 206), c)
    case False{}:
      fold.n46(U32.is_lt(c, 210), c)

def fold.n48(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n39(U32.is_lt(c, 200), c)
    case False{}:
      fold.n47(U32.is_lt(c, 208), c)

def fold.n49(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F5}"
    case False{}:
      "\u{F6}"

def fold.n50(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{F8}"

def fold.n51(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n49(U32.is_lt(c, 214), c)
    case False{}:
      fold.n50(U32.is_lt(c, 216), c)

def fold.n52(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{F9}"
    case False{}:
      "\u{FA}"

def fold.n53(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FC}"
    case False{}:
      "\u{FD}"

def fold.n54(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FB}"
    case False{}:
      fold.n53(U32.is_lt(c, 221), c)

def fold.n55(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n52(U32.is_lt(c, 218), c)
    case False{}:
      fold.n54(U32.is_lt(c, 220), c)

def fold.n56(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n51(U32.is_lt(c, 215), c)
    case False{}:
      fold.n55(U32.is_lt(c, 219), c)

def fold.n57(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FE}"
    case False{}:
      "\u{73}\u{73}"

def fold.n58(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{101}"

def fold.n59(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n57(U32.is_lt(c, 223), c)
    case False{}:
      fold.n58(U32.is_lt(c, 256), c)

def fold.n60(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{103}"

def fold.n61(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n62(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n61(U32.is_lt(c, 261), c)

def fold.n63(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n60(U32.is_lt(c, 258), c)
    case False{}:
      fold.n62(U32.is_lt(c, 260), c)

def fold.n64(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n59(U32.is_lt(c, 224), c)
    case False{}:
      fold.n63(U32.is_lt(c, 259), c)

def fold.n65(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n56(U32.is_lt(c, 217), c)
    case False{}:
      fold.n64(U32.is_lt(c, 257), c)

def fold.n66(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n48(U32.is_lt(c, 204), c)
    case False{}:
      fold.n65(U32.is_lt(c, 222), c)

def fold.n67(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n32(U32.is_lt(c, 81), c)
    case False{}:
      fold.n66(U32.is_lt(c, 213), c)

def fold.n68(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{107}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n69(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{109}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n70(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n68(U32.is_lt(c, 263), c)
    case False{}:
      fold.n69(U32.is_lt(c, 265), c)

def fold.n71(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n72(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n73(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n71(U32.is_lt(c, 267), c)
    case False{}:
      fold.n72(U32.is_lt(c, 269), c)

def fold.n74(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n70(U32.is_lt(c, 264), c)
    case False{}:
      fold.n73(U32.is_lt(c, 268), c)

def fold.n75(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n76(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{111}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n77(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n75(U32.is_lt(c, 271), c)
    case False{}:
      fold.n76(U32.is_lt(c, 273), c)

def fold.n78(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{113}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n79(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{117}"

def fold.n80(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{115}"
    case False{}:
      fold.n79(U32.is_lt(c, 278), c)

def fold.n81(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n78(U32.is_lt(c, 275), c)
    case False{}:
      fold.n80(U32.is_lt(c, 277), c)

def fold.n82(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n77(U32.is_lt(c, 272), c)
    case False{}:
      fold.n81(U32.is_lt(c, 276), c)

def fold.n83(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n74(U32.is_lt(c, 266), c)
    case False{}:
      fold.n82(U32.is_lt(c, 274), c)

def fold.n84(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{119}"

def fold.n85(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11B}"

def fold.n86(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n84(U32.is_lt(c, 280), c)
    case False{}:
      fold.n85(U32.is_lt(c, 282), c)

def fold.n87(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11D}"

def fold.n88(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{11F}"

def fold.n89(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n87(U32.is_lt(c, 284), c)
    case False{}:
      fold.n88(U32.is_lt(c, 286), c)

def fold.n90(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n86(U32.is_lt(c, 281), c)
    case False{}:
      fold.n89(U32.is_lt(c, 285), c)

def fold.n91(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{121}"

def fold.n92(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{123}"

def fold.n93(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n91(U32.is_lt(c, 288), c)
    case False{}:
      fold.n92(U32.is_lt(c, 290), c)

def fold.n94(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{125}"

def fold.n95(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{127}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n96(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n95(U32.is_lt(c, 295), c)

def fold.n97(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n94(U32.is_lt(c, 292), c)
    case False{}:
      fold.n96(U32.is_lt(c, 294), c)

def fold.n98(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n93(U32.is_lt(c, 289), c)
    case False{}:
      fold.n97(U32.is_lt(c, 293), c)

def fold.n99(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n90(U32.is_lt(c, 283), c)
    case False{}:
      fold.n98(U32.is_lt(c, 291), c)

def fold.n100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n83(U32.is_lt(c, 270), c)
    case False{}:
      fold.n99(U32.is_lt(c, 287), c)

def fold.n101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{129}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{12B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n101(U32.is_lt(c, 297), c)
    case False{}:
      fold.n102(U32.is_lt(c, 299), c)

def fold.n104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{12D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{12F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n104(U32.is_lt(c, 301), c)
    case False{}:
      fold.n105(U32.is_lt(c, 303), c)

def fold.n107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n103(U32.is_lt(c, 298), c)
    case False{}:
      fold.n106(U32.is_lt(c, 302), c)

def fold.n108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{69}\u{307}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{133}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n108(U32.is_lt(c, 305), c)
    case False{}:
      fold.n109(U32.is_lt(c, 307), c)

def fold.n111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{135}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{13A}"

def fold.n113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{137}"
    case False{}:
      fold.n112(U32.is_lt(c, 313), c)

def fold.n114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n111(U32.is_lt(c, 309), c)
    case False{}:
      fold.n113(U32.is_lt(c, 311), c)

def fold.n115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n110(U32.is_lt(c, 306), c)
    case False{}:
      fold.n114(U32.is_lt(c, 310), c)

def fold.n116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n107(U32.is_lt(c, 300), c)
    case False{}:
      fold.n115(U32.is_lt(c, 308), c)

def fold.n117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{13C}"

def fold.n118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{13E}"

def fold.n119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n117(U32.is_lt(c, 315), c)
    case False{}:
      fold.n118(U32.is_lt(c, 317), c)

def fold.n120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{140}"

def fold.n121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{142}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n121(U32.is_lt(c, 322), c)

def fold.n123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n120(U32.is_lt(c, 319), c)
    case False{}:
      fold.n122(U32.is_lt(c, 321), c)

def fold.n124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n119(U32.is_lt(c, 316), c)
    case False{}:
      fold.n123(U32.is_lt(c, 320), c)

def fold.n125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{144}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{146}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n125(U32.is_lt(c, 324), c)
    case False{}:
      fold.n126(U32.is_lt(c, 326), c)

def fold.n128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{148}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{14B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2BC}\u{6E}"
    case False{}:
      fold.n129(U32.is_lt(c, 331), c)

def fold.n131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n128(U32.is_lt(c, 328), c)
    case False{}:
      fold.n130(U32.is_lt(c, 330), c)

def fold.n132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n127(U32.is_lt(c, 325), c)
    case False{}:
      fold.n131(U32.is_lt(c, 329), c)

def fold.n133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n124(U32.is_lt(c, 318), c)
    case False{}:
      fold.n132(U32.is_lt(c, 327), c)

def fold.n134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n116(U32.is_lt(c, 304), c)
    case False{}:
      fold.n133(U32.is_lt(c, 323), c)

def fold.n135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n100(U32.is_lt(c, 279), c)
    case False{}:
      fold.n134(U32.is_lt(c, 314), c)

def fold.n136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n67(U32.is_lt(c, 196), c)
    case False{}:
      fold.n135(U32.is_lt(c, 296), c)

def fold.n137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{14D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{14F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n137(U32.is_lt(c, 333), c)
    case False{}:
      fold.n138(U32.is_lt(c, 335), c)

def fold.n140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{151}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{153}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n140(U32.is_lt(c, 337), c)
    case False{}:
      fold.n141(U32.is_lt(c, 339), c)

def fold.n143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n139(U32.is_lt(c, 334), c)
    case False{}:
      fold.n142(U32.is_lt(c, 338), c)

def fold.n144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{155}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{157}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n144(U32.is_lt(c, 341), c)
    case False{}:
      fold.n145(U32.is_lt(c, 343), c)

def fold.n147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{159}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{15D}"

def fold.n149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{15B}"
    case False{}:
      fold.n148(U32.is_lt(c, 348), c)

def fold.n150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n147(U32.is_lt(c, 345), c)
    case False{}:
      fold.n149(U32.is_lt(c, 347), c)

def fold.n151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n146(U32.is_lt(c, 342), c)
    case False{}:
      fold.n150(U32.is_lt(c, 346), c)

def fold.n152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n143(U32.is_lt(c, 336), c)
    case False{}:
      fold.n151(U32.is_lt(c, 344), c)

def fold.n153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{15F}"

def fold.n154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{161}"

def fold.n155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n153(U32.is_lt(c, 350), c)
    case False{}:
      fold.n154(U32.is_lt(c, 352), c)

def fold.n156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{163}"

def fold.n157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{165}"

def fold.n158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n156(U32.is_lt(c, 354), c)
    case False{}:
      fold.n157(U32.is_lt(c, 356), c)

def fold.n159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n155(U32.is_lt(c, 351), c)
    case False{}:
      fold.n158(U32.is_lt(c, 355), c)

def fold.n160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{167}"

def fold.n161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{169}"

def fold.n162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n160(U32.is_lt(c, 358), c)
    case False{}:
      fold.n161(U32.is_lt(c, 360), c)

def fold.n163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{16B}"

def fold.n164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n164(U32.is_lt(c, 365), c)

def fold.n166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n163(U32.is_lt(c, 362), c)
    case False{}:
      fold.n165(U32.is_lt(c, 364), c)

def fold.n167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n162(U32.is_lt(c, 359), c)
    case False{}:
      fold.n166(U32.is_lt(c, 363), c)

def fold.n168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n159(U32.is_lt(c, 353), c)
    case False{}:
      fold.n167(U32.is_lt(c, 361), c)

def fold.n169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n152(U32.is_lt(c, 340), c)
    case False{}:
      fold.n168(U32.is_lt(c, 357), c)

def fold.n170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{171}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n170(U32.is_lt(c, 367), c)
    case False{}:
      fold.n171(U32.is_lt(c, 369), c)

def fold.n173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{173}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{175}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n173(U32.is_lt(c, 371), c)
    case False{}:
      fold.n174(U32.is_lt(c, 373), c)

def fold.n176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n172(U32.is_lt(c, 368), c)
    case False{}:
      fold.n175(U32.is_lt(c, 372), c)

def fold.n177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{177}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF}"
    case False{}:
      "\u{17A}"

def fold.n179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n177(U32.is_lt(c, 375), c)
    case False{}:
      fold.n178(U32.is_lt(c, 377), c)

def fold.n180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{17C}"

def fold.n181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{17E}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n181(U32.is_lt(c, 382), c)

def fold.n183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n180(U32.is_lt(c, 379), c)
    case False{}:
      fold.n182(U32.is_lt(c, 381), c)

def fold.n184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n179(U32.is_lt(c, 376), c)
    case False{}:
      fold.n183(U32.is_lt(c, 380), c)

def fold.n185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n176(U32.is_lt(c, 370), c)
    case False{}:
      fold.n184(U32.is_lt(c, 378), c)

def fold.n186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{253}"
    case False{}:
      "\u{183}"

def fold.n188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n186(U32.is_lt(c, 384), c)
    case False{}:
      fold.n187(U32.is_lt(c, 386), c)

def fold.n189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{185}"

def fold.n190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{254}"
    case False{}:
      "\u{188}"

def fold.n191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n190(U32.is_lt(c, 391), c)

def fold.n192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n189(U32.is_lt(c, 388), c)
    case False{}:
      fold.n191(U32.is_lt(c, 390), c)

def fold.n193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n188(U32.is_lt(c, 385), c)
    case False{}:
      fold.n192(U32.is_lt(c, 389), c)

def fold.n194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{256}"

def fold.n195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{257}"
    case False{}:
      "\u{18C}"

def fold.n196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n194(U32.is_lt(c, 393), c)
    case False{}:
      fold.n195(U32.is_lt(c, 395), c)

def fold.n197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1DD}"

def fold.n198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25B}"
    case False{}:
      "\u{192}"

def fold.n199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{259}"
    case False{}:
      fold.n198(U32.is_lt(c, 401), c)

def fold.n200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n197(U32.is_lt(c, 398), c)
    case False{}:
      fold.n199(U32.is_lt(c, 400), c)

def fold.n201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n196(U32.is_lt(c, 394), c)
    case False{}:
      fold.n200(U32.is_lt(c, 399), c)

def fold.n202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n193(U32.is_lt(c, 387), c)
    case False{}:
      fold.n201(U32.is_lt(c, 396), c)

def fold.n203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n185(U32.is_lt(c, 374), c)
    case False{}:
      fold.n202(U32.is_lt(c, 392), c)

def fold.n204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n169(U32.is_lt(c, 349), c)
    case False{}:
      fold.n203(U32.is_lt(c, 383), c)

def fold.n205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{260}"

def fold.n206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{263}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n205(U32.is_lt(c, 403), c)
    case False{}:
      fold.n206(U32.is_lt(c, 405), c)

def fold.n208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{269}"
    case False{}:
      "\u{268}"

def fold.n209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{199}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n208(U32.is_lt(c, 407), c)
    case False{}:
      fold.n209(U32.is_lt(c, 409), c)

def fold.n211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n207(U32.is_lt(c, 404), c)
    case False{}:
      fold.n210(U32.is_lt(c, 408), c)

def fold.n212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{26F}"
    case False{}:
      "\u{272}"

def fold.n213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{275}"

def fold.n214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n212(U32.is_lt(c, 413), c)
    case False{}:
      fold.n213(U32.is_lt(c, 415), c)

def fold.n215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1A1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1A5}"

def fold.n217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1A3}"
    case False{}:
      fold.n216(U32.is_lt(c, 420), c)

def fold.n218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n215(U32.is_lt(c, 417), c)
    case False{}:
      fold.n217(U32.is_lt(c, 419), c)

def fold.n219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n214(U32.is_lt(c, 414), c)
    case False{}:
      fold.n218(U32.is_lt(c, 418), c)

def fold.n220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n211(U32.is_lt(c, 406), c)
    case False{}:
      fold.n219(U32.is_lt(c, 416), c)

def fold.n221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{280}"

def fold.n222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1A8}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n221(U32.is_lt(c, 422), c)
    case False{}:
      fold.n222(U32.is_lt(c, 424), c)

def fold.n224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{283}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{288}"

def fold.n226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1AD}"
    case False{}:
      fold.n225(U32.is_lt(c, 430), c)

def fold.n227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n224(U32.is_lt(c, 426), c)
    case False{}:
      fold.n226(U32.is_lt(c, 429), c)

def fold.n228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n223(U32.is_lt(c, 423), c)
    case False{}:
      fold.n227(U32.is_lt(c, 428), c)

def fold.n229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B0}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{28A}"
    case False{}:
      "\u{28B}"

def fold.n231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n229(U32.is_lt(c, 432), c)
    case False{}:
      fold.n230(U32.is_lt(c, 434), c)

def fold.n232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B4}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{292}"

def fold.n234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B6}"
    case False{}:
      fold.n233(U32.is_lt(c, 439), c)

def fold.n235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n232(U32.is_lt(c, 436), c)
    case False{}:
      fold.n234(U32.is_lt(c, 438), c)

def fold.n236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n231(U32.is_lt(c, 433), c)
    case False{}:
      fold.n235(U32.is_lt(c, 437), c)

def fold.n237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n228(U32.is_lt(c, 425), c)
    case False{}:
      fold.n236(U32.is_lt(c, 435), c)

def fold.n238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n220(U32.is_lt(c, 412), c)
    case False{}:
      fold.n237(U32.is_lt(c, 431), c)

def fold.n239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1BD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n239(U32.is_lt(c, 441), c)
    case False{}:
      fold.n240(U32.is_lt(c, 445), c)

def fold.n242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1C6}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1C9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n242(U32.is_lt(c, 454), c)
    case False{}:
      fold.n243(U32.is_lt(c, 457), c)

def fold.n245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n241(U32.is_lt(c, 444), c)
    case False{}:
      fold.n244(U32.is_lt(c, 455), c)

def fold.n246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1CC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1CE}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n246(U32.is_lt(c, 460), c)
    case False{}:
      fold.n247(U32.is_lt(c, 462), c)

def fold.n249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D0}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1D4}"

def fold.n251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D2}"
    case False{}:
      fold.n250(U32.is_lt(c, 467), c)

def fold.n252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n249(U32.is_lt(c, 464), c)
    case False{}:
      fold.n251(U32.is_lt(c, 466), c)

def fold.n253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n248(U32.is_lt(c, 461), c)
    case False{}:
      fold.n252(U32.is_lt(c, 465), c)

def fold.n254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n245(U32.is_lt(c, 452), c)
    case False{}:
      fold.n253(U32.is_lt(c, 463), c)

def fold.n255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1D6}"

def fold.n256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1D8}"

def fold.n257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n255(U32.is_lt(c, 469), c)
    case False{}:
      fold.n256(U32.is_lt(c, 471), c)

def fold.n258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1DA}"

def fold.n259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1DC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n259(U32.is_lt(c, 476), c)

def fold.n261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n258(U32.is_lt(c, 473), c)
    case False{}:
      fold.n260(U32.is_lt(c, 475), c)

def fold.n262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n257(U32.is_lt(c, 470), c)
    case False{}:
      fold.n261(U32.is_lt(c, 474), c)

def fold.n263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1DF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n263(U32.is_lt(c, 479), c)
    case False{}:
      fold.n264(U32.is_lt(c, 481), c)

def fold.n266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E7}"

def fold.n268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E5}"
    case False{}:
      fold.n267(U32.is_lt(c, 486), c)

def fold.n269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n266(U32.is_lt(c, 483), c)
    case False{}:
      fold.n268(U32.is_lt(c, 485), c)

def fold.n270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n265(U32.is_lt(c, 480), c)
    case False{}:
      fold.n269(U32.is_lt(c, 484), c)

def fold.n271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n262(U32.is_lt(c, 472), c)
    case False{}:
      fold.n270(U32.is_lt(c, 482), c)

def fold.n272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n254(U32.is_lt(c, 458), c)
    case False{}:
      fold.n271(U32.is_lt(c, 478), c)

def fold.n273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n238(U32.is_lt(c, 421), c)
    case False{}:
      fold.n272(U32.is_lt(c, 468), c)

def fold.n274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n204(U32.is_lt(c, 366), c)
    case False{}:
      fold.n273(U32.is_lt(c, 440), c)

def fold.n275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n136(U32.is_lt(c, 262), c)
    case False{}:
      fold.n274(U32.is_lt(c, 402), c)

def fold.n276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E9}"

def fold.n277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EB}"

def fold.n278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n276(U32.is_lt(c, 488), c)
    case False{}:
      fold.n277(U32.is_lt(c, 490), c)

def fold.n279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED}"

def fold.n280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EF}"

def fold.n281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n279(U32.is_lt(c, 492), c)
    case False{}:
      fold.n280(U32.is_lt(c, 494), c)

def fold.n282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n278(U32.is_lt(c, 489), c)
    case False{}:
      fold.n281(U32.is_lt(c, 493), c)

def fold.n283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{6A}\u{30C}"

def fold.n284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n283(U32.is_lt(c, 496), c)
    case False{}:
      fold.n284(U32.is_lt(c, 499), c)

def fold.n286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1BF}"
    case False{}:
      "\u{1F9}"

def fold.n288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{195}"
    case False{}:
      fold.n287(U32.is_lt(c, 504), c)

def fold.n289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n286(U32.is_lt(c, 501), c)
    case False{}:
      fold.n288(U32.is_lt(c, 503), c)

def fold.n290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n285(U32.is_lt(c, 497), c)
    case False{}:
      fold.n289(U32.is_lt(c, 502), c)

def fold.n291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n282(U32.is_lt(c, 491), c)
    case False{}:
      fold.n290(U32.is_lt(c, 500), c)

def fold.n292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1FB}"

def fold.n293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1FD}"

def fold.n294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n292(U32.is_lt(c, 506), c)
    case False{}:
      fold.n293(U32.is_lt(c, 508), c)

def fold.n295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1FF}"

def fold.n296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{201}"

def fold.n297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n295(U32.is_lt(c, 510), c)
    case False{}:
      fold.n296(U32.is_lt(c, 512), c)

def fold.n298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n294(U32.is_lt(c, 507), c)
    case False{}:
      fold.n297(U32.is_lt(c, 511), c)

def fold.n299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{203}"

def fold.n300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{205}"

def fold.n301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n299(U32.is_lt(c, 514), c)
    case False{}:
      fold.n300(U32.is_lt(c, 516), c)

def fold.n302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{207}"

def fold.n303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{209}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n303(U32.is_lt(c, 521), c)

def fold.n305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n302(U32.is_lt(c, 518), c)
    case False{}:
      fold.n304(U32.is_lt(c, 520), c)

def fold.n306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n301(U32.is_lt(c, 515), c)
    case False{}:
      fold.n305(U32.is_lt(c, 519), c)

def fold.n307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n298(U32.is_lt(c, 509), c)
    case False{}:
      fold.n306(U32.is_lt(c, 517), c)

def fold.n308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n291(U32.is_lt(c, 495), c)
    case False{}:
      fold.n307(U32.is_lt(c, 513), c)

def fold.n309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n309(U32.is_lt(c, 523), c)
    case False{}:
      fold.n310(U32.is_lt(c, 525), c)

def fold.n312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{20F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{211}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n312(U32.is_lt(c, 527), c)
    case False{}:
      fold.n313(U32.is_lt(c, 529), c)

def fold.n315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n311(U32.is_lt(c, 524), c)
    case False{}:
      fold.n314(U32.is_lt(c, 528), c)

def fold.n316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{213}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{215}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n316(U32.is_lt(c, 531), c)
    case False{}:
      fold.n317(U32.is_lt(c, 533), c)

def fold.n319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{217}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{21B}"

def fold.n321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{219}"
    case False{}:
      fold.n320(U32.is_lt(c, 538), c)

def fold.n322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n319(U32.is_lt(c, 535), c)
    case False{}:
      fold.n321(U32.is_lt(c, 537), c)

def fold.n323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n318(U32.is_lt(c, 532), c)
    case False{}:
      fold.n322(U32.is_lt(c, 536), c)

def fold.n324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n315(U32.is_lt(c, 526), c)
    case False{}:
      fold.n323(U32.is_lt(c, 534), c)

def fold.n325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{21D}"

def fold.n326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{21F}"

def fold.n327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n325(U32.is_lt(c, 540), c)
    case False{}:
      fold.n326(U32.is_lt(c, 542), c)

def fold.n328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{19E}"

def fold.n329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{223}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n329(U32.is_lt(c, 547), c)

def fold.n331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n328(U32.is_lt(c, 544), c)
    case False{}:
      fold.n330(U32.is_lt(c, 546), c)

def fold.n332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n327(U32.is_lt(c, 541), c)
    case False{}:
      fold.n331(U32.is_lt(c, 545), c)

def fold.n333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{225}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{227}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n333(U32.is_lt(c, 549), c)
    case False{}:
      fold.n334(U32.is_lt(c, 551), c)

def fold.n336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{229}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{22D}"

def fold.n338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{22B}"
    case False{}:
      fold.n337(U32.is_lt(c, 556), c)

def fold.n339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n336(U32.is_lt(c, 553), c)
    case False{}:
      fold.n338(U32.is_lt(c, 555), c)

def fold.n340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n335(U32.is_lt(c, 550), c)
    case False{}:
      fold.n339(U32.is_lt(c, 554), c)

def fold.n341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n332(U32.is_lt(c, 543), c)
    case False{}:
      fold.n340(U32.is_lt(c, 552), c)

def fold.n342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n324(U32.is_lt(c, 530), c)
    case False{}:
      fold.n341(U32.is_lt(c, 548), c)

def fold.n343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n308(U32.is_lt(c, 505), c)
    case False{}:
      fold.n342(U32.is_lt(c, 539), c)

def fold.n344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{22F}"

def fold.n345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{231}"

def fold.n346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n344(U32.is_lt(c, 558), c)
    case False{}:
      fold.n345(U32.is_lt(c, 560), c)

def fold.n347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{233}"

def fold.n348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C65}"

def fold.n349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n347(U32.is_lt(c, 562), c)
    case False{}:
      fold.n348(U32.is_lt(c, 570), c)

def fold.n350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n346(U32.is_lt(c, 559), c)
    case False{}:
      fold.n349(U32.is_lt(c, 563), c)

def fold.n351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{23C}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{19A}"
    case False{}:
      "\u{2C66}"

def fold.n353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n351(U32.is_lt(c, 572), c)
    case False{}:
      fold.n352(U32.is_lt(c, 574), c)

def fold.n354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{242}"

def fold.n355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{180}"
    case False{}:
      "\u{289}"

def fold.n356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n355(U32.is_lt(c, 580), c)

def fold.n357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n354(U32.is_lt(c, 577), c)
    case False{}:
      fold.n356(U32.is_lt(c, 579), c)

def fold.n358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n353(U32.is_lt(c, 573), c)
    case False{}:
      fold.n357(U32.is_lt(c, 578), c)

def fold.n359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n350(U32.is_lt(c, 561), c)
    case False{}:
      fold.n358(U32.is_lt(c, 575), c)

def fold.n360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{28C}"
    case False{}:
      "\u{247}"

def fold.n361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{249}"

def fold.n362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n360(U32.is_lt(c, 582), c)
    case False{}:
      fold.n361(U32.is_lt(c, 584), c)

def fold.n363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{24B}"

def fold.n364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{24D}"

def fold.n365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n363(U32.is_lt(c, 586), c)
    case False{}:
      fold.n364(U32.is_lt(c, 588), c)

def fold.n366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n362(U32.is_lt(c, 583), c)
    case False{}:
      fold.n365(U32.is_lt(c, 587), c)

def fold.n367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{24F}"

def fold.n368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B9}"

def fold.n369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n367(U32.is_lt(c, 590), c)
    case False{}:
      fold.n368(U32.is_lt(c, 837), c)

def fold.n370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{371}"

def fold.n371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{373}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n371(U32.is_lt(c, 883), c)

def fold.n373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n370(U32.is_lt(c, 880), c)
    case False{}:
      fold.n372(U32.is_lt(c, 882), c)

def fold.n374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n369(U32.is_lt(c, 591), c)
    case False{}:
      fold.n373(U32.is_lt(c, 881), c)

def fold.n375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n366(U32.is_lt(c, 585), c)
    case False{}:
      fold.n374(U32.is_lt(c, 838), c)

def fold.n376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n359(U32.is_lt(c, 571), c)
    case False{}:
      fold.n375(U32.is_lt(c, 589), c)

def fold.n377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{377}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3F3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n377(U32.is_lt(c, 887), c)
    case False{}:
      fold.n378(U32.is_lt(c, 896), c)

def fold.n380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3AC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3AD}"
    case False{}:
      "\u{3AE}"

def fold.n382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n380(U32.is_lt(c, 903), c)
    case False{}:
      fold.n381(U32.is_lt(c, 905), c)

def fold.n383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n379(U32.is_lt(c, 895), c)
    case False{}:
      fold.n382(U32.is_lt(c, 904), c)

def fold.n384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3AF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3CC}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n384(U32.is_lt(c, 907), c)
    case False{}:
      fold.n385(U32.is_lt(c, 909), c)

def fold.n387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3CD}"
    case False{}:
      "\u{3CE}"

def fold.n388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}"
    case False{}:
      "\u{3B2}"

def fold.n389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}\u{301}"
    case False{}:
      fold.n388(U32.is_lt(c, 914), c)

def fold.n390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n387(U32.is_lt(c, 911), c)
    case False{}:
      fold.n389(U32.is_lt(c, 913), c)

def fold.n391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n386(U32.is_lt(c, 908), c)
    case False{}:
      fold.n390(U32.is_lt(c, 912), c)

def fold.n392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n383(U32.is_lt(c, 902), c)
    case False{}:
      fold.n391(U32.is_lt(c, 910), c)

def fold.n393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B3}"
    case False{}:
      "\u{3B4}"

def fold.n394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B5}"
    case False{}:
      "\u{3B6}"

def fold.n395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n393(U32.is_lt(c, 916), c)
    case False{}:
      fold.n394(U32.is_lt(c, 918), c)

def fold.n396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}"
    case False{}:
      "\u{3B8}"

def fold.n397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BA}"
    case False{}:
      "\u{3BB}"

def fold.n398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}"
    case False{}:
      fold.n397(U32.is_lt(c, 923), c)

def fold.n399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n396(U32.is_lt(c, 920), c)
    case False{}:
      fold.n398(U32.is_lt(c, 922), c)

def fold.n400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n395(U32.is_lt(c, 917), c)
    case False{}:
      fold.n399(U32.is_lt(c, 921), c)

def fold.n401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BC}"
    case False{}:
      "\u{3BD}"

def fold.n402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3BE}"
    case False{}:
      "\u{3BF}"

def fold.n403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n401(U32.is_lt(c, 925), c)
    case False{}:
      fold.n402(U32.is_lt(c, 927), c)

def fold.n404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C0}"
    case False{}:
      "\u{3C1}"

def fold.n405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C3}"
    case False{}:
      "\u{3C4}"

def fold.n406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n405(U32.is_lt(c, 932), c)

def fold.n407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n404(U32.is_lt(c, 929), c)
    case False{}:
      fold.n406(U32.is_lt(c, 931), c)

def fold.n408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n403(U32.is_lt(c, 926), c)
    case False{}:
      fold.n407(U32.is_lt(c, 930), c)

def fold.n409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n400(U32.is_lt(c, 919), c)
    case False{}:
      fold.n408(U32.is_lt(c, 928), c)

def fold.n410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n392(U32.is_lt(c, 906), c)
    case False{}:
      fold.n409(U32.is_lt(c, 924), c)

def fold.n411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n376(U32.is_lt(c, 581), c)
    case False{}:
      fold.n410(U32.is_lt(c, 915), c)

def fold.n412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n343(U32.is_lt(c, 522), c)
    case False{}:
      fold.n411(U32.is_lt(c, 886), c)

def fold.n413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}"
    case False{}:
      "\u{3C6}"

def fold.n414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C7}"
    case False{}:
      "\u{3C8}"

def fold.n415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n413(U32.is_lt(c, 934), c)
    case False{}:
      fold.n414(U32.is_lt(c, 936), c)

def fold.n416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}"
    case False{}:
      "\u{3CA}"

def fold.n417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3CB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n416(U32.is_lt(c, 938), c)
    case False{}:
      fold.n417(U32.is_lt(c, 940), c)

def fold.n419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n415(U32.is_lt(c, 935), c)
    case False{}:
      fold.n418(U32.is_lt(c, 939), c)

def fold.n420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{301}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n420(U32.is_lt(c, 945), c)
    case False{}:
      fold.n421(U32.is_lt(c, 963), c)

def fold.n423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3D7}"
    case False{}:
      "\u{3B2}"

def fold.n424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C6}"

def fold.n425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B8}"
    case False{}:
      fold.n424(U32.is_lt(c, 981), c)

def fold.n426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n423(U32.is_lt(c, 976), c)
    case False{}:
      fold.n425(U32.is_lt(c, 978), c)

def fold.n427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n422(U32.is_lt(c, 962), c)
    case False{}:
      fold.n426(U32.is_lt(c, 977), c)

def fold.n428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n419(U32.is_lt(c, 937), c)
    case False{}:
      fold.n427(U32.is_lt(c, 975), c)

def fold.n429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C0}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3D9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n429(U32.is_lt(c, 983), c)
    case False{}:
      fold.n430(U32.is_lt(c, 985), c)

def fold.n432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3DB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3DD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n432(U32.is_lt(c, 987), c)
    case False{}:
      fold.n433(U32.is_lt(c, 989), c)

def fold.n435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n431(U32.is_lt(c, 984), c)
    case False{}:
      fold.n434(U32.is_lt(c, 988), c)

def fold.n436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3DF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3E1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n436(U32.is_lt(c, 991), c)
    case False{}:
      fold.n437(U32.is_lt(c, 993), c)

def fold.n439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3E3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3E7}"

def fold.n441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3E5}"
    case False{}:
      fold.n440(U32.is_lt(c, 998), c)

def fold.n442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n439(U32.is_lt(c, 995), c)
    case False{}:
      fold.n441(U32.is_lt(c, 997), c)

def fold.n443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n438(U32.is_lt(c, 992), c)
    case False{}:
      fold.n442(U32.is_lt(c, 996), c)

def fold.n444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n435(U32.is_lt(c, 986), c)
    case False{}:
      fold.n443(U32.is_lt(c, 994), c)

def fold.n445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n428(U32.is_lt(c, 944), c)
    case False{}:
      fold.n444(U32.is_lt(c, 990), c)

def fold.n446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3E9}"

def fold.n447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3EB}"

def fold.n448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n446(U32.is_lt(c, 1000), c)
    case False{}:
      fold.n447(U32.is_lt(c, 1002), c)

def fold.n449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3ED}"

def fold.n450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3EF}"

def fold.n451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n449(U32.is_lt(c, 1004), c)
    case False{}:
      fold.n450(U32.is_lt(c, 1006), c)

def fold.n452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n448(U32.is_lt(c, 1001), c)
    case False{}:
      fold.n451(U32.is_lt(c, 1005), c)

def fold.n453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3BA}"

def fold.n454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n453(U32.is_lt(c, 1008), c)
    case False{}:
      fold.n454(U32.is_lt(c, 1010), c)

def fold.n456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B8}"
    case False{}:
      "\u{3B5}"

def fold.n457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3F8}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n457(U32.is_lt(c, 1016), c)

def fold.n459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n456(U32.is_lt(c, 1013), c)
    case False{}:
      fold.n458(U32.is_lt(c, 1015), c)

def fold.n460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n455(U32.is_lt(c, 1009), c)
    case False{}:
      fold.n459(U32.is_lt(c, 1014), c)

def fold.n461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n452(U32.is_lt(c, 1003), c)
    case False{}:
      fold.n460(U32.is_lt(c, 1012), c)

def fold.n462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3F2}"
    case False{}:
      "\u{3FB}"

def fold.n463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{37B}"

def fold.n464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n462(U32.is_lt(c, 1018), c)
    case False{}:
      fold.n463(U32.is_lt(c, 1021), c)

def fold.n465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{37C}"
    case False{}:
      "\u{37D}"

def fold.n466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{451}"
    case False{}:
      "\u{452}"

def fold.n467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{450}"
    case False{}:
      fold.n466(U32.is_lt(c, 1026), c)

def fold.n468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n465(U32.is_lt(c, 1023), c)
    case False{}:
      fold.n467(U32.is_lt(c, 1025), c)

def fold.n469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n464(U32.is_lt(c, 1019), c)
    case False{}:
      fold.n468(U32.is_lt(c, 1024), c)

def fold.n470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{453}"
    case False{}:
      "\u{454}"

def fold.n471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{455}"
    case False{}:
      "\u{456}"

def fold.n472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n470(U32.is_lt(c, 1028), c)
    case False{}:
      fold.n471(U32.is_lt(c, 1030), c)

def fold.n473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{457}"
    case False{}:
      "\u{458}"

def fold.n474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45A}"
    case False{}:
      "\u{45B}"

def fold.n475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{459}"
    case False{}:
      fold.n474(U32.is_lt(c, 1035), c)

def fold.n476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n473(U32.is_lt(c, 1032), c)
    case False{}:
      fold.n475(U32.is_lt(c, 1034), c)

def fold.n477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n472(U32.is_lt(c, 1029), c)
    case False{}:
      fold.n476(U32.is_lt(c, 1033), c)

def fold.n478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n469(U32.is_lt(c, 1022), c)
    case False{}:
      fold.n477(U32.is_lt(c, 1031), c)

def fold.n479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n461(U32.is_lt(c, 1007), c)
    case False{}:
      fold.n478(U32.is_lt(c, 1027), c)

def fold.n480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n445(U32.is_lt(c, 982), c)
    case False{}:
      fold.n479(U32.is_lt(c, 1017), c)

def fold.n481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45C}"
    case False{}:
      "\u{45D}"

def fold.n482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{45E}"
    case False{}:
      "\u{45F}"

def fold.n483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n481(U32.is_lt(c, 1037), c)
    case False{}:
      fold.n482(U32.is_lt(c, 1039), c)

def fold.n484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{430}"
    case False{}:
      "\u{431}"

def fold.n485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{432}"
    case False{}:
      "\u{433}"

def fold.n486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n484(U32.is_lt(c, 1041), c)
    case False{}:
      fold.n485(U32.is_lt(c, 1043), c)

def fold.n487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n483(U32.is_lt(c, 1038), c)
    case False{}:
      fold.n486(U32.is_lt(c, 1042), c)

def fold.n488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{434}"
    case False{}:
      "\u{435}"

def fold.n489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{436}"
    case False{}:
      "\u{437}"

def fold.n490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n488(U32.is_lt(c, 1045), c)
    case False{}:
      fold.n489(U32.is_lt(c, 1047), c)

def fold.n491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{438}"
    case False{}:
      "\u{439}"

def fold.n492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43B}"
    case False{}:
      "\u{43C}"

def fold.n493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43A}"
    case False{}:
      fold.n492(U32.is_lt(c, 1052), c)

def fold.n494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n491(U32.is_lt(c, 1049), c)
    case False{}:
      fold.n493(U32.is_lt(c, 1051), c)

def fold.n495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n490(U32.is_lt(c, 1046), c)
    case False{}:
      fold.n494(U32.is_lt(c, 1050), c)

def fold.n496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n487(U32.is_lt(c, 1040), c)
    case False{}:
      fold.n495(U32.is_lt(c, 1048), c)

def fold.n497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43D}"
    case False{}:
      "\u{43E}"

def fold.n498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43F}"
    case False{}:
      "\u{440}"

def fold.n499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n497(U32.is_lt(c, 1054), c)
    case False{}:
      fold.n498(U32.is_lt(c, 1056), c)

def fold.n500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{441}"
    case False{}:
      "\u{442}"

def fold.n501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{444}"
    case False{}:
      "\u{445}"

def fold.n502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{443}"
    case False{}:
      fold.n501(U32.is_lt(c, 1061), c)

def fold.n503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n500(U32.is_lt(c, 1058), c)
    case False{}:
      fold.n502(U32.is_lt(c, 1060), c)

def fold.n504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n499(U32.is_lt(c, 1055), c)
    case False{}:
      fold.n503(U32.is_lt(c, 1059), c)

def fold.n505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{446}"
    case False{}:
      "\u{447}"

def fold.n506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{448}"
    case False{}:
      "\u{449}"

def fold.n507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n505(U32.is_lt(c, 1063), c)
    case False{}:
      fold.n506(U32.is_lt(c, 1065), c)

def fold.n508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44A}"
    case False{}:
      "\u{44B}"

def fold.n509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44D}"
    case False{}:
      "\u{44E}"

def fold.n510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44C}"
    case False{}:
      fold.n509(U32.is_lt(c, 1070), c)

def fold.n511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n508(U32.is_lt(c, 1067), c)
    case False{}:
      fold.n510(U32.is_lt(c, 1069), c)

def fold.n512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n507(U32.is_lt(c, 1064), c)
    case False{}:
      fold.n511(U32.is_lt(c, 1068), c)

def fold.n513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n504(U32.is_lt(c, 1057), c)
    case False{}:
      fold.n512(U32.is_lt(c, 1066), c)

def fold.n514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n496(U32.is_lt(c, 1044), c)
    case False{}:
      fold.n513(U32.is_lt(c, 1062), c)

def fold.n515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{44F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{461}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n515(U32.is_lt(c, 1072), c)
    case False{}:
      fold.n516(U32.is_lt(c, 1121), c)

def fold.n518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{463}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{465}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n518(U32.is_lt(c, 1123), c)
    case False{}:
      fold.n519(U32.is_lt(c, 1125), c)

def fold.n521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n517(U32.is_lt(c, 1120), c)
    case False{}:
      fold.n520(U32.is_lt(c, 1124), c)

def fold.n522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{467}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{469}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n522(U32.is_lt(c, 1127), c)
    case False{}:
      fold.n523(U32.is_lt(c, 1129), c)

def fold.n525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{46B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{46F}"

def fold.n527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{46D}"
    case False{}:
      fold.n526(U32.is_lt(c, 1134), c)

def fold.n528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n525(U32.is_lt(c, 1131), c)
    case False{}:
      fold.n527(U32.is_lt(c, 1133), c)

def fold.n529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n524(U32.is_lt(c, 1128), c)
    case False{}:
      fold.n528(U32.is_lt(c, 1132), c)

def fold.n530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n521(U32.is_lt(c, 1122), c)
    case False{}:
      fold.n529(U32.is_lt(c, 1130), c)

def fold.n531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{471}"

def fold.n532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{473}"

def fold.n533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n531(U32.is_lt(c, 1136), c)
    case False{}:
      fold.n532(U32.is_lt(c, 1138), c)

def fold.n534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{475}"

def fold.n535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{477}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n535(U32.is_lt(c, 1143), c)

def fold.n537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n534(U32.is_lt(c, 1140), c)
    case False{}:
      fold.n536(U32.is_lt(c, 1142), c)

def fold.n538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n533(U32.is_lt(c, 1137), c)
    case False{}:
      fold.n537(U32.is_lt(c, 1141), c)

def fold.n539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{479}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{47B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n539(U32.is_lt(c, 1145), c)
    case False{}:
      fold.n540(U32.is_lt(c, 1147), c)

def fold.n542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{47D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{481}"

def fold.n544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{47F}"
    case False{}:
      fold.n543(U32.is_lt(c, 1152), c)

def fold.n545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n542(U32.is_lt(c, 1149), c)
    case False{}:
      fold.n544(U32.is_lt(c, 1151), c)

def fold.n546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n541(U32.is_lt(c, 1146), c)
    case False{}:
      fold.n545(U32.is_lt(c, 1150), c)

def fold.n547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n538(U32.is_lt(c, 1139), c)
    case False{}:
      fold.n546(U32.is_lt(c, 1148), c)

def fold.n548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n530(U32.is_lt(c, 1126), c)
    case False{}:
      fold.n547(U32.is_lt(c, 1144), c)

def fold.n549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n514(U32.is_lt(c, 1053), c)
    case False{}:
      fold.n548(U32.is_lt(c, 1135), c)

def fold.n550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n480(U32.is_lt(c, 999), c)
    case False{}:
      fold.n549(U32.is_lt(c, 1071), c)

def fold.n551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n412(U32.is_lt(c, 557), c)
    case False{}:
      fold.n550(U32.is_lt(c, 1036), c)

def fold.n552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n275(U32.is_lt(c, 332), c)
    case False{}:
      fold.n551(U32.is_lt(c, 933), c)

def fold.n553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{48B}"

def fold.n554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{48D}"

def fold.n555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n553(U32.is_lt(c, 1162), c)
    case False{}:
      fold.n554(U32.is_lt(c, 1164), c)

def fold.n556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{48F}"

def fold.n557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{491}"

def fold.n558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n556(U32.is_lt(c, 1166), c)
    case False{}:
      fold.n557(U32.is_lt(c, 1168), c)

def fold.n559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n555(U32.is_lt(c, 1163), c)
    case False{}:
      fold.n558(U32.is_lt(c, 1167), c)

def fold.n560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{493}"

def fold.n561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{495}"

def fold.n562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n560(U32.is_lt(c, 1170), c)
    case False{}:
      fold.n561(U32.is_lt(c, 1172), c)

def fold.n563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{497}"

def fold.n564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{499}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n564(U32.is_lt(c, 1177), c)

def fold.n566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n563(U32.is_lt(c, 1174), c)
    case False{}:
      fold.n565(U32.is_lt(c, 1176), c)

def fold.n567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n562(U32.is_lt(c, 1171), c)
    case False{}:
      fold.n566(U32.is_lt(c, 1175), c)

def fold.n568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n559(U32.is_lt(c, 1165), c)
    case False{}:
      fold.n567(U32.is_lt(c, 1173), c)

def fold.n569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n569(U32.is_lt(c, 1179), c)
    case False{}:
      fold.n570(U32.is_lt(c, 1181), c)

def fold.n572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{49F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n572(U32.is_lt(c, 1183), c)
    case False{}:
      fold.n573(U32.is_lt(c, 1185), c)

def fold.n575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n571(U32.is_lt(c, 1180), c)
    case False{}:
      fold.n574(U32.is_lt(c, 1184), c)

def fold.n576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n576(U32.is_lt(c, 1187), c)
    case False{}:
      fold.n577(U32.is_lt(c, 1189), c)

def fold.n579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4AB}"

def fold.n581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4A9}"
    case False{}:
      fold.n580(U32.is_lt(c, 1194), c)

def fold.n582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n579(U32.is_lt(c, 1191), c)
    case False{}:
      fold.n581(U32.is_lt(c, 1193), c)

def fold.n583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n578(U32.is_lt(c, 1188), c)
    case False{}:
      fold.n582(U32.is_lt(c, 1192), c)

def fold.n584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n575(U32.is_lt(c, 1182), c)
    case False{}:
      fold.n583(U32.is_lt(c, 1190), c)

def fold.n585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n568(U32.is_lt(c, 1169), c)
    case False{}:
      fold.n584(U32.is_lt(c, 1186), c)

def fold.n586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4AD}"

def fold.n587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4AF}"

def fold.n588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n586(U32.is_lt(c, 1196), c)
    case False{}:
      fold.n587(U32.is_lt(c, 1198), c)

def fold.n589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B1}"

def fold.n590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B3}"

def fold.n591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n589(U32.is_lt(c, 1200), c)
    case False{}:
      fold.n590(U32.is_lt(c, 1202), c)

def fold.n592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n588(U32.is_lt(c, 1197), c)
    case False{}:
      fold.n591(U32.is_lt(c, 1201), c)

def fold.n593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B5}"

def fold.n594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B7}"

def fold.n595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n593(U32.is_lt(c, 1204), c)
    case False{}:
      fold.n594(U32.is_lt(c, 1206), c)

def fold.n596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4B9}"

def fold.n597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4BB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n597(U32.is_lt(c, 1211), c)

def fold.n599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n596(U32.is_lt(c, 1208), c)
    case False{}:
      fold.n598(U32.is_lt(c, 1210), c)

def fold.n600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n595(U32.is_lt(c, 1205), c)
    case False{}:
      fold.n599(U32.is_lt(c, 1209), c)

def fold.n601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n592(U32.is_lt(c, 1199), c)
    case False{}:
      fold.n600(U32.is_lt(c, 1207), c)

def fold.n602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4BD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4BF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n602(U32.is_lt(c, 1213), c)
    case False{}:
      fold.n603(U32.is_lt(c, 1215), c)

def fold.n605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4CF}"
    case False{}:
      "\u{4C2}"

def fold.n606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C4}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n606(U32.is_lt(c, 1220), c)

def fold.n608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n605(U32.is_lt(c, 1217), c)
    case False{}:
      fold.n607(U32.is_lt(c, 1219), c)

def fold.n609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n604(U32.is_lt(c, 1214), c)
    case False{}:
      fold.n608(U32.is_lt(c, 1218), c)

def fold.n610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C6}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4C8}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n610(U32.is_lt(c, 1222), c)
    case False{}:
      fold.n611(U32.is_lt(c, 1224), c)

def fold.n613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4CA}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4CE}"

def fold.n615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4CC}"
    case False{}:
      fold.n614(U32.is_lt(c, 1229), c)

def fold.n616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n613(U32.is_lt(c, 1226), c)
    case False{}:
      fold.n615(U32.is_lt(c, 1228), c)

def fold.n617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n612(U32.is_lt(c, 1223), c)
    case False{}:
      fold.n616(U32.is_lt(c, 1227), c)

def fold.n618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n609(U32.is_lt(c, 1216), c)
    case False{}:
      fold.n617(U32.is_lt(c, 1225), c)

def fold.n619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n601(U32.is_lt(c, 1203), c)
    case False{}:
      fold.n618(U32.is_lt(c, 1221), c)

def fold.n620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n585(U32.is_lt(c, 1178), c)
    case False{}:
      fold.n619(U32.is_lt(c, 1212), c)

def fold.n621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D1}"

def fold.n622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D3}"

def fold.n623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n621(U32.is_lt(c, 1232), c)
    case False{}:
      fold.n622(U32.is_lt(c, 1234), c)

def fold.n624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D5}"

def fold.n625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D7}"

def fold.n626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n624(U32.is_lt(c, 1236), c)
    case False{}:
      fold.n625(U32.is_lt(c, 1238), c)

def fold.n627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n623(U32.is_lt(c, 1233), c)
    case False{}:
      fold.n626(U32.is_lt(c, 1237), c)

def fold.n628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4D9}"

def fold.n629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4DB}"

def fold.n630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n628(U32.is_lt(c, 1240), c)
    case False{}:
      fold.n629(U32.is_lt(c, 1242), c)

def fold.n631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4DD}"

def fold.n632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4DF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n632(U32.is_lt(c, 1247), c)

def fold.n634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n631(U32.is_lt(c, 1244), c)
    case False{}:
      fold.n633(U32.is_lt(c, 1246), c)

def fold.n635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n630(U32.is_lt(c, 1241), c)
    case False{}:
      fold.n634(U32.is_lt(c, 1245), c)

def fold.n636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n627(U32.is_lt(c, 1235), c)
    case False{}:
      fold.n635(U32.is_lt(c, 1243), c)

def fold.n637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n637(U32.is_lt(c, 1249), c)
    case False{}:
      fold.n638(U32.is_lt(c, 1251), c)

def fold.n640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n640(U32.is_lt(c, 1253), c)
    case False{}:
      fold.n641(U32.is_lt(c, 1255), c)

def fold.n643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n639(U32.is_lt(c, 1250), c)
    case False{}:
      fold.n642(U32.is_lt(c, 1254), c)

def fold.n644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4E9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4EB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n644(U32.is_lt(c, 1257), c)
    case False{}:
      fold.n645(U32.is_lt(c, 1259), c)

def fold.n647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4ED}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F1}"

def fold.n649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{4EF}"
    case False{}:
      fold.n648(U32.is_lt(c, 1264), c)

def fold.n650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n647(U32.is_lt(c, 1261), c)
    case False{}:
      fold.n649(U32.is_lt(c, 1263), c)

def fold.n651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n646(U32.is_lt(c, 1258), c)
    case False{}:
      fold.n650(U32.is_lt(c, 1262), c)

def fold.n652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n643(U32.is_lt(c, 1252), c)
    case False{}:
      fold.n651(U32.is_lt(c, 1260), c)

def fold.n653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n636(U32.is_lt(c, 1239), c)
    case False{}:
      fold.n652(U32.is_lt(c, 1256), c)

def fold.n654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F3}"

def fold.n655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F5}"

def fold.n656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n654(U32.is_lt(c, 1266), c)
    case False{}:
      fold.n655(U32.is_lt(c, 1268), c)

def fold.n657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F7}"

def fold.n658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4F9}"

def fold.n659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n657(U32.is_lt(c, 1270), c)
    case False{}:
      fold.n658(U32.is_lt(c, 1272), c)

def fold.n660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n656(U32.is_lt(c, 1267), c)
    case False{}:
      fold.n659(U32.is_lt(c, 1271), c)

def fold.n661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4FB}"

def fold.n662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4FD}"

def fold.n663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n661(U32.is_lt(c, 1274), c)
    case False{}:
      fold.n662(U32.is_lt(c, 1276), c)

def fold.n664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{4FF}"

def fold.n665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{501}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n665(U32.is_lt(c, 1281), c)

def fold.n667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n664(U32.is_lt(c, 1278), c)
    case False{}:
      fold.n666(U32.is_lt(c, 1280), c)

def fold.n668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n663(U32.is_lt(c, 1275), c)
    case False{}:
      fold.n667(U32.is_lt(c, 1279), c)

def fold.n669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n660(U32.is_lt(c, 1269), c)
    case False{}:
      fold.n668(U32.is_lt(c, 1277), c)

def fold.n670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{503}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{505}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n670(U32.is_lt(c, 1283), c)
    case False{}:
      fold.n671(U32.is_lt(c, 1285), c)

def fold.n673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{507}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{50B}"

def fold.n675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{509}"
    case False{}:
      fold.n674(U32.is_lt(c, 1290), c)

def fold.n676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n673(U32.is_lt(c, 1287), c)
    case False{}:
      fold.n675(U32.is_lt(c, 1289), c)

def fold.n677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n672(U32.is_lt(c, 1284), c)
    case False{}:
      fold.n676(U32.is_lt(c, 1288), c)

def fold.n678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{50D}"

def fold.n679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{50F}"

def fold.n680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n678(U32.is_lt(c, 1292), c)
    case False{}:
      fold.n679(U32.is_lt(c, 1294), c)

def fold.n681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{511}"

def fold.n682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{513}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n682(U32.is_lt(c, 1299), c)

def fold.n684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n681(U32.is_lt(c, 1296), c)
    case False{}:
      fold.n683(U32.is_lt(c, 1298), c)

def fold.n685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n680(U32.is_lt(c, 1293), c)
    case False{}:
      fold.n684(U32.is_lt(c, 1297), c)

def fold.n686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n677(U32.is_lt(c, 1286), c)
    case False{}:
      fold.n685(U32.is_lt(c, 1295), c)

def fold.n687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n669(U32.is_lt(c, 1273), c)
    case False{}:
      fold.n686(U32.is_lt(c, 1291), c)

def fold.n688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n653(U32.is_lt(c, 1248), c)
    case False{}:
      fold.n687(U32.is_lt(c, 1282), c)

def fold.n689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n620(U32.is_lt(c, 1195), c)
    case False{}:
      fold.n688(U32.is_lt(c, 1265), c)

def fold.n690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{515}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{517}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n690(U32.is_lt(c, 1301), c)
    case False{}:
      fold.n691(U32.is_lt(c, 1303), c)

def fold.n693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{519}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n693(U32.is_lt(c, 1305), c)
    case False{}:
      fold.n694(U32.is_lt(c, 1307), c)

def fold.n696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n692(U32.is_lt(c, 1302), c)
    case False{}:
      fold.n695(U32.is_lt(c, 1306), c)

def fold.n697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{51F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n697(U32.is_lt(c, 1309), c)
    case False{}:
      fold.n698(U32.is_lt(c, 1311), c)

def fold.n700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{521}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{525}"

def fold.n702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{523}"
    case False{}:
      fold.n701(U32.is_lt(c, 1316), c)

def fold.n703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n700(U32.is_lt(c, 1313), c)
    case False{}:
      fold.n702(U32.is_lt(c, 1315), c)

def fold.n704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n699(U32.is_lt(c, 1310), c)
    case False{}:
      fold.n703(U32.is_lt(c, 1314), c)

def fold.n705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n696(U32.is_lt(c, 1304), c)
    case False{}:
      fold.n704(U32.is_lt(c, 1312), c)

def fold.n706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{527}"

def fold.n707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{529}"

def fold.n708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n706(U32.is_lt(c, 1318), c)
    case False{}:
      fold.n707(U32.is_lt(c, 1320), c)

def fold.n709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{52B}"

def fold.n710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{52D}"

def fold.n711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n709(U32.is_lt(c, 1322), c)
    case False{}:
      fold.n710(U32.is_lt(c, 1324), c)

def fold.n712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n708(U32.is_lt(c, 1319), c)
    case False{}:
      fold.n711(U32.is_lt(c, 1323), c)

def fold.n713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{52F}"

def fold.n714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{561}"

def fold.n715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n713(U32.is_lt(c, 1326), c)
    case False{}:
      fold.n714(U32.is_lt(c, 1329), c)

def fold.n716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{562}"
    case False{}:
      "\u{563}"

def fold.n717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{565}"
    case False{}:
      "\u{566}"

def fold.n718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{564}"
    case False{}:
      fold.n717(U32.is_lt(c, 1334), c)

def fold.n719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n716(U32.is_lt(c, 1331), c)
    case False{}:
      fold.n718(U32.is_lt(c, 1333), c)

def fold.n720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n715(U32.is_lt(c, 1327), c)
    case False{}:
      fold.n719(U32.is_lt(c, 1332), c)

def fold.n721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n712(U32.is_lt(c, 1321), c)
    case False{}:
      fold.n720(U32.is_lt(c, 1330), c)

def fold.n722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n705(U32.is_lt(c, 1308), c)
    case False{}:
      fold.n721(U32.is_lt(c, 1325), c)

def fold.n723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{567}"
    case False{}:
      "\u{568}"

def fold.n724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{569}"
    case False{}:
      "\u{56A}"

def fold.n725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n723(U32.is_lt(c, 1336), c)
    case False{}:
      fold.n724(U32.is_lt(c, 1338), c)

def fold.n726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{56B}"
    case False{}:
      "\u{56C}"

def fold.n727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{56D}"
    case False{}:
      "\u{56E}"

def fold.n728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n726(U32.is_lt(c, 1340), c)
    case False{}:
      fold.n727(U32.is_lt(c, 1342), c)

def fold.n729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n725(U32.is_lt(c, 1337), c)
    case False{}:
      fold.n728(U32.is_lt(c, 1341), c)

def fold.n730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{56F}"
    case False{}:
      "\u{570}"

def fold.n731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{571}"
    case False{}:
      "\u{572}"

def fold.n732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n730(U32.is_lt(c, 1344), c)
    case False{}:
      fold.n731(U32.is_lt(c, 1346), c)

def fold.n733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{573}"
    case False{}:
      "\u{574}"

def fold.n734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{576}"
    case False{}:
      "\u{577}"

def fold.n735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{575}"
    case False{}:
      fold.n734(U32.is_lt(c, 1351), c)

def fold.n736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n733(U32.is_lt(c, 1348), c)
    case False{}:
      fold.n735(U32.is_lt(c, 1350), c)

def fold.n737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n732(U32.is_lt(c, 1345), c)
    case False{}:
      fold.n736(U32.is_lt(c, 1349), c)

def fold.n738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n729(U32.is_lt(c, 1339), c)
    case False{}:
      fold.n737(U32.is_lt(c, 1347), c)

def fold.n739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{578}"
    case False{}:
      "\u{579}"

def fold.n740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57A}"
    case False{}:
      "\u{57B}"

def fold.n741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n739(U32.is_lt(c, 1353), c)
    case False{}:
      fold.n740(U32.is_lt(c, 1355), c)

def fold.n742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57C}"
    case False{}:
      "\u{57D}"

def fold.n743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57F}"
    case False{}:
      "\u{580}"

def fold.n744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{57E}"
    case False{}:
      fold.n743(U32.is_lt(c, 1360), c)

def fold.n745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n742(U32.is_lt(c, 1357), c)
    case False{}:
      fold.n744(U32.is_lt(c, 1359), c)

def fold.n746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n741(U32.is_lt(c, 1354), c)
    case False{}:
      fold.n745(U32.is_lt(c, 1358), c)

def fold.n747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{581}"
    case False{}:
      "\u{582}"

def fold.n748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{583}"
    case False{}:
      "\u{584}"

def fold.n749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n747(U32.is_lt(c, 1362), c)
    case False{}:
      fold.n748(U32.is_lt(c, 1364), c)

def fold.n750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{585}"
    case False{}:
      "\u{586}"

def fold.n751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{565}\u{582}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n751(U32.is_lt(c, 1416), c)

def fold.n753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n750(U32.is_lt(c, 1366), c)
    case False{}:
      fold.n752(U32.is_lt(c, 1415), c)

def fold.n754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n749(U32.is_lt(c, 1363), c)
    case False{}:
      fold.n753(U32.is_lt(c, 1367), c)

def fold.n755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n746(U32.is_lt(c, 1356), c)
    case False{}:
      fold.n754(U32.is_lt(c, 1365), c)

def fold.n756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n738(U32.is_lt(c, 1343), c)
    case False{}:
      fold.n755(U32.is_lt(c, 1361), c)

def fold.n757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n722(U32.is_lt(c, 1317), c)
    case False{}:
      fold.n756(U32.is_lt(c, 1352), c)

def fold.n758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D00}"
    case False{}:
      "\u{2D01}"

def fold.n759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D02}"
    case False{}:
      "\u{2D03}"

def fold.n760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n758(U32.is_lt(c, 4257), c)
    case False{}:
      fold.n759(U32.is_lt(c, 4259), c)

def fold.n761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D04}"
    case False{}:
      "\u{2D05}"

def fold.n762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D06}"
    case False{}:
      "\u{2D07}"

def fold.n763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n761(U32.is_lt(c, 4261), c)
    case False{}:
      fold.n762(U32.is_lt(c, 4263), c)

def fold.n764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n760(U32.is_lt(c, 4258), c)
    case False{}:
      fold.n763(U32.is_lt(c, 4262), c)

def fold.n765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D08}"
    case False{}:
      "\u{2D09}"

def fold.n766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D0A}"
    case False{}:
      "\u{2D0B}"

def fold.n767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n765(U32.is_lt(c, 4265), c)
    case False{}:
      fold.n766(U32.is_lt(c, 4267), c)

def fold.n768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D0C}"
    case False{}:
      "\u{2D0D}"

def fold.n769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D0F}"
    case False{}:
      "\u{2D10}"

def fold.n770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D0E}"
    case False{}:
      fold.n769(U32.is_lt(c, 4272), c)

def fold.n771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n768(U32.is_lt(c, 4269), c)
    case False{}:
      fold.n770(U32.is_lt(c, 4271), c)

def fold.n772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n767(U32.is_lt(c, 4266), c)
    case False{}:
      fold.n771(U32.is_lt(c, 4270), c)

def fold.n773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n764(U32.is_lt(c, 4260), c)
    case False{}:
      fold.n772(U32.is_lt(c, 4268), c)

def fold.n774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D11}"
    case False{}:
      "\u{2D12}"

def fold.n775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D13}"
    case False{}:
      "\u{2D14}"

def fold.n776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n774(U32.is_lt(c, 4274), c)
    case False{}:
      fold.n775(U32.is_lt(c, 4276), c)

def fold.n777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D15}"
    case False{}:
      "\u{2D16}"

def fold.n778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D18}"
    case False{}:
      "\u{2D19}"

def fold.n779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D17}"
    case False{}:
      fold.n778(U32.is_lt(c, 4281), c)

def fold.n780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n777(U32.is_lt(c, 4278), c)
    case False{}:
      fold.n779(U32.is_lt(c, 4280), c)

def fold.n781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n776(U32.is_lt(c, 4275), c)
    case False{}:
      fold.n780(U32.is_lt(c, 4279), c)

def fold.n782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D1A}"
    case False{}:
      "\u{2D1B}"

def fold.n783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D1C}"
    case False{}:
      "\u{2D1D}"

def fold.n784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n782(U32.is_lt(c, 4283), c)
    case False{}:
      fold.n783(U32.is_lt(c, 4285), c)

def fold.n785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D1E}"
    case False{}:
      "\u{2D1F}"

def fold.n786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D21}"
    case False{}:
      "\u{2D22}"

def fold.n787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D20}"
    case False{}:
      fold.n786(U32.is_lt(c, 4290), c)

def fold.n788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n785(U32.is_lt(c, 4287), c)
    case False{}:
      fold.n787(U32.is_lt(c, 4289), c)

def fold.n789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n784(U32.is_lt(c, 4284), c)
    case False{}:
      fold.n788(U32.is_lt(c, 4288), c)

def fold.n790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n781(U32.is_lt(c, 4277), c)
    case False{}:
      fold.n789(U32.is_lt(c, 4286), c)

def fold.n791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n773(U32.is_lt(c, 4264), c)
    case False{}:
      fold.n790(U32.is_lt(c, 4282), c)

def fold.n792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D23}"
    case False{}:
      "\u{2D24}"

def fold.n793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D25}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n792(U32.is_lt(c, 4292), c)
    case False{}:
      fold.n793(U32.is_lt(c, 4294), c)

def fold.n795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D27}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2D2D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n795(U32.is_lt(c, 4296), c)
    case False{}:
      fold.n796(U32.is_lt(c, 4302), c)

def fold.n798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n794(U32.is_lt(c, 4293), c)
    case False{}:
      fold.n797(U32.is_lt(c, 4301), c)

def fold.n799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13F0}"
    case False{}:
      "\u{13F1}"

def fold.n800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13F2}"
    case False{}:
      "\u{13F3}"

def fold.n801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n799(U32.is_lt(c, 5113), c)
    case False{}:
      fold.n800(U32.is_lt(c, 5115), c)

def fold.n802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13F4}"
    case False{}:
      "\u{13F5}"

def fold.n803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{432}"
    case False{}:
      "\u{434}"

def fold.n804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n803(U32.is_lt(c, 7297), c)

def fold.n805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n802(U32.is_lt(c, 5117), c)
    case False{}:
      fold.n804(U32.is_lt(c, 7296), c)

def fold.n806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n801(U32.is_lt(c, 5114), c)
    case False{}:
      fold.n805(U32.is_lt(c, 5118), c)

def fold.n807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n798(U32.is_lt(c, 4295), c)
    case False{}:
      fold.n806(U32.is_lt(c, 5116), c)

def fold.n808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{43E}"
    case False{}:
      "\u{441}"

def fold.n809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{442}"
    case False{}:
      "\u{44A}"

def fold.n810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n808(U32.is_lt(c, 7299), c)
    case False{}:
      fold.n809(U32.is_lt(c, 7302), c)

def fold.n811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{463}"
    case False{}:
      "\u{A64B}"

def fold.n812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{10D0}"

def fold.n813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1C8A}"
    case False{}:
      fold.n812(U32.is_lt(c, 7312), c)

def fold.n814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n811(U32.is_lt(c, 7304), c)
    case False{}:
      fold.n813(U32.is_lt(c, 7306), c)

def fold.n815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n810(U32.is_lt(c, 7300), c)
    case False{}:
      fold.n814(U32.is_lt(c, 7305), c)

def fold.n816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D1}"
    case False{}:
      "\u{10D2}"

def fold.n817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D3}"
    case False{}:
      "\u{10D4}"

def fold.n818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n816(U32.is_lt(c, 7314), c)
    case False{}:
      fold.n817(U32.is_lt(c, 7316), c)

def fold.n819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D5}"
    case False{}:
      "\u{10D6}"

def fold.n820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D8}"
    case False{}:
      "\u{10D9}"

def fold.n821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D7}"
    case False{}:
      fold.n820(U32.is_lt(c, 7321), c)

def fold.n822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n819(U32.is_lt(c, 7318), c)
    case False{}:
      fold.n821(U32.is_lt(c, 7320), c)

def fold.n823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n818(U32.is_lt(c, 7315), c)
    case False{}:
      fold.n822(U32.is_lt(c, 7319), c)

def fold.n824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n815(U32.is_lt(c, 7303), c)
    case False{}:
      fold.n823(U32.is_lt(c, 7317), c)

def fold.n825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n807(U32.is_lt(c, 5112), c)
    case False{}:
      fold.n824(U32.is_lt(c, 7313), c)

def fold.n826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n791(U32.is_lt(c, 4273), c)
    case False{}:
      fold.n825(U32.is_lt(c, 7298), c)

def fold.n827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n757(U32.is_lt(c, 1335), c)
    case False{}:
      fold.n826(U32.is_lt(c, 4291), c)

def fold.n828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n689(U32.is_lt(c, 1230), c)
    case False{}:
      fold.n827(U32.is_lt(c, 4256), c)

def fold.n829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10DA}"
    case False{}:
      "\u{10DB}"

def fold.n830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10DC}"
    case False{}:
      "\u{10DD}"

def fold.n831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n829(U32.is_lt(c, 7323), c)
    case False{}:
      fold.n830(U32.is_lt(c, 7325), c)

def fold.n832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10DE}"
    case False{}:
      "\u{10DF}"

def fold.n833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E0}"
    case False{}:
      "\u{10E1}"

def fold.n834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n832(U32.is_lt(c, 7327), c)
    case False{}:
      fold.n833(U32.is_lt(c, 7329), c)

def fold.n835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n831(U32.is_lt(c, 7324), c)
    case False{}:
      fold.n834(U32.is_lt(c, 7328), c)

def fold.n836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E2}"
    case False{}:
      "\u{10E3}"

def fold.n837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E4}"
    case False{}:
      "\u{10E5}"

def fold.n838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n836(U32.is_lt(c, 7331), c)
    case False{}:
      fold.n837(U32.is_lt(c, 7333), c)

def fold.n839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E6}"
    case False{}:
      "\u{10E7}"

def fold.n840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E9}"
    case False{}:
      "\u{10EA}"

def fold.n841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10E8}"
    case False{}:
      fold.n840(U32.is_lt(c, 7338), c)

def fold.n842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n839(U32.is_lt(c, 7335), c)
    case False{}:
      fold.n841(U32.is_lt(c, 7337), c)

def fold.n843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n838(U32.is_lt(c, 7332), c)
    case False{}:
      fold.n842(U32.is_lt(c, 7336), c)

def fold.n844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n835(U32.is_lt(c, 7326), c)
    case False{}:
      fold.n843(U32.is_lt(c, 7334), c)

def fold.n845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10EB}"
    case False{}:
      "\u{10EC}"

def fold.n846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10ED}"
    case False{}:
      "\u{10EE}"

def fold.n847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n845(U32.is_lt(c, 7340), c)
    case False{}:
      fold.n846(U32.is_lt(c, 7342), c)

def fold.n848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10EF}"
    case False{}:
      "\u{10F0}"

def fold.n849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F1}"
    case False{}:
      "\u{10F2}"

def fold.n850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n848(U32.is_lt(c, 7344), c)
    case False{}:
      fold.n849(U32.is_lt(c, 7346), c)

def fold.n851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n847(U32.is_lt(c, 7341), c)
    case False{}:
      fold.n850(U32.is_lt(c, 7345), c)

def fold.n852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F3}"
    case False{}:
      "\u{10F4}"

def fold.n853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F5}"
    case False{}:
      "\u{10F6}"

def fold.n854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n852(U32.is_lt(c, 7348), c)
    case False{}:
      fold.n853(U32.is_lt(c, 7350), c)

def fold.n855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F7}"
    case False{}:
      "\u{10F8}"

def fold.n856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10FA}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10F9}"
    case False{}:
      fold.n856(U32.is_lt(c, 7355), c)

def fold.n858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n855(U32.is_lt(c, 7352), c)
    case False{}:
      fold.n857(U32.is_lt(c, 7354), c)

def fold.n859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n854(U32.is_lt(c, 7349), c)
    case False{}:
      fold.n858(U32.is_lt(c, 7353), c)

def fold.n860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n851(U32.is_lt(c, 7343), c)
    case False{}:
      fold.n859(U32.is_lt(c, 7351), c)

def fold.n861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n844(U32.is_lt(c, 7330), c)
    case False{}:
      fold.n860(U32.is_lt(c, 7347), c)

def fold.n862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10FD}"
    case False{}:
      "\u{10FE}"

def fold.n863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10FF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n862(U32.is_lt(c, 7358), c)
    case False{}:
      fold.n863(U32.is_lt(c, 7360), c)

def fold.n865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E01}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E03}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n865(U32.is_lt(c, 7681), c)
    case False{}:
      fold.n866(U32.is_lt(c, 7683), c)

def fold.n868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n864(U32.is_lt(c, 7359), c)
    case False{}:
      fold.n867(U32.is_lt(c, 7682), c)

def fold.n869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E05}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E07}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n869(U32.is_lt(c, 7685), c)
    case False{}:
      fold.n870(U32.is_lt(c, 7687), c)

def fold.n872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E09}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E0D}"

def fold.n874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E0B}"
    case False{}:
      fold.n873(U32.is_lt(c, 7692), c)

def fold.n875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n872(U32.is_lt(c, 7689), c)
    case False{}:
      fold.n874(U32.is_lt(c, 7691), c)

def fold.n876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n871(U32.is_lt(c, 7686), c)
    case False{}:
      fold.n875(U32.is_lt(c, 7690), c)

def fold.n877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n868(U32.is_lt(c, 7680), c)
    case False{}:
      fold.n876(U32.is_lt(c, 7688), c)

def fold.n878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E0F}"

def fold.n879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E11}"

def fold.n880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n878(U32.is_lt(c, 7694), c)
    case False{}:
      fold.n879(U32.is_lt(c, 7696), c)

def fold.n881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E13}"

def fold.n882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E15}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n882(U32.is_lt(c, 7701), c)

def fold.n884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n881(U32.is_lt(c, 7698), c)
    case False{}:
      fold.n883(U32.is_lt(c, 7700), c)

def fold.n885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n880(U32.is_lt(c, 7695), c)
    case False{}:
      fold.n884(U32.is_lt(c, 7699), c)

def fold.n886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E17}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E19}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n886(U32.is_lt(c, 7703), c)
    case False{}:
      fold.n887(U32.is_lt(c, 7705), c)

def fold.n889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E1B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E1F}"

def fold.n891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E1D}"
    case False{}:
      fold.n890(U32.is_lt(c, 7710), c)

def fold.n892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n889(U32.is_lt(c, 7707), c)
    case False{}:
      fold.n891(U32.is_lt(c, 7709), c)

def fold.n893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n888(U32.is_lt(c, 7704), c)
    case False{}:
      fold.n892(U32.is_lt(c, 7708), c)

def fold.n894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n885(U32.is_lt(c, 7697), c)
    case False{}:
      fold.n893(U32.is_lt(c, 7706), c)

def fold.n895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n877(U32.is_lt(c, 7684), c)
    case False{}:
      fold.n894(U32.is_lt(c, 7702), c)

def fold.n896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n861(U32.is_lt(c, 7339), c)
    case False{}:
      fold.n895(U32.is_lt(c, 7693), c)

def fold.n897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E21}"

def fold.n898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E23}"

def fold.n899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n897(U32.is_lt(c, 7712), c)
    case False{}:
      fold.n898(U32.is_lt(c, 7714), c)

def fold.n900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E25}"

def fold.n901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E27}"

def fold.n902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n900(U32.is_lt(c, 7716), c)
    case False{}:
      fold.n901(U32.is_lt(c, 7718), c)

def fold.n903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n899(U32.is_lt(c, 7713), c)
    case False{}:
      fold.n902(U32.is_lt(c, 7717), c)

def fold.n904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E29}"

def fold.n905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E2B}"

def fold.n906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n904(U32.is_lt(c, 7720), c)
    case False{}:
      fold.n905(U32.is_lt(c, 7722), c)

def fold.n907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E2D}"

def fold.n908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E2F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n908(U32.is_lt(c, 7727), c)

def fold.n910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n907(U32.is_lt(c, 7724), c)
    case False{}:
      fold.n909(U32.is_lt(c, 7726), c)

def fold.n911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n906(U32.is_lt(c, 7721), c)
    case False{}:
      fold.n910(U32.is_lt(c, 7725), c)

def fold.n912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n903(U32.is_lt(c, 7715), c)
    case False{}:
      fold.n911(U32.is_lt(c, 7723), c)

def fold.n913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E31}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E33}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n913(U32.is_lt(c, 7729), c)
    case False{}:
      fold.n914(U32.is_lt(c, 7731), c)

def fold.n916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E35}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E37}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n916(U32.is_lt(c, 7733), c)
    case False{}:
      fold.n917(U32.is_lt(c, 7735), c)

def fold.n919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n915(U32.is_lt(c, 7730), c)
    case False{}:
      fold.n918(U32.is_lt(c, 7734), c)

def fold.n920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E39}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E3B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n920(U32.is_lt(c, 7737), c)
    case False{}:
      fold.n921(U32.is_lt(c, 7739), c)

def fold.n923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E3D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E41}"

def fold.n925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E3F}"
    case False{}:
      fold.n924(U32.is_lt(c, 7744), c)

def fold.n926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n923(U32.is_lt(c, 7741), c)
    case False{}:
      fold.n925(U32.is_lt(c, 7743), c)

def fold.n927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n922(U32.is_lt(c, 7738), c)
    case False{}:
      fold.n926(U32.is_lt(c, 7742), c)

def fold.n928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n919(U32.is_lt(c, 7732), c)
    case False{}:
      fold.n927(U32.is_lt(c, 7740), c)

def fold.n929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n912(U32.is_lt(c, 7719), c)
    case False{}:
      fold.n928(U32.is_lt(c, 7736), c)

def fold.n930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E43}"

def fold.n931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E45}"

def fold.n932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n930(U32.is_lt(c, 7746), c)
    case False{}:
      fold.n931(U32.is_lt(c, 7748), c)

def fold.n933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E47}"

def fold.n934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E49}"

def fold.n935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n933(U32.is_lt(c, 7750), c)
    case False{}:
      fold.n934(U32.is_lt(c, 7752), c)

def fold.n936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n932(U32.is_lt(c, 7747), c)
    case False{}:
      fold.n935(U32.is_lt(c, 7751), c)

def fold.n937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E4B}"

def fold.n938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E4D}"

def fold.n939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n937(U32.is_lt(c, 7754), c)
    case False{}:
      fold.n938(U32.is_lt(c, 7756), c)

def fold.n940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E4F}"

def fold.n941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E51}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n941(U32.is_lt(c, 7761), c)

def fold.n943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n940(U32.is_lt(c, 7758), c)
    case False{}:
      fold.n942(U32.is_lt(c, 7760), c)

def fold.n944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n939(U32.is_lt(c, 7755), c)
    case False{}:
      fold.n943(U32.is_lt(c, 7759), c)

def fold.n945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n936(U32.is_lt(c, 7749), c)
    case False{}:
      fold.n944(U32.is_lt(c, 7757), c)

def fold.n946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E53}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E55}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n946(U32.is_lt(c, 7763), c)
    case False{}:
      fold.n947(U32.is_lt(c, 7765), c)

def fold.n949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E57}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E5B}"

def fold.n951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E59}"
    case False{}:
      fold.n950(U32.is_lt(c, 7770), c)

def fold.n952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n949(U32.is_lt(c, 7767), c)
    case False{}:
      fold.n951(U32.is_lt(c, 7769), c)

def fold.n953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n948(U32.is_lt(c, 7764), c)
    case False{}:
      fold.n952(U32.is_lt(c, 7768), c)

def fold.n954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E5D}"

def fold.n955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E5F}"

def fold.n956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n954(U32.is_lt(c, 7772), c)
    case False{}:
      fold.n955(U32.is_lt(c, 7774), c)

def fold.n957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E61}"

def fold.n958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E63}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n958(U32.is_lt(c, 7779), c)

def fold.n960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n957(U32.is_lt(c, 7776), c)
    case False{}:
      fold.n959(U32.is_lt(c, 7778), c)

def fold.n961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n956(U32.is_lt(c, 7773), c)
    case False{}:
      fold.n960(U32.is_lt(c, 7777), c)

def fold.n962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n953(U32.is_lt(c, 7766), c)
    case False{}:
      fold.n961(U32.is_lt(c, 7775), c)

def fold.n963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n945(U32.is_lt(c, 7753), c)
    case False{}:
      fold.n962(U32.is_lt(c, 7771), c)

def fold.n964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n929(U32.is_lt(c, 7728), c)
    case False{}:
      fold.n963(U32.is_lt(c, 7762), c)

def fold.n965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n896(U32.is_lt(c, 7357), c)
    case False{}:
      fold.n964(U32.is_lt(c, 7745), c)

def fold.n966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E65}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E67}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n966(U32.is_lt(c, 7781), c)
    case False{}:
      fold.n967(U32.is_lt(c, 7783), c)

def fold.n969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E69}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E6B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n969(U32.is_lt(c, 7785), c)
    case False{}:
      fold.n970(U32.is_lt(c, 7787), c)

def fold.n972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n968(U32.is_lt(c, 7782), c)
    case False{}:
      fold.n971(U32.is_lt(c, 7786), c)

def fold.n973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E6D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E6F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n973(U32.is_lt(c, 7789), c)
    case False{}:
      fold.n974(U32.is_lt(c, 7791), c)

def fold.n976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E71}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E75}"

def fold.n978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E73}"
    case False{}:
      fold.n977(U32.is_lt(c, 7796), c)

def fold.n979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n976(U32.is_lt(c, 7793), c)
    case False{}:
      fold.n978(U32.is_lt(c, 7795), c)

def fold.n980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n975(U32.is_lt(c, 7790), c)
    case False{}:
      fold.n979(U32.is_lt(c, 7794), c)

def fold.n981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n972(U32.is_lt(c, 7784), c)
    case False{}:
      fold.n980(U32.is_lt(c, 7792), c)

def fold.n982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E77}"

def fold.n983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E79}"

def fold.n984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n982(U32.is_lt(c, 7798), c)
    case False{}:
      fold.n983(U32.is_lt(c, 7800), c)

def fold.n985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E7B}"

def fold.n986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E7D}"

def fold.n987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n985(U32.is_lt(c, 7802), c)
    case False{}:
      fold.n986(U32.is_lt(c, 7804), c)

def fold.n988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n984(U32.is_lt(c, 7799), c)
    case False{}:
      fold.n987(U32.is_lt(c, 7803), c)

def fold.n989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E7F}"

def fold.n990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E81}"

def fold.n991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n989(U32.is_lt(c, 7806), c)
    case False{}:
      fold.n990(U32.is_lt(c, 7808), c)

def fold.n992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1E83}"

def fold.n993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E85}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n993(U32.is_lt(c, 7813), c)

def fold.n995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n992(U32.is_lt(c, 7810), c)
    case False{}:
      fold.n994(U32.is_lt(c, 7812), c)

def fold.n996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n991(U32.is_lt(c, 7807), c)
    case False{}:
      fold.n995(U32.is_lt(c, 7811), c)

def fold.n997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n988(U32.is_lt(c, 7801), c)
    case False{}:
      fold.n996(U32.is_lt(c, 7809), c)

def fold.n998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n981(U32.is_lt(c, 7788), c)
    case False{}:
      fold.n997(U32.is_lt(c, 7805), c)

def fold.n999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E87}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E89}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n999(U32.is_lt(c, 7815), c)
    case False{}:
      fold.n1000(U32.is_lt(c, 7817), c)

def fold.n1002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E8B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E8D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1002(U32.is_lt(c, 7819), c)
    case False{}:
      fold.n1003(U32.is_lt(c, 7821), c)

def fold.n1005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1001(U32.is_lt(c, 7816), c)
    case False{}:
      fold.n1004(U32.is_lt(c, 7820), c)

def fold.n1006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E8F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E91}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1006(U32.is_lt(c, 7823), c)
    case False{}:
      fold.n1007(U32.is_lt(c, 7825), c)

def fold.n1009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E93}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{68}\u{331}"

def fold.n1011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E95}"
    case False{}:
      fold.n1010(U32.is_lt(c, 7830), c)

def fold.n1012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1009(U32.is_lt(c, 7827), c)
    case False{}:
      fold.n1011(U32.is_lt(c, 7829), c)

def fold.n1013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1008(U32.is_lt(c, 7824), c)
    case False{}:
      fold.n1012(U32.is_lt(c, 7828), c)

def fold.n1014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1005(U32.is_lt(c, 7818), c)
    case False{}:
      fold.n1013(U32.is_lt(c, 7826), c)

def fold.n1015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{74}\u{308}"
    case False{}:
      "\u{77}\u{30A}"

def fold.n1016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{79}\u{30A}"
    case False{}:
      "\u{61}\u{2BE}"

def fold.n1017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1015(U32.is_lt(c, 7832), c)
    case False{}:
      fold.n1016(U32.is_lt(c, 7834), c)

def fold.n1018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E61}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EA1}"

def fold.n1020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{73}\u{73}"
    case False{}:
      fold.n1019(U32.is_lt(c, 7840), c)

def fold.n1021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1018(U32.is_lt(c, 7836), c)
    case False{}:
      fold.n1020(U32.is_lt(c, 7839), c)

def fold.n1022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1017(U32.is_lt(c, 7833), c)
    case False{}:
      fold.n1021(U32.is_lt(c, 7838), c)

def fold.n1023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EA3}"

def fold.n1024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EA5}"

def fold.n1025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1023(U32.is_lt(c, 7842), c)
    case False{}:
      fold.n1024(U32.is_lt(c, 7844), c)

def fold.n1026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EA7}"

def fold.n1027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EA9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1027(U32.is_lt(c, 7849), c)

def fold.n1029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1026(U32.is_lt(c, 7846), c)
    case False{}:
      fold.n1028(U32.is_lt(c, 7848), c)

def fold.n1030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1025(U32.is_lt(c, 7843), c)
    case False{}:
      fold.n1029(U32.is_lt(c, 7847), c)

def fold.n1031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1022(U32.is_lt(c, 7835), c)
    case False{}:
      fold.n1030(U32.is_lt(c, 7845), c)

def fold.n1032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1014(U32.is_lt(c, 7822), c)
    case False{}:
      fold.n1031(U32.is_lt(c, 7841), c)

def fold.n1033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n998(U32.is_lt(c, 7797), c)
    case False{}:
      fold.n1032(U32.is_lt(c, 7831), c)

def fold.n1034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EAB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EAD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1034(U32.is_lt(c, 7851), c)
    case False{}:
      fold.n1035(U32.is_lt(c, 7853), c)

def fold.n1037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EAF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EB1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1037(U32.is_lt(c, 7855), c)
    case False{}:
      fold.n1038(U32.is_lt(c, 7857), c)

def fold.n1040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1036(U32.is_lt(c, 7852), c)
    case False{}:
      fold.n1039(U32.is_lt(c, 7856), c)

def fold.n1041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EB3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EB5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1041(U32.is_lt(c, 7859), c)
    case False{}:
      fold.n1042(U32.is_lt(c, 7861), c)

def fold.n1044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EB7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EBB}"

def fold.n1046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EB9}"
    case False{}:
      fold.n1045(U32.is_lt(c, 7866), c)

def fold.n1047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1044(U32.is_lt(c, 7863), c)
    case False{}:
      fold.n1046(U32.is_lt(c, 7865), c)

def fold.n1048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1043(U32.is_lt(c, 7860), c)
    case False{}:
      fold.n1047(U32.is_lt(c, 7864), c)

def fold.n1049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1040(U32.is_lt(c, 7854), c)
    case False{}:
      fold.n1048(U32.is_lt(c, 7862), c)

def fold.n1050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EBD}"

def fold.n1051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EBF}"

def fold.n1052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1050(U32.is_lt(c, 7868), c)
    case False{}:
      fold.n1051(U32.is_lt(c, 7870), c)

def fold.n1053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EC1}"

def fold.n1054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EC3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1054(U32.is_lt(c, 7875), c)

def fold.n1056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1053(U32.is_lt(c, 7872), c)
    case False{}:
      fold.n1055(U32.is_lt(c, 7874), c)

def fold.n1057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1052(U32.is_lt(c, 7869), c)
    case False{}:
      fold.n1056(U32.is_lt(c, 7873), c)

def fold.n1058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EC5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EC7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1058(U32.is_lt(c, 7877), c)
    case False{}:
      fold.n1059(U32.is_lt(c, 7879), c)

def fold.n1061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EC9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ECD}"

def fold.n1063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1ECB}"
    case False{}:
      fold.n1062(U32.is_lt(c, 7884), c)

def fold.n1064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1061(U32.is_lt(c, 7881), c)
    case False{}:
      fold.n1063(U32.is_lt(c, 7883), c)

def fold.n1065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1060(U32.is_lt(c, 7878), c)
    case False{}:
      fold.n1064(U32.is_lt(c, 7882), c)

def fold.n1066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1057(U32.is_lt(c, 7871), c)
    case False{}:
      fold.n1065(U32.is_lt(c, 7880), c)

def fold.n1067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1049(U32.is_lt(c, 7858), c)
    case False{}:
      fold.n1066(U32.is_lt(c, 7876), c)

def fold.n1068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ECF}"

def fold.n1069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED1}"

def fold.n1070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1068(U32.is_lt(c, 7886), c)
    case False{}:
      fold.n1069(U32.is_lt(c, 7888), c)

def fold.n1071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED3}"

def fold.n1072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED5}"

def fold.n1073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1071(U32.is_lt(c, 7890), c)
    case False{}:
      fold.n1072(U32.is_lt(c, 7892), c)

def fold.n1074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1070(U32.is_lt(c, 7887), c)
    case False{}:
      fold.n1073(U32.is_lt(c, 7891), c)

def fold.n1075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED7}"

def fold.n1076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1ED9}"

def fold.n1077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1075(U32.is_lt(c, 7894), c)
    case False{}:
      fold.n1076(U32.is_lt(c, 7896), c)

def fold.n1078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EDB}"

def fold.n1079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EDD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1079(U32.is_lt(c, 7901), c)

def fold.n1081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1078(U32.is_lt(c, 7898), c)
    case False{}:
      fold.n1080(U32.is_lt(c, 7900), c)

def fold.n1082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1077(U32.is_lt(c, 7895), c)
    case False{}:
      fold.n1081(U32.is_lt(c, 7899), c)

def fold.n1083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1074(U32.is_lt(c, 7889), c)
    case False{}:
      fold.n1082(U32.is_lt(c, 7897), c)

def fold.n1084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EDF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EE1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1084(U32.is_lt(c, 7903), c)
    case False{}:
      fold.n1085(U32.is_lt(c, 7905), c)

def fold.n1087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EE3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EE7}"

def fold.n1089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EE5}"
    case False{}:
      fold.n1088(U32.is_lt(c, 7910), c)

def fold.n1090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1087(U32.is_lt(c, 7907), c)
    case False{}:
      fold.n1089(U32.is_lt(c, 7909), c)

def fold.n1091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1086(U32.is_lt(c, 7904), c)
    case False{}:
      fold.n1090(U32.is_lt(c, 7908), c)

def fold.n1092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EE9}"

def fold.n1093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EEB}"

def fold.n1094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1092(U32.is_lt(c, 7912), c)
    case False{}:
      fold.n1093(U32.is_lt(c, 7914), c)

def fold.n1095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1EED}"

def fold.n1096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EEF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1096(U32.is_lt(c, 7919), c)

def fold.n1098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1095(U32.is_lt(c, 7916), c)
    case False{}:
      fold.n1097(U32.is_lt(c, 7918), c)

def fold.n1099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1094(U32.is_lt(c, 7913), c)
    case False{}:
      fold.n1098(U32.is_lt(c, 7917), c)

def fold.n1100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1091(U32.is_lt(c, 7906), c)
    case False{}:
      fold.n1099(U32.is_lt(c, 7915), c)

def fold.n1101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1083(U32.is_lt(c, 7893), c)
    case False{}:
      fold.n1100(U32.is_lt(c, 7911), c)

def fold.n1102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1067(U32.is_lt(c, 7867), c)
    case False{}:
      fold.n1101(U32.is_lt(c, 7902), c)

def fold.n1103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1033(U32.is_lt(c, 7814), c)
    case False{}:
      fold.n1102(U32.is_lt(c, 7885), c)

def fold.n1104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n965(U32.is_lt(c, 7711), c)
    case False{}:
      fold.n1103(U32.is_lt(c, 7850), c)

def fold.n1105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n828(U32.is_lt(c, 1300), c)
    case False{}:
      fold.n1104(U32.is_lt(c, 7780), c)

def fold.n1106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n552(U32.is_lt(c, 487), c)
    case False{}:
      fold.n1105(U32.is_lt(c, 7322), c)

def fold.n1107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EF1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EF3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1107(U32.is_lt(c, 7921), c)
    case False{}:
      fold.n1108(U32.is_lt(c, 7923), c)

def fold.n1110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EF5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EF7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1110(U32.is_lt(c, 7925), c)
    case False{}:
      fold.n1111(U32.is_lt(c, 7927), c)

def fold.n1113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1109(U32.is_lt(c, 7922), c)
    case False{}:
      fold.n1112(U32.is_lt(c, 7926), c)

def fold.n1114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EF9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EFB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1114(U32.is_lt(c, 7929), c)
    case False{}:
      fold.n1115(U32.is_lt(c, 7931), c)

def fold.n1117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EFD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F00}"

def fold.n1119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1EFF}"
    case False{}:
      fold.n1118(U32.is_lt(c, 7944), c)

def fold.n1120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1117(U32.is_lt(c, 7933), c)
    case False{}:
      fold.n1119(U32.is_lt(c, 7935), c)

def fold.n1121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1116(U32.is_lt(c, 7930), c)
    case False{}:
      fold.n1120(U32.is_lt(c, 7934), c)

def fold.n1122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1113(U32.is_lt(c, 7924), c)
    case False{}:
      fold.n1121(U32.is_lt(c, 7932), c)

def fold.n1123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F01}"
    case False{}:
      "\u{1F02}"

def fold.n1124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F03}"
    case False{}:
      "\u{1F04}"

def fold.n1125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1123(U32.is_lt(c, 7946), c)
    case False{}:
      fold.n1124(U32.is_lt(c, 7948), c)

def fold.n1126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F05}"
    case False{}:
      "\u{1F06}"

def fold.n1127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F07}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1126(U32.is_lt(c, 7950), c)
    case False{}:
      fold.n1127(U32.is_lt(c, 7952), c)

def fold.n1129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1125(U32.is_lt(c, 7947), c)
    case False{}:
      fold.n1128(U32.is_lt(c, 7951), c)

def fold.n1130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F10}"
    case False{}:
      "\u{1F11}"

def fold.n1131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F12}"
    case False{}:
      "\u{1F13}"

def fold.n1132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1130(U32.is_lt(c, 7961), c)
    case False{}:
      fold.n1131(U32.is_lt(c, 7963), c)

def fold.n1133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F14}"
    case False{}:
      "\u{1F15}"

def fold.n1134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F20}"
    case False{}:
      "\u{1F21}"

def fold.n1135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1134(U32.is_lt(c, 7977), c)

def fold.n1136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1133(U32.is_lt(c, 7965), c)
    case False{}:
      fold.n1135(U32.is_lt(c, 7976), c)

def fold.n1137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1132(U32.is_lt(c, 7962), c)
    case False{}:
      fold.n1136(U32.is_lt(c, 7966), c)

def fold.n1138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1129(U32.is_lt(c, 7949), c)
    case False{}:
      fold.n1137(U32.is_lt(c, 7964), c)

def fold.n1139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1122(U32.is_lt(c, 7928), c)
    case False{}:
      fold.n1138(U32.is_lt(c, 7960), c)

def fold.n1140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F22}"
    case False{}:
      "\u{1F23}"

def fold.n1141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F24}"
    case False{}:
      "\u{1F25}"

def fold.n1142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1140(U32.is_lt(c, 7979), c)
    case False{}:
      fold.n1141(U32.is_lt(c, 7981), c)

def fold.n1143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F26}"
    case False{}:
      "\u{1F27}"

def fold.n1144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F30}"

def fold.n1145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1143(U32.is_lt(c, 7983), c)
    case False{}:
      fold.n1144(U32.is_lt(c, 7992), c)

def fold.n1146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1142(U32.is_lt(c, 7980), c)
    case False{}:
      fold.n1145(U32.is_lt(c, 7984), c)

def fold.n1147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F31}"
    case False{}:
      "\u{1F32}"

def fold.n1148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F33}"
    case False{}:
      "\u{1F34}"

def fold.n1149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1147(U32.is_lt(c, 7994), c)
    case False{}:
      fold.n1148(U32.is_lt(c, 7996), c)

def fold.n1150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F35}"
    case False{}:
      "\u{1F36}"

def fold.n1151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F40}"

def fold.n1152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F37}"
    case False{}:
      fold.n1151(U32.is_lt(c, 8008), c)

def fold.n1153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1150(U32.is_lt(c, 7998), c)
    case False{}:
      fold.n1152(U32.is_lt(c, 8000), c)

def fold.n1154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1149(U32.is_lt(c, 7995), c)
    case False{}:
      fold.n1153(U32.is_lt(c, 7999), c)

def fold.n1155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1146(U32.is_lt(c, 7982), c)
    case False{}:
      fold.n1154(U32.is_lt(c, 7997), c)

def fold.n1156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F41}"
    case False{}:
      "\u{1F42}"

def fold.n1157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F43}"
    case False{}:
      "\u{1F44}"

def fold.n1158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1156(U32.is_lt(c, 8010), c)
    case False{}:
      fold.n1157(U32.is_lt(c, 8012), c)

def fold.n1159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F45}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C5}\u{313}\u{300}"

def fold.n1161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{313}"
    case False{}:
      fold.n1160(U32.is_lt(c, 8018), c)

def fold.n1162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1159(U32.is_lt(c, 8014), c)
    case False{}:
      fold.n1161(U32.is_lt(c, 8017), c)

def fold.n1163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1158(U32.is_lt(c, 8011), c)
    case False{}:
      fold.n1162(U32.is_lt(c, 8016), c)

def fold.n1164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C5}\u{313}\u{301}"

def fold.n1165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C5}\u{313}\u{342}"

def fold.n1166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1164(U32.is_lt(c, 8020), c)
    case False{}:
      fold.n1165(U32.is_lt(c, 8022), c)

def fold.n1167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F51}"

def fold.n1168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F53}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1168(U32.is_lt(c, 8028), c)

def fold.n1170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1167(U32.is_lt(c, 8025), c)
    case False{}:
      fold.n1169(U32.is_lt(c, 8027), c)

def fold.n1171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1166(U32.is_lt(c, 8021), c)
    case False{}:
      fold.n1170(U32.is_lt(c, 8026), c)

def fold.n1172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1163(U32.is_lt(c, 8013), c)
    case False{}:
      fold.n1171(U32.is_lt(c, 8023), c)

def fold.n1173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1155(U32.is_lt(c, 7993), c)
    case False{}:
      fold.n1172(U32.is_lt(c, 8019), c)

def fold.n1174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1139(U32.is_lt(c, 7945), c)
    case False{}:
      fold.n1173(U32.is_lt(c, 8009), c)

def fold.n1175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F55}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F57}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1175(U32.is_lt(c, 8030), c)
    case False{}:
      fold.n1176(U32.is_lt(c, 8032), c)

def fold.n1178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F60}"
    case False{}:
      "\u{1F61}"

def fold.n1179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F62}"
    case False{}:
      "\u{1F63}"

def fold.n1180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1178(U32.is_lt(c, 8041), c)
    case False{}:
      fold.n1179(U32.is_lt(c, 8043), c)

def fold.n1181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1177(U32.is_lt(c, 8031), c)
    case False{}:
      fold.n1180(U32.is_lt(c, 8042), c)

def fold.n1182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F64}"
    case False{}:
      "\u{1F65}"

def fold.n1183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F66}"
    case False{}:
      "\u{1F67}"

def fold.n1184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1182(U32.is_lt(c, 8045), c)
    case False{}:
      fold.n1183(U32.is_lt(c, 8047), c)

def fold.n1185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F00}\u{3B9}"

def fold.n1186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F02}\u{3B9}"
    case False{}:
      "\u{1F03}\u{3B9}"

def fold.n1187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F01}\u{3B9}"
    case False{}:
      fold.n1186(U32.is_lt(c, 8067), c)

def fold.n1188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1185(U32.is_lt(c, 8064), c)
    case False{}:
      fold.n1187(U32.is_lt(c, 8066), c)

def fold.n1189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1184(U32.is_lt(c, 8046), c)
    case False{}:
      fold.n1188(U32.is_lt(c, 8065), c)

def fold.n1190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1181(U32.is_lt(c, 8040), c)
    case False{}:
      fold.n1189(U32.is_lt(c, 8048), c)

def fold.n1191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F04}\u{3B9}"
    case False{}:
      "\u{1F05}\u{3B9}"

def fold.n1192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F06}\u{3B9}"
    case False{}:
      "\u{1F07}\u{3B9}"

def fold.n1193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1191(U32.is_lt(c, 8069), c)
    case False{}:
      fold.n1192(U32.is_lt(c, 8071), c)

def fold.n1194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F00}\u{3B9}"
    case False{}:
      "\u{1F01}\u{3B9}"

def fold.n1195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F02}\u{3B9}"
    case False{}:
      "\u{1F03}\u{3B9}"

def fold.n1196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1194(U32.is_lt(c, 8073), c)
    case False{}:
      fold.n1195(U32.is_lt(c, 8075), c)

def fold.n1197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1193(U32.is_lt(c, 8070), c)
    case False{}:
      fold.n1196(U32.is_lt(c, 8074), c)

def fold.n1198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F04}\u{3B9}"
    case False{}:
      "\u{1F05}\u{3B9}"

def fold.n1199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F06}\u{3B9}"
    case False{}:
      "\u{1F07}\u{3B9}"

def fold.n1200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1198(U32.is_lt(c, 8077), c)
    case False{}:
      fold.n1199(U32.is_lt(c, 8079), c)

def fold.n1201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F20}\u{3B9}"
    case False{}:
      "\u{1F21}\u{3B9}"

def fold.n1202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F23}\u{3B9}"
    case False{}:
      "\u{1F24}\u{3B9}"

def fold.n1203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F22}\u{3B9}"
    case False{}:
      fold.n1202(U32.is_lt(c, 8084), c)

def fold.n1204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1201(U32.is_lt(c, 8081), c)
    case False{}:
      fold.n1203(U32.is_lt(c, 8083), c)

def fold.n1205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1200(U32.is_lt(c, 8078), c)
    case False{}:
      fold.n1204(U32.is_lt(c, 8082), c)

def fold.n1206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1197(U32.is_lt(c, 8072), c)
    case False{}:
      fold.n1205(U32.is_lt(c, 8080), c)

def fold.n1207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1190(U32.is_lt(c, 8044), c)
    case False{}:
      fold.n1206(U32.is_lt(c, 8076), c)

def fold.n1208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F25}\u{3B9}"
    case False{}:
      "\u{1F26}\u{3B9}"

def fold.n1209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F27}\u{3B9}"
    case False{}:
      "\u{1F20}\u{3B9}"

def fold.n1210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1208(U32.is_lt(c, 8086), c)
    case False{}:
      fold.n1209(U32.is_lt(c, 8088), c)

def fold.n1211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F21}\u{3B9}"
    case False{}:
      "\u{1F22}\u{3B9}"

def fold.n1212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F23}\u{3B9}"
    case False{}:
      "\u{1F24}\u{3B9}"

def fold.n1213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1211(U32.is_lt(c, 8090), c)
    case False{}:
      fold.n1212(U32.is_lt(c, 8092), c)

def fold.n1214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1210(U32.is_lt(c, 8087), c)
    case False{}:
      fold.n1213(U32.is_lt(c, 8091), c)

def fold.n1215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F25}\u{3B9}"
    case False{}:
      "\u{1F26}\u{3B9}"

def fold.n1216(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F27}\u{3B9}"
    case False{}:
      "\u{1F60}\u{3B9}"

def fold.n1217(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1215(U32.is_lt(c, 8094), c)
    case False{}:
      fold.n1216(U32.is_lt(c, 8096), c)

def fold.n1218(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F61}\u{3B9}"
    case False{}:
      "\u{1F62}\u{3B9}"

def fold.n1219(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F64}\u{3B9}"
    case False{}:
      "\u{1F65}\u{3B9}"

def fold.n1220(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F63}\u{3B9}"
    case False{}:
      fold.n1219(U32.is_lt(c, 8101), c)

def fold.n1221(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1218(U32.is_lt(c, 8098), c)
    case False{}:
      fold.n1220(U32.is_lt(c, 8100), c)

def fold.n1222(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1217(U32.is_lt(c, 8095), c)
    case False{}:
      fold.n1221(U32.is_lt(c, 8099), c)

def fold.n1223(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1214(U32.is_lt(c, 8089), c)
    case False{}:
      fold.n1222(U32.is_lt(c, 8097), c)

def fold.n1224(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F66}\u{3B9}"
    case False{}:
      "\u{1F67}\u{3B9}"

def fold.n1225(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F60}\u{3B9}"
    case False{}:
      "\u{1F61}\u{3B9}"

def fold.n1226(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1224(U32.is_lt(c, 8103), c)
    case False{}:
      fold.n1225(U32.is_lt(c, 8105), c)

def fold.n1227(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F62}\u{3B9}"
    case False{}:
      "\u{1F63}\u{3B9}"

def fold.n1228(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F65}\u{3B9}"
    case False{}:
      "\u{1F66}\u{3B9}"

def fold.n1229(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F64}\u{3B9}"
    case False{}:
      fold.n1228(U32.is_lt(c, 8110), c)

def fold.n1230(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1227(U32.is_lt(c, 8107), c)
    case False{}:
      fold.n1229(U32.is_lt(c, 8109), c)

def fold.n1231(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1226(U32.is_lt(c, 8104), c)
    case False{}:
      fold.n1230(U32.is_lt(c, 8108), c)

def fold.n1232(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F67}\u{3B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1233(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F70}\u{3B9}"
    case False{}:
      "\u{3B1}\u{3B9}"

def fold.n1234(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1232(U32.is_lt(c, 8112), c)
    case False{}:
      fold.n1233(U32.is_lt(c, 8115), c)

def fold.n1235(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3AC}\u{3B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1236(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{342}\u{3B9}"
    case False{}:
      "\u{1FB0}"

def fold.n1237(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B1}\u{342}"
    case False{}:
      fold.n1236(U32.is_lt(c, 8120), c)

def fold.n1238(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1235(U32.is_lt(c, 8117), c)
    case False{}:
      fold.n1237(U32.is_lt(c, 8119), c)

def fold.n1239(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1234(U32.is_lt(c, 8114), c)
    case False{}:
      fold.n1238(U32.is_lt(c, 8118), c)

def fold.n1240(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1231(U32.is_lt(c, 8106), c)
    case False{}:
      fold.n1239(U32.is_lt(c, 8116), c)

def fold.n1241(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1223(U32.is_lt(c, 8093), c)
    case False{}:
      fold.n1240(U32.is_lt(c, 8111), c)

def fold.n1242(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1207(U32.is_lt(c, 8068), c)
    case False{}:
      fold.n1241(U32.is_lt(c, 8102), c)

def fold.n1243(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1174(U32.is_lt(c, 7978), c)
    case False{}:
      fold.n1242(U32.is_lt(c, 8085), c)

def fold.n1244(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FB1}"
    case False{}:
      "\u{1F70}"

def fold.n1245(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F71}"
    case False{}:
      "\u{3B1}\u{3B9}"

def fold.n1246(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1244(U32.is_lt(c, 8122), c)
    case False{}:
      fold.n1245(U32.is_lt(c, 8124), c)

def fold.n1247(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B9}"

def fold.n1248(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F74}\u{3B9}"

def fold.n1249(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1247(U32.is_lt(c, 8126), c)
    case False{}:
      fold.n1248(U32.is_lt(c, 8130), c)

def fold.n1250(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1246(U32.is_lt(c, 8123), c)
    case False{}:
      fold.n1249(U32.is_lt(c, 8127), c)

def fold.n1251(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{3B9}"
    case False{}:
      "\u{3AE}\u{3B9}"

def fold.n1252(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B7}\u{342}"

def fold.n1253(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1251(U32.is_lt(c, 8132), c)
    case False{}:
      fold.n1252(U32.is_lt(c, 8134), c)

def fold.n1254(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{342}\u{3B9}"
    case False{}:
      "\u{1F72}"

def fold.n1255(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F74}"
    case False{}:
      "\u{1F75}"

def fold.n1256(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F73}"
    case False{}:
      fold.n1255(U32.is_lt(c, 8139), c)

def fold.n1257(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1254(U32.is_lt(c, 8136), c)
    case False{}:
      fold.n1256(U32.is_lt(c, 8138), c)

def fold.n1258(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1253(U32.is_lt(c, 8133), c)
    case False{}:
      fold.n1257(U32.is_lt(c, 8137), c)

def fold.n1259(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1250(U32.is_lt(c, 8125), c)
    case False{}:
      fold.n1258(U32.is_lt(c, 8135), c)

def fold.n1260(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B7}\u{3B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1261(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}\u{300}"
    case False{}:
      "\u{3B9}\u{308}\u{301}"

def fold.n1262(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1260(U32.is_lt(c, 8141), c)
    case False{}:
      fold.n1261(U32.is_lt(c, 8147), c)

def fold.n1263(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3B9}\u{342}"

def fold.n1264(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3B9}\u{308}\u{342}"
    case False{}:
      "\u{1FD0}"

def fold.n1265(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1263(U32.is_lt(c, 8150), c)
    case False{}:
      fold.n1264(U32.is_lt(c, 8152), c)

def fold.n1266(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1262(U32.is_lt(c, 8146), c)
    case False{}:
      fold.n1265(U32.is_lt(c, 8151), c)

def fold.n1267(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FD1}"
    case False{}:
      "\u{1F76}"

def fold.n1268(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F77}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1269(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1267(U32.is_lt(c, 8154), c)
    case False{}:
      fold.n1268(U32.is_lt(c, 8156), c)

def fold.n1270(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{300}"
    case False{}:
      "\u{3C5}\u{308}\u{301}"

def fold.n1271(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C5}\u{342}"

def fold.n1272(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C1}\u{313}"
    case False{}:
      fold.n1271(U32.is_lt(c, 8166), c)

def fold.n1273(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1270(U32.is_lt(c, 8163), c)
    case False{}:
      fold.n1272(U32.is_lt(c, 8165), c)

def fold.n1274(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1269(U32.is_lt(c, 8155), c)
    case False{}:
      fold.n1273(U32.is_lt(c, 8164), c)

def fold.n1275(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1266(U32.is_lt(c, 8148), c)
    case False{}:
      fold.n1274(U32.is_lt(c, 8162), c)

def fold.n1276(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1259(U32.is_lt(c, 8131), c)
    case False{}:
      fold.n1275(U32.is_lt(c, 8153), c)

def fold.n1277(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C5}\u{308}\u{342}"
    case False{}:
      "\u{1FE0}"

def fold.n1278(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1FE1}"
    case False{}:
      "\u{1F7A}"

def fold.n1279(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1277(U32.is_lt(c, 8168), c)
    case False{}:
      fold.n1278(U32.is_lt(c, 8170), c)

def fold.n1280(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F7B}"
    case False{}:
      "\u{1FE5}"

def fold.n1281(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1F7C}\u{3B9}"

def fold.n1282(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1280(U32.is_lt(c, 8172), c)
    case False{}:
      fold.n1281(U32.is_lt(c, 8178), c)

def fold.n1283(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1279(U32.is_lt(c, 8169), c)
    case False{}:
      fold.n1282(U32.is_lt(c, 8173), c)

def fold.n1284(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{3B9}"
    case False{}:
      "\u{3CE}\u{3B9}"

def fold.n1285(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{3C9}\u{342}"

def fold.n1286(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1284(U32.is_lt(c, 8180), c)
    case False{}:
      fold.n1285(U32.is_lt(c, 8182), c)

def fold.n1287(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{342}\u{3B9}"
    case False{}:
      "\u{1F78}"

def fold.n1288(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F7C}"
    case False{}:
      "\u{1F7D}"

def fold.n1289(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1F79}"
    case False{}:
      fold.n1288(U32.is_lt(c, 8187), c)

def fold.n1290(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1287(U32.is_lt(c, 8184), c)
    case False{}:
      fold.n1289(U32.is_lt(c, 8186), c)

def fold.n1291(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1286(U32.is_lt(c, 8181), c)
    case False{}:
      fold.n1290(U32.is_lt(c, 8185), c)

def fold.n1292(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1283(U32.is_lt(c, 8171), c)
    case False{}:
      fold.n1291(U32.is_lt(c, 8183), c)

def fold.n1293(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}\u{3B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1294(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{3C9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1295(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1293(U32.is_lt(c, 8189), c)
    case False{}:
      fold.n1294(U32.is_lt(c, 8487), c)

def fold.n1296(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{6B}"
    case False{}:
      "\u{E5}"

def fold.n1297(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{214E}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1298(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1297(U32.is_lt(c, 8499), c)

def fold.n1299(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1296(U32.is_lt(c, 8491), c)
    case False{}:
      fold.n1298(U32.is_lt(c, 8498), c)

def fold.n1300(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1295(U32.is_lt(c, 8486), c)
    case False{}:
      fold.n1299(U32.is_lt(c, 8492), c)

def fold.n1301(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2170}"
    case False{}:
      "\u{2171}"

def fold.n1302(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2172}"
    case False{}:
      "\u{2173}"

def fold.n1303(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1301(U32.is_lt(c, 8545), c)
    case False{}:
      fold.n1302(U32.is_lt(c, 8547), c)

def fold.n1304(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2174}"
    case False{}:
      "\u{2175}"

def fold.n1305(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2177}"
    case False{}:
      "\u{2178}"

def fold.n1306(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2176}"
    case False{}:
      fold.n1305(U32.is_lt(c, 8552), c)

def fold.n1307(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1304(U32.is_lt(c, 8549), c)
    case False{}:
      fold.n1306(U32.is_lt(c, 8551), c)

def fold.n1308(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1303(U32.is_lt(c, 8546), c)
    case False{}:
      fold.n1307(U32.is_lt(c, 8550), c)

def fold.n1309(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1300(U32.is_lt(c, 8490), c)
    case False{}:
      fold.n1308(U32.is_lt(c, 8548), c)

def fold.n1310(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1292(U32.is_lt(c, 8179), c)
    case False{}:
      fold.n1309(U32.is_lt(c, 8544), c)

def fold.n1311(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1276(U32.is_lt(c, 8140), c)
    case False{}:
      fold.n1310(U32.is_lt(c, 8188), c)

def fold.n1312(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2179}"
    case False{}:
      "\u{217A}"

def fold.n1313(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{217B}"
    case False{}:
      "\u{217C}"

def fold.n1314(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1312(U32.is_lt(c, 8554), c)
    case False{}:
      fold.n1313(U32.is_lt(c, 8556), c)

def fold.n1315(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{217D}"
    case False{}:
      "\u{217E}"

def fold.n1316(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{217F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1317(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1315(U32.is_lt(c, 8558), c)
    case False{}:
      fold.n1316(U32.is_lt(c, 8560), c)

def fold.n1318(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1314(U32.is_lt(c, 8555), c)
    case False{}:
      fold.n1317(U32.is_lt(c, 8559), c)

def fold.n1319(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2184}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1320(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D0}"
    case False{}:
      "\u{24D1}"

def fold.n1321(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1319(U32.is_lt(c, 8580), c)
    case False{}:
      fold.n1320(U32.is_lt(c, 9399), c)

def fold.n1322(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D2}"
    case False{}:
      "\u{24D3}"

def fold.n1323(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D5}"
    case False{}:
      "\u{24D6}"

def fold.n1324(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D4}"
    case False{}:
      fold.n1323(U32.is_lt(c, 9404), c)

def fold.n1325(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1322(U32.is_lt(c, 9401), c)
    case False{}:
      fold.n1324(U32.is_lt(c, 9403), c)

def fold.n1326(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1321(U32.is_lt(c, 9398), c)
    case False{}:
      fold.n1325(U32.is_lt(c, 9402), c)

def fold.n1327(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1318(U32.is_lt(c, 8557), c)
    case False{}:
      fold.n1326(U32.is_lt(c, 9400), c)

def fold.n1328(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D7}"
    case False{}:
      "\u{24D8}"

def fold.n1329(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24D9}"
    case False{}:
      "\u{24DA}"

def fold.n1330(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1328(U32.is_lt(c, 9406), c)
    case False{}:
      fold.n1329(U32.is_lt(c, 9408), c)

def fold.n1331(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24DB}"
    case False{}:
      "\u{24DC}"

def fold.n1332(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24DE}"
    case False{}:
      "\u{24DF}"

def fold.n1333(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24DD}"
    case False{}:
      fold.n1332(U32.is_lt(c, 9413), c)

def fold.n1334(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1331(U32.is_lt(c, 9410), c)
    case False{}:
      fold.n1333(U32.is_lt(c, 9412), c)

def fold.n1335(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1330(U32.is_lt(c, 9407), c)
    case False{}:
      fold.n1334(U32.is_lt(c, 9411), c)

def fold.n1336(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E0}"
    case False{}:
      "\u{24E1}"

def fold.n1337(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E2}"
    case False{}:
      "\u{24E3}"

def fold.n1338(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1336(U32.is_lt(c, 9415), c)
    case False{}:
      fold.n1337(U32.is_lt(c, 9417), c)

def fold.n1339(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E4}"
    case False{}:
      "\u{24E5}"

def fold.n1340(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E7}"
    case False{}:
      "\u{24E8}"

def fold.n1341(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E6}"
    case False{}:
      fold.n1340(U32.is_lt(c, 9422), c)

def fold.n1342(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1339(U32.is_lt(c, 9419), c)
    case False{}:
      fold.n1341(U32.is_lt(c, 9421), c)

def fold.n1343(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1338(U32.is_lt(c, 9416), c)
    case False{}:
      fold.n1342(U32.is_lt(c, 9420), c)

def fold.n1344(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1335(U32.is_lt(c, 9409), c)
    case False{}:
      fold.n1343(U32.is_lt(c, 9418), c)

def fold.n1345(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1327(U32.is_lt(c, 8579), c)
    case False{}:
      fold.n1344(U32.is_lt(c, 9414), c)

def fold.n1346(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{24E9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1347(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C30}"
    case False{}:
      "\u{2C31}"

def fold.n1348(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1346(U32.is_lt(c, 9424), c)
    case False{}:
      fold.n1347(U32.is_lt(c, 11265), c)

def fold.n1349(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C32}"
    case False{}:
      "\u{2C33}"

def fold.n1350(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C34}"
    case False{}:
      "\u{2C35}"

def fold.n1351(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1349(U32.is_lt(c, 11267), c)
    case False{}:
      fold.n1350(U32.is_lt(c, 11269), c)

def fold.n1352(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1348(U32.is_lt(c, 11264), c)
    case False{}:
      fold.n1351(U32.is_lt(c, 11268), c)

def fold.n1353(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C36}"
    case False{}:
      "\u{2C37}"

def fold.n1354(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C38}"
    case False{}:
      "\u{2C39}"

def fold.n1355(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1353(U32.is_lt(c, 11271), c)
    case False{}:
      fold.n1354(U32.is_lt(c, 11273), c)

def fold.n1356(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C3A}"
    case False{}:
      "\u{2C3B}"

def fold.n1357(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C3D}"
    case False{}:
      "\u{2C3E}"

def fold.n1358(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C3C}"
    case False{}:
      fold.n1357(U32.is_lt(c, 11278), c)

def fold.n1359(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1356(U32.is_lt(c, 11275), c)
    case False{}:
      fold.n1358(U32.is_lt(c, 11277), c)

def fold.n1360(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1355(U32.is_lt(c, 11272), c)
    case False{}:
      fold.n1359(U32.is_lt(c, 11276), c)

def fold.n1361(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1352(U32.is_lt(c, 11266), c)
    case False{}:
      fold.n1360(U32.is_lt(c, 11274), c)

def fold.n1362(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C3F}"
    case False{}:
      "\u{2C40}"

def fold.n1363(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C41}"
    case False{}:
      "\u{2C42}"

def fold.n1364(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1362(U32.is_lt(c, 11280), c)
    case False{}:
      fold.n1363(U32.is_lt(c, 11282), c)

def fold.n1365(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C43}"
    case False{}:
      "\u{2C44}"

def fold.n1366(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C46}"
    case False{}:
      "\u{2C47}"

def fold.n1367(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C45}"
    case False{}:
      fold.n1366(U32.is_lt(c, 11287), c)

def fold.n1368(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1365(U32.is_lt(c, 11284), c)
    case False{}:
      fold.n1367(U32.is_lt(c, 11286), c)

def fold.n1369(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1364(U32.is_lt(c, 11281), c)
    case False{}:
      fold.n1368(U32.is_lt(c, 11285), c)

def fold.n1370(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C48}"
    case False{}:
      "\u{2C49}"

def fold.n1371(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C4A}"
    case False{}:
      "\u{2C4B}"

def fold.n1372(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1370(U32.is_lt(c, 11289), c)
    case False{}:
      fold.n1371(U32.is_lt(c, 11291), c)

def fold.n1373(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C4C}"
    case False{}:
      "\u{2C4D}"

def fold.n1374(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C4F}"
    case False{}:
      "\u{2C50}"

def fold.n1375(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C4E}"
    case False{}:
      fold.n1374(U32.is_lt(c, 11296), c)

def fold.n1376(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1373(U32.is_lt(c, 11293), c)
    case False{}:
      fold.n1375(U32.is_lt(c, 11295), c)

def fold.n1377(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1372(U32.is_lt(c, 11290), c)
    case False{}:
      fold.n1376(U32.is_lt(c, 11294), c)

def fold.n1378(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1369(U32.is_lt(c, 11283), c)
    case False{}:
      fold.n1377(U32.is_lt(c, 11292), c)

def fold.n1379(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1361(U32.is_lt(c, 11270), c)
    case False{}:
      fold.n1378(U32.is_lt(c, 11288), c)

def fold.n1380(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1345(U32.is_lt(c, 9405), c)
    case False{}:
      fold.n1379(U32.is_lt(c, 11279), c)

def fold.n1381(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1311(U32.is_lt(c, 8167), c)
    case False{}:
      fold.n1380(U32.is_lt(c, 9423), c)

def fold.n1382(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1243(U32.is_lt(c, 8029), c)
    case False{}:
      fold.n1381(U32.is_lt(c, 8553), c)

def fold.n1383(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C51}"
    case False{}:
      "\u{2C52}"

def fold.n1384(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C53}"
    case False{}:
      "\u{2C54}"

def fold.n1385(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1383(U32.is_lt(c, 11298), c)
    case False{}:
      fold.n1384(U32.is_lt(c, 11300), c)

def fold.n1386(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C55}"
    case False{}:
      "\u{2C56}"

def fold.n1387(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C57}"
    case False{}:
      "\u{2C58}"

def fold.n1388(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1386(U32.is_lt(c, 11302), c)
    case False{}:
      fold.n1387(U32.is_lt(c, 11304), c)

def fold.n1389(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1385(U32.is_lt(c, 11299), c)
    case False{}:
      fold.n1388(U32.is_lt(c, 11303), c)

def fold.n1390(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C59}"
    case False{}:
      "\u{2C5A}"

def fold.n1391(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C5B}"
    case False{}:
      "\u{2C5C}"

def fold.n1392(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1390(U32.is_lt(c, 11306), c)
    case False{}:
      fold.n1391(U32.is_lt(c, 11308), c)

def fold.n1393(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C5D}"
    case False{}:
      "\u{2C5E}"

def fold.n1394(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C61}"

def fold.n1395(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C5F}"
    case False{}:
      fold.n1394(U32.is_lt(c, 11360), c)

def fold.n1396(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1393(U32.is_lt(c, 11310), c)
    case False{}:
      fold.n1395(U32.is_lt(c, 11312), c)

def fold.n1397(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1392(U32.is_lt(c, 11307), c)
    case False{}:
      fold.n1396(U32.is_lt(c, 11311), c)

def fold.n1398(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1389(U32.is_lt(c, 11301), c)
    case False{}:
      fold.n1397(U32.is_lt(c, 11309), c)

def fold.n1399(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{26B}"

def fold.n1400(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1D7D}"
    case False{}:
      "\u{27D}"

def fold.n1401(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1399(U32.is_lt(c, 11362), c)
    case False{}:
      fold.n1400(U32.is_lt(c, 11364), c)

def fold.n1402(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C68}"

def fold.n1403(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C6A}"

def fold.n1404(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1402(U32.is_lt(c, 11367), c)
    case False{}:
      fold.n1403(U32.is_lt(c, 11369), c)

def fold.n1405(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1401(U32.is_lt(c, 11363), c)
    case False{}:
      fold.n1404(U32.is_lt(c, 11368), c)

def fold.n1406(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C6C}"

def fold.n1407(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{251}"

def fold.n1408(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1406(U32.is_lt(c, 11371), c)
    case False{}:
      fold.n1407(U32.is_lt(c, 11373), c)

def fold.n1409(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{271}"
    case False{}:
      "\u{250}"

def fold.n1410(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C73}"

def fold.n1411(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{252}"
    case False{}:
      fold.n1410(U32.is_lt(c, 11378), c)

def fold.n1412(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1409(U32.is_lt(c, 11375), c)
    case False{}:
      fold.n1411(U32.is_lt(c, 11377), c)

def fold.n1413(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1408(U32.is_lt(c, 11372), c)
    case False{}:
      fold.n1412(U32.is_lt(c, 11376), c)

def fold.n1414(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1405(U32.is_lt(c, 11365), c)
    case False{}:
      fold.n1413(U32.is_lt(c, 11374), c)

def fold.n1415(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1398(U32.is_lt(c, 11305), c)
    case False{}:
      fold.n1414(U32.is_lt(c, 11370), c)

def fold.n1416(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C76}"

def fold.n1417(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{23F}"

def fold.n1418(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1416(U32.is_lt(c, 11381), c)
    case False{}:
      fold.n1417(U32.is_lt(c, 11390), c)

def fold.n1419(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{240}"
    case False{}:
      "\u{2C81}"

def fold.n1420(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C83}"

def fold.n1421(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1419(U32.is_lt(c, 11392), c)
    case False{}:
      fold.n1420(U32.is_lt(c, 11394), c)

def fold.n1422(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1418(U32.is_lt(c, 11382), c)
    case False{}:
      fold.n1421(U32.is_lt(c, 11393), c)

def fold.n1423(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C85}"

def fold.n1424(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C87}"

def fold.n1425(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1423(U32.is_lt(c, 11396), c)
    case False{}:
      fold.n1424(U32.is_lt(c, 11398), c)

def fold.n1426(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C89}"

def fold.n1427(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C8B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1428(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1427(U32.is_lt(c, 11403), c)

def fold.n1429(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1426(U32.is_lt(c, 11400), c)
    case False{}:
      fold.n1428(U32.is_lt(c, 11402), c)

def fold.n1430(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1425(U32.is_lt(c, 11397), c)
    case False{}:
      fold.n1429(U32.is_lt(c, 11401), c)

def fold.n1431(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1422(U32.is_lt(c, 11391), c)
    case False{}:
      fold.n1430(U32.is_lt(c, 11399), c)

def fold.n1432(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C8D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1433(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C8F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1434(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1432(U32.is_lt(c, 11405), c)
    case False{}:
      fold.n1433(U32.is_lt(c, 11407), c)

def fold.n1435(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C91}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1436(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C95}"

def fold.n1437(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C93}"
    case False{}:
      fold.n1436(U32.is_lt(c, 11412), c)

def fold.n1438(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1435(U32.is_lt(c, 11409), c)
    case False{}:
      fold.n1437(U32.is_lt(c, 11411), c)

def fold.n1439(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1434(U32.is_lt(c, 11406), c)
    case False{}:
      fold.n1438(U32.is_lt(c, 11410), c)

def fold.n1440(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C97}"

def fold.n1441(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C99}"

def fold.n1442(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1440(U32.is_lt(c, 11414), c)
    case False{}:
      fold.n1441(U32.is_lt(c, 11416), c)

def fold.n1443(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2C9B}"

def fold.n1444(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C9D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1445(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1444(U32.is_lt(c, 11421), c)

def fold.n1446(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1443(U32.is_lt(c, 11418), c)
    case False{}:
      fold.n1445(U32.is_lt(c, 11420), c)

def fold.n1447(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1442(U32.is_lt(c, 11415), c)
    case False{}:
      fold.n1446(U32.is_lt(c, 11419), c)

def fold.n1448(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1439(U32.is_lt(c, 11408), c)
    case False{}:
      fold.n1447(U32.is_lt(c, 11417), c)

def fold.n1449(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1431(U32.is_lt(c, 11395), c)
    case False{}:
      fold.n1448(U32.is_lt(c, 11413), c)

def fold.n1450(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1415(U32.is_lt(c, 11361), c)
    case False{}:
      fold.n1449(U32.is_lt(c, 11404), c)

def fold.n1451(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2C9F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1452(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CA1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1453(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1451(U32.is_lt(c, 11423), c)
    case False{}:
      fold.n1452(U32.is_lt(c, 11425), c)

def fold.n1454(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CA3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1455(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CA5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1456(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1454(U32.is_lt(c, 11427), c)
    case False{}:
      fold.n1455(U32.is_lt(c, 11429), c)

def fold.n1457(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1453(U32.is_lt(c, 11424), c)
    case False{}:
      fold.n1456(U32.is_lt(c, 11428), c)

def fold.n1458(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CA7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1459(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CA9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1460(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1458(U32.is_lt(c, 11431), c)
    case False{}:
      fold.n1459(U32.is_lt(c, 11433), c)

def fold.n1461(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CAB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1462(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CAF}"

def fold.n1463(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CAD}"
    case False{}:
      fold.n1462(U32.is_lt(c, 11438), c)

def fold.n1464(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1461(U32.is_lt(c, 11435), c)
    case False{}:
      fold.n1463(U32.is_lt(c, 11437), c)

def fold.n1465(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1460(U32.is_lt(c, 11432), c)
    case False{}:
      fold.n1464(U32.is_lt(c, 11436), c)

def fold.n1466(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1457(U32.is_lt(c, 11426), c)
    case False{}:
      fold.n1465(U32.is_lt(c, 11434), c)

def fold.n1467(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CB1}"

def fold.n1468(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CB3}"

def fold.n1469(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1467(U32.is_lt(c, 11440), c)
    case False{}:
      fold.n1468(U32.is_lt(c, 11442), c)

def fold.n1470(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CB5}"

def fold.n1471(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CB7}"

def fold.n1472(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1470(U32.is_lt(c, 11444), c)
    case False{}:
      fold.n1471(U32.is_lt(c, 11446), c)

def fold.n1473(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1469(U32.is_lt(c, 11441), c)
    case False{}:
      fold.n1472(U32.is_lt(c, 11445), c)

def fold.n1474(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CB9}"

def fold.n1475(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CBB}"

def fold.n1476(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1474(U32.is_lt(c, 11448), c)
    case False{}:
      fold.n1475(U32.is_lt(c, 11450), c)

def fold.n1477(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CBD}"

def fold.n1478(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CBF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1479(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1478(U32.is_lt(c, 11455), c)

def fold.n1480(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1477(U32.is_lt(c, 11452), c)
    case False{}:
      fold.n1479(U32.is_lt(c, 11454), c)

def fold.n1481(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1476(U32.is_lt(c, 11449), c)
    case False{}:
      fold.n1480(U32.is_lt(c, 11453), c)

def fold.n1482(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1473(U32.is_lt(c, 11443), c)
    case False{}:
      fold.n1481(U32.is_lt(c, 11451), c)

def fold.n1483(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1466(U32.is_lt(c, 11430), c)
    case False{}:
      fold.n1482(U32.is_lt(c, 11447), c)

def fold.n1484(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CC1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1485(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CC3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1486(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1484(U32.is_lt(c, 11457), c)
    case False{}:
      fold.n1485(U32.is_lt(c, 11459), c)

def fold.n1487(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CC5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1488(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CC7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1489(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1487(U32.is_lt(c, 11461), c)
    case False{}:
      fold.n1488(U32.is_lt(c, 11463), c)

def fold.n1490(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1486(U32.is_lt(c, 11458), c)
    case False{}:
      fold.n1489(U32.is_lt(c, 11462), c)

def fold.n1491(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CC9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1492(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CCB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1493(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1491(U32.is_lt(c, 11465), c)
    case False{}:
      fold.n1492(U32.is_lt(c, 11467), c)

def fold.n1494(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CCD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1495(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CD1}"

def fold.n1496(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CCF}"
    case False{}:
      fold.n1495(U32.is_lt(c, 11472), c)

def fold.n1497(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1494(U32.is_lt(c, 11469), c)
    case False{}:
      fold.n1496(U32.is_lt(c, 11471), c)

def fold.n1498(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1493(U32.is_lt(c, 11466), c)
    case False{}:
      fold.n1497(U32.is_lt(c, 11470), c)

def fold.n1499(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1490(U32.is_lt(c, 11460), c)
    case False{}:
      fold.n1498(U32.is_lt(c, 11468), c)

def fold.n1500(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CD3}"

def fold.n1501(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CD5}"

def fold.n1502(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1500(U32.is_lt(c, 11474), c)
    case False{}:
      fold.n1501(U32.is_lt(c, 11476), c)

def fold.n1503(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CD7}"

def fold.n1504(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CD9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1505(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1504(U32.is_lt(c, 11481), c)

def fold.n1506(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1503(U32.is_lt(c, 11478), c)
    case False{}:
      fold.n1505(U32.is_lt(c, 11480), c)

def fold.n1507(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1502(U32.is_lt(c, 11475), c)
    case False{}:
      fold.n1506(U32.is_lt(c, 11479), c)

def fold.n1508(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CDB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1509(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CDD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1510(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1508(U32.is_lt(c, 11483), c)
    case False{}:
      fold.n1509(U32.is_lt(c, 11485), c)

def fold.n1511(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CDF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1512(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CE3}"

def fold.n1513(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{2CE1}"
    case False{}:
      fold.n1512(U32.is_lt(c, 11490), c)

def fold.n1514(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1511(U32.is_lt(c, 11487), c)
    case False{}:
      fold.n1513(U32.is_lt(c, 11489), c)

def fold.n1515(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1510(U32.is_lt(c, 11484), c)
    case False{}:
      fold.n1514(U32.is_lt(c, 11488), c)

def fold.n1516(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1507(U32.is_lt(c, 11477), c)
    case False{}:
      fold.n1515(U32.is_lt(c, 11486), c)

def fold.n1517(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1499(U32.is_lt(c, 11464), c)
    case False{}:
      fold.n1516(U32.is_lt(c, 11482), c)

def fold.n1518(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1483(U32.is_lt(c, 11439), c)
    case False{}:
      fold.n1517(U32.is_lt(c, 11473), c)

def fold.n1519(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1450(U32.is_lt(c, 11379), c)
    case False{}:
      fold.n1518(U32.is_lt(c, 11456), c)

def fold.n1520(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CEC}"

def fold.n1521(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CEE}"

def fold.n1522(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1520(U32.is_lt(c, 11499), c)
    case False{}:
      fold.n1521(U32.is_lt(c, 11501), c)

def fold.n1523(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{2CF3}"

def fold.n1524(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A641}"

def fold.n1525(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1523(U32.is_lt(c, 11506), c)
    case False{}:
      fold.n1524(U32.is_lt(c, 42560), c)

def fold.n1526(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1522(U32.is_lt(c, 11500), c)
    case False{}:
      fold.n1525(U32.is_lt(c, 11507), c)

def fold.n1527(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A643}"

def fold.n1528(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A645}"

def fold.n1529(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1527(U32.is_lt(c, 42562), c)
    case False{}:
      fold.n1528(U32.is_lt(c, 42564), c)

def fold.n1530(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A647}"

def fold.n1531(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A649}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1532(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1531(U32.is_lt(c, 42569), c)

def fold.n1533(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1530(U32.is_lt(c, 42566), c)
    case False{}:
      fold.n1532(U32.is_lt(c, 42568), c)

def fold.n1534(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1529(U32.is_lt(c, 42563), c)
    case False{}:
      fold.n1533(U32.is_lt(c, 42567), c)

def fold.n1535(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1526(U32.is_lt(c, 11502), c)
    case False{}:
      fold.n1534(U32.is_lt(c, 42565), c)

def fold.n1536(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A64B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1537(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A64D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1538(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1536(U32.is_lt(c, 42571), c)
    case False{}:
      fold.n1537(U32.is_lt(c, 42573), c)

def fold.n1539(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A64F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1540(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A651}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1541(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1539(U32.is_lt(c, 42575), c)
    case False{}:
      fold.n1540(U32.is_lt(c, 42577), c)

def fold.n1542(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1538(U32.is_lt(c, 42572), c)
    case False{}:
      fold.n1541(U32.is_lt(c, 42576), c)

def fold.n1543(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A653}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1544(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A655}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1545(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1543(U32.is_lt(c, 42579), c)
    case False{}:
      fold.n1544(U32.is_lt(c, 42581), c)

def fold.n1546(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A657}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1547(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A65B}"

def fold.n1548(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A659}"
    case False{}:
      fold.n1547(U32.is_lt(c, 42586), c)

def fold.n1549(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1546(U32.is_lt(c, 42583), c)
    case False{}:
      fold.n1548(U32.is_lt(c, 42585), c)

def fold.n1550(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1545(U32.is_lt(c, 42580), c)
    case False{}:
      fold.n1549(U32.is_lt(c, 42584), c)

def fold.n1551(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1542(U32.is_lt(c, 42574), c)
    case False{}:
      fold.n1550(U32.is_lt(c, 42582), c)

def fold.n1552(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1535(U32.is_lt(c, 42561), c)
    case False{}:
      fold.n1551(U32.is_lt(c, 42578), c)

def fold.n1553(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A65D}"

def fold.n1554(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A65F}"

def fold.n1555(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1553(U32.is_lt(c, 42588), c)
    case False{}:
      fold.n1554(U32.is_lt(c, 42590), c)

def fold.n1556(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A661}"

def fold.n1557(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A663}"

def fold.n1558(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1556(U32.is_lt(c, 42592), c)
    case False{}:
      fold.n1557(U32.is_lt(c, 42594), c)

def fold.n1559(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1555(U32.is_lt(c, 42589), c)
    case False{}:
      fold.n1558(U32.is_lt(c, 42593), c)

def fold.n1560(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A665}"

def fold.n1561(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A667}"

def fold.n1562(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1560(U32.is_lt(c, 42596), c)
    case False{}:
      fold.n1561(U32.is_lt(c, 42598), c)

def fold.n1563(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A669}"

def fold.n1564(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A66B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1565(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1564(U32.is_lt(c, 42603), c)

def fold.n1566(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1563(U32.is_lt(c, 42600), c)
    case False{}:
      fold.n1565(U32.is_lt(c, 42602), c)

def fold.n1567(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1562(U32.is_lt(c, 42597), c)
    case False{}:
      fold.n1566(U32.is_lt(c, 42601), c)

def fold.n1568(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1559(U32.is_lt(c, 42591), c)
    case False{}:
      fold.n1567(U32.is_lt(c, 42599), c)

def fold.n1569(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A66D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1570(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A681}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1571(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1569(U32.is_lt(c, 42605), c)
    case False{}:
      fold.n1570(U32.is_lt(c, 42625), c)

def fold.n1572(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A683}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1573(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A687}"

def fold.n1574(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A685}"
    case False{}:
      fold.n1573(U32.is_lt(c, 42630), c)

def fold.n1575(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1572(U32.is_lt(c, 42627), c)
    case False{}:
      fold.n1574(U32.is_lt(c, 42629), c)

def fold.n1576(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1571(U32.is_lt(c, 42624), c)
    case False{}:
      fold.n1575(U32.is_lt(c, 42628), c)

def fold.n1577(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A689}"

def fold.n1578(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A68B}"

def fold.n1579(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1577(U32.is_lt(c, 42632), c)
    case False{}:
      fold.n1578(U32.is_lt(c, 42634), c)

def fold.n1580(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A68D}"

def fold.n1581(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A68F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1582(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1581(U32.is_lt(c, 42639), c)

def fold.n1583(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1580(U32.is_lt(c, 42636), c)
    case False{}:
      fold.n1582(U32.is_lt(c, 42638), c)

def fold.n1584(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1579(U32.is_lt(c, 42633), c)
    case False{}:
      fold.n1583(U32.is_lt(c, 42637), c)

def fold.n1585(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1576(U32.is_lt(c, 42626), c)
    case False{}:
      fold.n1584(U32.is_lt(c, 42635), c)

def fold.n1586(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1568(U32.is_lt(c, 42595), c)
    case False{}:
      fold.n1585(U32.is_lt(c, 42631), c)

def fold.n1587(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1552(U32.is_lt(c, 42570), c)
    case False{}:
      fold.n1586(U32.is_lt(c, 42604), c)

def fold.n1588(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A691}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1589(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A693}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1590(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1588(U32.is_lt(c, 42641), c)
    case False{}:
      fold.n1589(U32.is_lt(c, 42643), c)

def fold.n1591(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A695}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1592(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A697}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1593(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1591(U32.is_lt(c, 42645), c)
    case False{}:
      fold.n1592(U32.is_lt(c, 42647), c)

def fold.n1594(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1590(U32.is_lt(c, 42642), c)
    case False{}:
      fold.n1593(U32.is_lt(c, 42646), c)

def fold.n1595(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A699}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1596(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A69B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1597(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1595(U32.is_lt(c, 42649), c)
    case False{}:
      fold.n1596(U32.is_lt(c, 42651), c)

def fold.n1598(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A723}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1599(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A727}"

def fold.n1600(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A725}"
    case False{}:
      fold.n1599(U32.is_lt(c, 42790), c)

def fold.n1601(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1598(U32.is_lt(c, 42787), c)
    case False{}:
      fold.n1600(U32.is_lt(c, 42789), c)

def fold.n1602(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1597(U32.is_lt(c, 42650), c)
    case False{}:
      fold.n1601(U32.is_lt(c, 42788), c)

def fold.n1603(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1594(U32.is_lt(c, 42644), c)
    case False{}:
      fold.n1602(U32.is_lt(c, 42786), c)

def fold.n1604(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A729}"

def fold.n1605(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A72B}"

def fold.n1606(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1604(U32.is_lt(c, 42792), c)
    case False{}:
      fold.n1605(U32.is_lt(c, 42794), c)

def fold.n1607(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A72D}"

def fold.n1608(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A72F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1609(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1608(U32.is_lt(c, 42799), c)

def fold.n1610(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1607(U32.is_lt(c, 42796), c)
    case False{}:
      fold.n1609(U32.is_lt(c, 42798), c)

def fold.n1611(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1606(U32.is_lt(c, 42793), c)
    case False{}:
      fold.n1610(U32.is_lt(c, 42797), c)

def fold.n1612(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A733}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1613(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A735}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1614(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1612(U32.is_lt(c, 42803), c)
    case False{}:
      fold.n1613(U32.is_lt(c, 42805), c)

def fold.n1615(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A737}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1616(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A73B}"

def fold.n1617(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A739}"
    case False{}:
      fold.n1616(U32.is_lt(c, 42810), c)

def fold.n1618(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1615(U32.is_lt(c, 42807), c)
    case False{}:
      fold.n1617(U32.is_lt(c, 42809), c)

def fold.n1619(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1614(U32.is_lt(c, 42804), c)
    case False{}:
      fold.n1618(U32.is_lt(c, 42808), c)

def fold.n1620(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1611(U32.is_lt(c, 42795), c)
    case False{}:
      fold.n1619(U32.is_lt(c, 42806), c)

def fold.n1621(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1603(U32.is_lt(c, 42648), c)
    case False{}:
      fold.n1620(U32.is_lt(c, 42802), c)

def fold.n1622(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A73D}"

def fold.n1623(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A73F}"

def fold.n1624(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1622(U32.is_lt(c, 42812), c)
    case False{}:
      fold.n1623(U32.is_lt(c, 42814), c)

def fold.n1625(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A741}"

def fold.n1626(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A743}"

def fold.n1627(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1625(U32.is_lt(c, 42816), c)
    case False{}:
      fold.n1626(U32.is_lt(c, 42818), c)

def fold.n1628(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1624(U32.is_lt(c, 42813), c)
    case False{}:
      fold.n1627(U32.is_lt(c, 42817), c)

def fold.n1629(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A745}"

def fold.n1630(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A747}"

def fold.n1631(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1629(U32.is_lt(c, 42820), c)
    case False{}:
      fold.n1630(U32.is_lt(c, 42822), c)

def fold.n1632(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A749}"

def fold.n1633(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A74B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1634(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1633(U32.is_lt(c, 42827), c)

def fold.n1635(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1632(U32.is_lt(c, 42824), c)
    case False{}:
      fold.n1634(U32.is_lt(c, 42826), c)

def fold.n1636(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1631(U32.is_lt(c, 42821), c)
    case False{}:
      fold.n1635(U32.is_lt(c, 42825), c)

def fold.n1637(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1628(U32.is_lt(c, 42815), c)
    case False{}:
      fold.n1636(U32.is_lt(c, 42823), c)

def fold.n1638(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A74D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1639(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A74F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1640(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1638(U32.is_lt(c, 42829), c)
    case False{}:
      fold.n1639(U32.is_lt(c, 42831), c)

def fold.n1641(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A751}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1642(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A755}"

def fold.n1643(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A753}"
    case False{}:
      fold.n1642(U32.is_lt(c, 42836), c)

def fold.n1644(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1641(U32.is_lt(c, 42833), c)
    case False{}:
      fold.n1643(U32.is_lt(c, 42835), c)

def fold.n1645(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1640(U32.is_lt(c, 42830), c)
    case False{}:
      fold.n1644(U32.is_lt(c, 42834), c)

def fold.n1646(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A757}"

def fold.n1647(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A759}"

def fold.n1648(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1646(U32.is_lt(c, 42838), c)
    case False{}:
      fold.n1647(U32.is_lt(c, 42840), c)

def fold.n1649(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A75B}"

def fold.n1650(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A75D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1651(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1650(U32.is_lt(c, 42845), c)

def fold.n1652(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1649(U32.is_lt(c, 42842), c)
    case False{}:
      fold.n1651(U32.is_lt(c, 42844), c)

def fold.n1653(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1648(U32.is_lt(c, 42839), c)
    case False{}:
      fold.n1652(U32.is_lt(c, 42843), c)

def fold.n1654(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1645(U32.is_lt(c, 42832), c)
    case False{}:
      fold.n1653(U32.is_lt(c, 42841), c)

def fold.n1655(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1637(U32.is_lt(c, 42819), c)
    case False{}:
      fold.n1654(U32.is_lt(c, 42837), c)

def fold.n1656(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1621(U32.is_lt(c, 42791), c)
    case False{}:
      fold.n1655(U32.is_lt(c, 42828), c)

def fold.n1657(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1587(U32.is_lt(c, 42587), c)
    case False{}:
      fold.n1656(U32.is_lt(c, 42811), c)

def fold.n1658(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1519(U32.is_lt(c, 11422), c)
    case False{}:
      fold.n1657(U32.is_lt(c, 42640), c)

def fold.n1659(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1382(U32.is_lt(c, 8121), c)
    case False{}:
      fold.n1658(U32.is_lt(c, 11491), c)

def fold.n1660(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A75F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1661(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A761}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1662(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1660(U32.is_lt(c, 42847), c)
    case False{}:
      fold.n1661(U32.is_lt(c, 42849), c)

def fold.n1663(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A763}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1664(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A765}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1665(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1663(U32.is_lt(c, 42851), c)
    case False{}:
      fold.n1664(U32.is_lt(c, 42853), c)

def fold.n1666(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1662(U32.is_lt(c, 42848), c)
    case False{}:
      fold.n1665(U32.is_lt(c, 42852), c)

def fold.n1667(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A767}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1668(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A769}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1669(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1667(U32.is_lt(c, 42855), c)
    case False{}:
      fold.n1668(U32.is_lt(c, 42857), c)

def fold.n1670(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A76B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1671(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A76F}"

def fold.n1672(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A76D}"
    case False{}:
      fold.n1671(U32.is_lt(c, 42862), c)

def fold.n1673(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1670(U32.is_lt(c, 42859), c)
    case False{}:
      fold.n1672(U32.is_lt(c, 42861), c)

def fold.n1674(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1669(U32.is_lt(c, 42856), c)
    case False{}:
      fold.n1673(U32.is_lt(c, 42860), c)

def fold.n1675(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1666(U32.is_lt(c, 42850), c)
    case False{}:
      fold.n1674(U32.is_lt(c, 42858), c)

def fold.n1676(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A77A}"

def fold.n1677(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A77C}"

def fold.n1678(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1676(U32.is_lt(c, 42873), c)
    case False{}:
      fold.n1677(U32.is_lt(c, 42875), c)

def fold.n1679(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{1D79}"

def fold.n1680(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A77F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1681(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1679(U32.is_lt(c, 42877), c)
    case False{}:
      fold.n1680(U32.is_lt(c, 42879), c)

def fold.n1682(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1678(U32.is_lt(c, 42874), c)
    case False{}:
      fold.n1681(U32.is_lt(c, 42878), c)

def fold.n1683(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A781}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1684(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A783}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1685(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1683(U32.is_lt(c, 42881), c)
    case False{}:
      fold.n1684(U32.is_lt(c, 42883), c)

def fold.n1686(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A785}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1687(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A78C}"

def fold.n1688(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A787}"
    case False{}:
      fold.n1687(U32.is_lt(c, 42891), c)

def fold.n1689(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1686(U32.is_lt(c, 42885), c)
    case False{}:
      fold.n1688(U32.is_lt(c, 42887), c)

def fold.n1690(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1685(U32.is_lt(c, 42882), c)
    case False{}:
      fold.n1689(U32.is_lt(c, 42886), c)

def fold.n1691(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1682(U32.is_lt(c, 42876), c)
    case False{}:
      fold.n1690(U32.is_lt(c, 42884), c)

def fold.n1692(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1675(U32.is_lt(c, 42854), c)
    case False{}:
      fold.n1691(U32.is_lt(c, 42880), c)

def fold.n1693(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{265}"

def fold.n1694(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A791}"

def fold.n1695(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1693(U32.is_lt(c, 42893), c)
    case False{}:
      fold.n1694(U32.is_lt(c, 42896), c)

def fold.n1696(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A793}"

def fold.n1697(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A797}"

def fold.n1698(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1696(U32.is_lt(c, 42898), c)
    case False{}:
      fold.n1697(U32.is_lt(c, 42902), c)

def fold.n1699(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1695(U32.is_lt(c, 42894), c)
    case False{}:
      fold.n1698(U32.is_lt(c, 42899), c)

def fold.n1700(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A799}"

def fold.n1701(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A79B}"

def fold.n1702(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1700(U32.is_lt(c, 42904), c)
    case False{}:
      fold.n1701(U32.is_lt(c, 42906), c)

def fold.n1703(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A79D}"

def fold.n1704(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A79F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1705(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1704(U32.is_lt(c, 42911), c)

def fold.n1706(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1703(U32.is_lt(c, 42908), c)
    case False{}:
      fold.n1705(U32.is_lt(c, 42910), c)

def fold.n1707(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1702(U32.is_lt(c, 42905), c)
    case False{}:
      fold.n1706(U32.is_lt(c, 42909), c)

def fold.n1708(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1699(U32.is_lt(c, 42897), c)
    case False{}:
      fold.n1707(U32.is_lt(c, 42907), c)

def fold.n1709(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7A1}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1710(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7A3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1711(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1709(U32.is_lt(c, 42913), c)
    case False{}:
      fold.n1710(U32.is_lt(c, 42915), c)

def fold.n1712(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7A5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1713(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A7A9}"

def fold.n1714(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7A7}"
    case False{}:
      fold.n1713(U32.is_lt(c, 42920), c)

def fold.n1715(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1712(U32.is_lt(c, 42917), c)
    case False{}:
      fold.n1714(U32.is_lt(c, 42919), c)

def fold.n1716(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1711(U32.is_lt(c, 42914), c)
    case False{}:
      fold.n1715(U32.is_lt(c, 42918), c)

def fold.n1717(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{266}"

def fold.n1718(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{25C}"
    case False{}:
      "\u{261}"

def fold.n1719(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1717(U32.is_lt(c, 42922), c)
    case False{}:
      fold.n1718(U32.is_lt(c, 42924), c)

def fold.n1720(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{26C}"
    case False{}:
      "\u{26A}"

def fold.n1721(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{29E}"
    case False{}:
      "\u{287}"

def fold.n1722(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1721(U32.is_lt(c, 42929), c)

def fold.n1723(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1720(U32.is_lt(c, 42926), c)
    case False{}:
      fold.n1722(U32.is_lt(c, 42928), c)

def fold.n1724(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1719(U32.is_lt(c, 42923), c)
    case False{}:
      fold.n1723(U32.is_lt(c, 42927), c)

def fold.n1725(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1716(U32.is_lt(c, 42916), c)
    case False{}:
      fold.n1724(U32.is_lt(c, 42925), c)

def fold.n1726(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1708(U32.is_lt(c, 42903), c)
    case False{}:
      fold.n1725(U32.is_lt(c, 42921), c)

def fold.n1727(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1692(U32.is_lt(c, 42863), c)
    case False{}:
      fold.n1726(U32.is_lt(c, 42912), c)

def fold.n1728(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{29D}"
    case False{}:
      "\u{AB53}"

def fold.n1729(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7B5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1730(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1728(U32.is_lt(c, 42931), c)
    case False{}:
      fold.n1729(U32.is_lt(c, 42933), c)

def fold.n1731(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7B7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1732(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1733(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1731(U32.is_lt(c, 42935), c)
    case False{}:
      fold.n1732(U32.is_lt(c, 42937), c)

def fold.n1734(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1730(U32.is_lt(c, 42932), c)
    case False{}:
      fold.n1733(U32.is_lt(c, 42936), c)

def fold.n1735(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7BB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1736(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7BD}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1737(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1735(U32.is_lt(c, 42939), c)
    case False{}:
      fold.n1736(U32.is_lt(c, 42941), c)

def fold.n1738(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7BF}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1739(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A7C3}"

def fold.n1740(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7C1}"
    case False{}:
      fold.n1739(U32.is_lt(c, 42946), c)

def fold.n1741(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1738(U32.is_lt(c, 42943), c)
    case False{}:
      fold.n1740(U32.is_lt(c, 42945), c)

def fold.n1742(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1737(U32.is_lt(c, 42940), c)
    case False{}:
      fold.n1741(U32.is_lt(c, 42944), c)

def fold.n1743(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1734(U32.is_lt(c, 42934), c)
    case False{}:
      fold.n1742(U32.is_lt(c, 42942), c)

def fold.n1744(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A794}"

def fold.n1745(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{282}"
    case False{}:
      "\u{1D8E}"

def fold.n1746(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1744(U32.is_lt(c, 42948), c)
    case False{}:
      fold.n1745(U32.is_lt(c, 42950), c)

def fold.n1747(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7C8}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1748(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7CA}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1749(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1747(U32.is_lt(c, 42952), c)
    case False{}:
      fold.n1748(U32.is_lt(c, 42954), c)

def fold.n1750(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1746(U32.is_lt(c, 42949), c)
    case False{}:
      fold.n1749(U32.is_lt(c, 42953), c)

def fold.n1751(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{264}"
    case False{}:
      "\u{A7CD}"

def fold.n1752(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A7CF}"

def fold.n1753(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1751(U32.is_lt(c, 42956), c)
    case False{}:
      fold.n1752(U32.is_lt(c, 42958), c)

def fold.n1754(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{A7D1}"

def fold.n1755(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7D3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1756(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1755(U32.is_lt(c, 42963), c)

def fold.n1757(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1754(U32.is_lt(c, 42960), c)
    case False{}:
      fold.n1756(U32.is_lt(c, 42962), c)

def fold.n1758(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1753(U32.is_lt(c, 42957), c)
    case False{}:
      fold.n1757(U32.is_lt(c, 42961), c)

def fold.n1759(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1750(U32.is_lt(c, 42951), c)
    case False{}:
      fold.n1758(U32.is_lt(c, 42959), c)

def fold.n1760(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1743(U32.is_lt(c, 42938), c)
    case False{}:
      fold.n1759(U32.is_lt(c, 42955), c)

def fold.n1761(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7D5}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1762(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7D7}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1763(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1761(U32.is_lt(c, 42965), c)
    case False{}:
      fold.n1762(U32.is_lt(c, 42967), c)

def fold.n1764(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7D9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1765(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7DB}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1766(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1764(U32.is_lt(c, 42969), c)
    case False{}:
      fold.n1765(U32.is_lt(c, 42971), c)

def fold.n1767(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1763(U32.is_lt(c, 42966), c)
    case False{}:
      fold.n1766(U32.is_lt(c, 42970), c)

def fold.n1768(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{19B}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1769(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{A7F6}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1770(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1768(U32.is_lt(c, 42973), c)
    case False{}:
      fold.n1769(U32.is_lt(c, 42998), c)

def fold.n1771(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A0}"
    case False{}:
      "\u{13A1}"

def fold.n1772(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A3}"
    case False{}:
      "\u{13A4}"

def fold.n1773(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A2}"
    case False{}:
      fold.n1772(U32.is_lt(c, 43892), c)

def fold.n1774(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1771(U32.is_lt(c, 43889), c)
    case False{}:
      fold.n1773(U32.is_lt(c, 43891), c)

def fold.n1775(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1770(U32.is_lt(c, 42997), c)
    case False{}:
      fold.n1774(U32.is_lt(c, 43890), c)

def fold.n1776(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1767(U32.is_lt(c, 42968), c)
    case False{}:
      fold.n1775(U32.is_lt(c, 43888), c)

def fold.n1777(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A5}"
    case False{}:
      "\u{13A6}"

def fold.n1778(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A7}"
    case False{}:
      "\u{13A8}"

def fold.n1779(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1777(U32.is_lt(c, 43894), c)
    case False{}:
      fold.n1778(U32.is_lt(c, 43896), c)

def fold.n1780(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13A9}"
    case False{}:
      "\u{13AA}"

def fold.n1781(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13AC}"
    case False{}:
      "\u{13AD}"

def fold.n1782(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13AB}"
    case False{}:
      fold.n1781(U32.is_lt(c, 43901), c)

def fold.n1783(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1780(U32.is_lt(c, 43898), c)
    case False{}:
      fold.n1782(U32.is_lt(c, 43900), c)

def fold.n1784(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1779(U32.is_lt(c, 43895), c)
    case False{}:
      fold.n1783(U32.is_lt(c, 43899), c)

def fold.n1785(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13AE}"
    case False{}:
      "\u{13AF}"

def fold.n1786(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B0}"
    case False{}:
      "\u{13B1}"

def fold.n1787(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1785(U32.is_lt(c, 43903), c)
    case False{}:
      fold.n1786(U32.is_lt(c, 43905), c)

def fold.n1788(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B2}"
    case False{}:
      "\u{13B3}"

def fold.n1789(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B5}"
    case False{}:
      "\u{13B6}"

def fold.n1790(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B4}"
    case False{}:
      fold.n1789(U32.is_lt(c, 43910), c)

def fold.n1791(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1788(U32.is_lt(c, 43907), c)
    case False{}:
      fold.n1790(U32.is_lt(c, 43909), c)

def fold.n1792(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1787(U32.is_lt(c, 43904), c)
    case False{}:
      fold.n1791(U32.is_lt(c, 43908), c)

def fold.n1793(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1784(U32.is_lt(c, 43897), c)
    case False{}:
      fold.n1792(U32.is_lt(c, 43906), c)

def fold.n1794(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1776(U32.is_lt(c, 42972), c)
    case False{}:
      fold.n1793(U32.is_lt(c, 43902), c)

def fold.n1795(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1760(U32.is_lt(c, 42947), c)
    case False{}:
      fold.n1794(U32.is_lt(c, 43893), c)

def fold.n1796(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1727(U32.is_lt(c, 42892), c)
    case False{}:
      fold.n1795(U32.is_lt(c, 42964), c)

def fold.n1797(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B7}"
    case False{}:
      "\u{13B8}"

def fold.n1798(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13B9}"
    case False{}:
      "\u{13BA}"

def fold.n1799(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1797(U32.is_lt(c, 43912), c)
    case False{}:
      fold.n1798(U32.is_lt(c, 43914), c)

def fold.n1800(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13BB}"
    case False{}:
      "\u{13BC}"

def fold.n1801(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13BD}"
    case False{}:
      "\u{13BE}"

def fold.n1802(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1800(U32.is_lt(c, 43916), c)
    case False{}:
      fold.n1801(U32.is_lt(c, 43918), c)

def fold.n1803(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1799(U32.is_lt(c, 43913), c)
    case False{}:
      fold.n1802(U32.is_lt(c, 43917), c)

def fold.n1804(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13BF}"
    case False{}:
      "\u{13C0}"

def fold.n1805(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13C1}"
    case False{}:
      "\u{13C2}"

def fold.n1806(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1804(U32.is_lt(c, 43920), c)
    case False{}:
      fold.n1805(U32.is_lt(c, 43922), c)

def fold.n1807(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13C3}"
    case False{}:
      "\u{13C4}"

def fold.n1808(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13C6}"
    case False{}:
      "\u{13C7}"

def fold.n1809(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13C5}"
    case False{}:
      fold.n1808(U32.is_lt(c, 43927), c)

def fold.n1810(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1807(U32.is_lt(c, 43924), c)
    case False{}:
      fold.n1809(U32.is_lt(c, 43926), c)

def fold.n1811(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1806(U32.is_lt(c, 43921), c)
    case False{}:
      fold.n1810(U32.is_lt(c, 43925), c)

def fold.n1812(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1803(U32.is_lt(c, 43915), c)
    case False{}:
      fold.n1811(U32.is_lt(c, 43923), c)

def fold.n1813(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13C8}"
    case False{}:
      "\u{13C9}"

def fold.n1814(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13CA}"
    case False{}:
      "\u{13CB}"

def fold.n1815(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1813(U32.is_lt(c, 43929), c)
    case False{}:
      fold.n1814(U32.is_lt(c, 43931), c)

def fold.n1816(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13CC}"
    case False{}:
      "\u{13CD}"

def fold.n1817(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13CE}"
    case False{}:
      "\u{13CF}"

def fold.n1818(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1816(U32.is_lt(c, 43933), c)
    case False{}:
      fold.n1817(U32.is_lt(c, 43935), c)

def fold.n1819(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1815(U32.is_lt(c, 43930), c)
    case False{}:
      fold.n1818(U32.is_lt(c, 43934), c)

def fold.n1820(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D0}"
    case False{}:
      "\u{13D1}"

def fold.n1821(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D2}"
    case False{}:
      "\u{13D3}"

def fold.n1822(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1820(U32.is_lt(c, 43937), c)
    case False{}:
      fold.n1821(U32.is_lt(c, 43939), c)

def fold.n1823(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D4}"
    case False{}:
      "\u{13D5}"

def fold.n1824(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D7}"
    case False{}:
      "\u{13D8}"

def fold.n1825(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D6}"
    case False{}:
      fold.n1824(U32.is_lt(c, 43944), c)

def fold.n1826(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1823(U32.is_lt(c, 43941), c)
    case False{}:
      fold.n1825(U32.is_lt(c, 43943), c)

def fold.n1827(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1822(U32.is_lt(c, 43938), c)
    case False{}:
      fold.n1826(U32.is_lt(c, 43942), c)

def fold.n1828(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1819(U32.is_lt(c, 43932), c)
    case False{}:
      fold.n1827(U32.is_lt(c, 43940), c)

def fold.n1829(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1812(U32.is_lt(c, 43919), c)
    case False{}:
      fold.n1828(U32.is_lt(c, 43936), c)

def fold.n1830(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13D9}"
    case False{}:
      "\u{13DA}"

def fold.n1831(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13DB}"
    case False{}:
      "\u{13DC}"

def fold.n1832(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1830(U32.is_lt(c, 43946), c)
    case False{}:
      fold.n1831(U32.is_lt(c, 43948), c)

def fold.n1833(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13DD}"
    case False{}:
      "\u{13DE}"

def fold.n1834(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13DF}"
    case False{}:
      "\u{13E0}"

def fold.n1835(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1833(U32.is_lt(c, 43950), c)
    case False{}:
      fold.n1834(U32.is_lt(c, 43952), c)

def fold.n1836(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1832(U32.is_lt(c, 43947), c)
    case False{}:
      fold.n1835(U32.is_lt(c, 43951), c)

def fold.n1837(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13E1}"
    case False{}:
      "\u{13E2}"

def fold.n1838(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13E3}"
    case False{}:
      "\u{13E4}"

def fold.n1839(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1837(U32.is_lt(c, 43954), c)
    case False{}:
      fold.n1838(U32.is_lt(c, 43956), c)

def fold.n1840(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13E5}"
    case False{}:
      "\u{13E6}"

def fold.n1841(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13E8}"
    case False{}:
      "\u{13E9}"

def fold.n1842(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13E7}"
    case False{}:
      fold.n1841(U32.is_lt(c, 43961), c)

def fold.n1843(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1840(U32.is_lt(c, 43958), c)
    case False{}:
      fold.n1842(U32.is_lt(c, 43960), c)

def fold.n1844(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1839(U32.is_lt(c, 43955), c)
    case False{}:
      fold.n1843(U32.is_lt(c, 43959), c)

def fold.n1845(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1836(U32.is_lt(c, 43949), c)
    case False{}:
      fold.n1844(U32.is_lt(c, 43957), c)

def fold.n1846(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13EA}"
    case False{}:
      "\u{13EB}"

def fold.n1847(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13EC}"
    case False{}:
      "\u{13ED}"

def fold.n1848(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1846(U32.is_lt(c, 43963), c)
    case False{}:
      fold.n1847(U32.is_lt(c, 43965), c)

def fold.n1849(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{13EE}"
    case False{}:
      "\u{13EF}"

def fold.n1850(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66}\u{66}"
    case False{}:
      "\u{66}\u{69}"

def fold.n1851(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1850(U32.is_lt(c, 64257), c)

def fold.n1852(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1849(U32.is_lt(c, 43967), c)
    case False{}:
      fold.n1851(U32.is_lt(c, 64256), c)

def fold.n1853(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1848(U32.is_lt(c, 43964), c)
    case False{}:
      fold.n1852(U32.is_lt(c, 43968), c)

def fold.n1854(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66}\u{6C}"
    case False{}:
      "\u{66}\u{66}\u{69}"

def fold.n1855(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{66}\u{66}\u{6C}"
    case False{}:
      "\u{73}\u{74}"

def fold.n1856(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1854(U32.is_lt(c, 64259), c)
    case False{}:
      fold.n1855(U32.is_lt(c, 64261), c)

def fold.n1857(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{574}\u{576}"

def fold.n1858(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{574}\u{56B}"
    case False{}:
      "\u{57E}\u{576}"

def fold.n1859(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{574}\u{565}"
    case False{}:
      fold.n1858(U32.is_lt(c, 64278), c)

def fold.n1860(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1857(U32.is_lt(c, 64275), c)
    case False{}:
      fold.n1859(U32.is_lt(c, 64277), c)

def fold.n1861(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1856(U32.is_lt(c, 64260), c)
    case False{}:
      fold.n1860(U32.is_lt(c, 64276), c)

def fold.n1862(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1853(U32.is_lt(c, 43966), c)
    case False{}:
      fold.n1861(U32.is_lt(c, 64263), c)

def fold.n1863(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1845(U32.is_lt(c, 43953), c)
    case False{}:
      fold.n1862(U32.is_lt(c, 64258), c)

def fold.n1864(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1829(U32.is_lt(c, 43928), c)
    case False{}:
      fold.n1863(U32.is_lt(c, 43962), c)

def fold.n1865(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{574}\u{56D}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1866(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF41}"
    case False{}:
      "\u{FF42}"

def fold.n1867(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1865(U32.is_lt(c, 64280), c)
    case False{}:
      fold.n1866(U32.is_lt(c, 65314), c)

def fold.n1868(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF43}"
    case False{}:
      "\u{FF44}"

def fold.n1869(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF45}"
    case False{}:
      "\u{FF46}"

def fold.n1870(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1868(U32.is_lt(c, 65316), c)
    case False{}:
      fold.n1869(U32.is_lt(c, 65318), c)

def fold.n1871(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1867(U32.is_lt(c, 65313), c)
    case False{}:
      fold.n1870(U32.is_lt(c, 65317), c)

def fold.n1872(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF47}"
    case False{}:
      "\u{FF48}"

def fold.n1873(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF49}"
    case False{}:
      "\u{FF4A}"

def fold.n1874(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1872(U32.is_lt(c, 65320), c)
    case False{}:
      fold.n1873(U32.is_lt(c, 65322), c)

def fold.n1875(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF4B}"
    case False{}:
      "\u{FF4C}"

def fold.n1876(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF4E}"
    case False{}:
      "\u{FF4F}"

def fold.n1877(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF4D}"
    case False{}:
      fold.n1876(U32.is_lt(c, 65327), c)

def fold.n1878(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1875(U32.is_lt(c, 65324), c)
    case False{}:
      fold.n1877(U32.is_lt(c, 65326), c)

def fold.n1879(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1874(U32.is_lt(c, 65321), c)
    case False{}:
      fold.n1878(U32.is_lt(c, 65325), c)

def fold.n1880(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1871(U32.is_lt(c, 65315), c)
    case False{}:
      fold.n1879(U32.is_lt(c, 65323), c)

def fold.n1881(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF50}"
    case False{}:
      "\u{FF51}"

def fold.n1882(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF52}"
    case False{}:
      "\u{FF53}"

def fold.n1883(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1881(U32.is_lt(c, 65329), c)
    case False{}:
      fold.n1882(U32.is_lt(c, 65331), c)

def fold.n1884(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF54}"
    case False{}:
      "\u{FF55}"

def fold.n1885(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF57}"
    case False{}:
      "\u{FF58}"

def fold.n1886(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF56}"
    case False{}:
      fold.n1885(U32.is_lt(c, 65336), c)

def fold.n1887(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1884(U32.is_lt(c, 65333), c)
    case False{}:
      fold.n1886(U32.is_lt(c, 65335), c)

def fold.n1888(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1883(U32.is_lt(c, 65330), c)
    case False{}:
      fold.n1887(U32.is_lt(c, 65334), c)

def fold.n1889(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{FF59}"
    case False{}:
      "\u{FF5A}"

def fold.n1890(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{10428}"

def fold.n1891(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1889(U32.is_lt(c, 65338), c)
    case False{}:
      fold.n1890(U32.is_lt(c, 66560), c)

def fold.n1892(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10429}"
    case False{}:
      "\u{1042A}"

def fold.n1893(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1042C}"
    case False{}:
      "\u{1042D}"

def fold.n1894(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1042B}"
    case False{}:
      fold.n1893(U32.is_lt(c, 66565), c)

def fold.n1895(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1892(U32.is_lt(c, 66562), c)
    case False{}:
      fold.n1894(U32.is_lt(c, 66564), c)

def fold.n1896(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1891(U32.is_lt(c, 65339), c)
    case False{}:
      fold.n1895(U32.is_lt(c, 66563), c)

def fold.n1897(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1888(U32.is_lt(c, 65332), c)
    case False{}:
      fold.n1896(U32.is_lt(c, 66561), c)

def fold.n1898(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1880(U32.is_lt(c, 65319), c)
    case False{}:
      fold.n1897(U32.is_lt(c, 65337), c)

def fold.n1899(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1042E}"
    case False{}:
      "\u{1042F}"

def fold.n1900(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10430}"
    case False{}:
      "\u{10431}"

def fold.n1901(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1899(U32.is_lt(c, 66567), c)
    case False{}:
      fold.n1900(U32.is_lt(c, 66569), c)

def fold.n1902(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10432}"
    case False{}:
      "\u{10433}"

def fold.n1903(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10434}"
    case False{}:
      "\u{10435}"

def fold.n1904(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1902(U32.is_lt(c, 66571), c)
    case False{}:
      fold.n1903(U32.is_lt(c, 66573), c)

def fold.n1905(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1901(U32.is_lt(c, 66568), c)
    case False{}:
      fold.n1904(U32.is_lt(c, 66572), c)

def fold.n1906(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10436}"
    case False{}:
      "\u{10437}"

def fold.n1907(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10438}"
    case False{}:
      "\u{10439}"

def fold.n1908(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1906(U32.is_lt(c, 66575), c)
    case False{}:
      fold.n1907(U32.is_lt(c, 66577), c)

def fold.n1909(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1043A}"
    case False{}:
      "\u{1043B}"

def fold.n1910(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1043D}"
    case False{}:
      "\u{1043E}"

def fold.n1911(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1043C}"
    case False{}:
      fold.n1910(U32.is_lt(c, 66582), c)

def fold.n1912(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1909(U32.is_lt(c, 66579), c)
    case False{}:
      fold.n1911(U32.is_lt(c, 66581), c)

def fold.n1913(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1908(U32.is_lt(c, 66576), c)
    case False{}:
      fold.n1912(U32.is_lt(c, 66580), c)

def fold.n1914(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1905(U32.is_lt(c, 66570), c)
    case False{}:
      fold.n1913(U32.is_lt(c, 66578), c)

def fold.n1915(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1043F}"
    case False{}:
      "\u{10440}"

def fold.n1916(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10441}"
    case False{}:
      "\u{10442}"

def fold.n1917(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1915(U32.is_lt(c, 66584), c)
    case False{}:
      fold.n1916(U32.is_lt(c, 66586), c)

def fold.n1918(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10443}"
    case False{}:
      "\u{10444}"

def fold.n1919(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10446}"
    case False{}:
      "\u{10447}"

def fold.n1920(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10445}"
    case False{}:
      fold.n1919(U32.is_lt(c, 66591), c)

def fold.n1921(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1918(U32.is_lt(c, 66588), c)
    case False{}:
      fold.n1920(U32.is_lt(c, 66590), c)

def fold.n1922(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1917(U32.is_lt(c, 66585), c)
    case False{}:
      fold.n1921(U32.is_lt(c, 66589), c)

def fold.n1923(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10448}"
    case False{}:
      "\u{10449}"

def fold.n1924(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1044A}"
    case False{}:
      "\u{1044B}"

def fold.n1925(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1923(U32.is_lt(c, 66593), c)
    case False{}:
      fold.n1924(U32.is_lt(c, 66595), c)

def fold.n1926(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1044C}"
    case False{}:
      "\u{1044D}"

def fold.n1927(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1044F}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n1928(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1044E}"
    case False{}:
      fold.n1927(U32.is_lt(c, 66600), c)

def fold.n1929(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1926(U32.is_lt(c, 66597), c)
    case False{}:
      fold.n1928(U32.is_lt(c, 66599), c)

def fold.n1930(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1925(U32.is_lt(c, 66594), c)
    case False{}:
      fold.n1929(U32.is_lt(c, 66598), c)

def fold.n1931(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1922(U32.is_lt(c, 66587), c)
    case False{}:
      fold.n1930(U32.is_lt(c, 66596), c)

def fold.n1932(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1914(U32.is_lt(c, 66574), c)
    case False{}:
      fold.n1931(U32.is_lt(c, 66592), c)

def fold.n1933(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1898(U32.is_lt(c, 65328), c)
    case False{}:
      fold.n1932(U32.is_lt(c, 66583), c)

def fold.n1934(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1864(U32.is_lt(c, 43945), c)
    case False{}:
      fold.n1933(U32.is_lt(c, 66566), c)

def fold.n1935(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1796(U32.is_lt(c, 42930), c)
    case False{}:
      fold.n1934(U32.is_lt(c, 64279), c)

def fold.n1936(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104D8}"
    case False{}:
      "\u{104D9}"

def fold.n1937(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104DA}"
    case False{}:
      "\u{104DB}"

def fold.n1938(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1936(U32.is_lt(c, 66737), c)
    case False{}:
      fold.n1937(U32.is_lt(c, 66739), c)

def fold.n1939(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104DC}"
    case False{}:
      "\u{104DD}"

def fold.n1940(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104DE}"
    case False{}:
      "\u{104DF}"

def fold.n1941(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1939(U32.is_lt(c, 66741), c)
    case False{}:
      fold.n1940(U32.is_lt(c, 66743), c)

def fold.n1942(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1938(U32.is_lt(c, 66738), c)
    case False{}:
      fold.n1941(U32.is_lt(c, 66742), c)

def fold.n1943(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E0}"
    case False{}:
      "\u{104E1}"

def fold.n1944(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E2}"
    case False{}:
      "\u{104E3}"

def fold.n1945(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1943(U32.is_lt(c, 66745), c)
    case False{}:
      fold.n1944(U32.is_lt(c, 66747), c)

def fold.n1946(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E4}"
    case False{}:
      "\u{104E5}"

def fold.n1947(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E7}"
    case False{}:
      "\u{104E8}"

def fold.n1948(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E6}"
    case False{}:
      fold.n1947(U32.is_lt(c, 66752), c)

def fold.n1949(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1946(U32.is_lt(c, 66749), c)
    case False{}:
      fold.n1948(U32.is_lt(c, 66751), c)

def fold.n1950(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1945(U32.is_lt(c, 66746), c)
    case False{}:
      fold.n1949(U32.is_lt(c, 66750), c)

def fold.n1951(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1942(U32.is_lt(c, 66740), c)
    case False{}:
      fold.n1950(U32.is_lt(c, 66748), c)

def fold.n1952(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104E9}"
    case False{}:
      "\u{104EA}"

def fold.n1953(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104EB}"
    case False{}:
      "\u{104EC}"

def fold.n1954(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1952(U32.is_lt(c, 66754), c)
    case False{}:
      fold.n1953(U32.is_lt(c, 66756), c)

def fold.n1955(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104ED}"
    case False{}:
      "\u{104EE}"

def fold.n1956(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104EF}"
    case False{}:
      "\u{104F0}"

def fold.n1957(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1955(U32.is_lt(c, 66758), c)
    case False{}:
      fold.n1956(U32.is_lt(c, 66760), c)

def fold.n1958(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1954(U32.is_lt(c, 66755), c)
    case False{}:
      fold.n1957(U32.is_lt(c, 66759), c)

def fold.n1959(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104F1}"
    case False{}:
      "\u{104F2}"

def fold.n1960(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104F3}"
    case False{}:
      "\u{104F4}"

def fold.n1961(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1959(U32.is_lt(c, 66762), c)
    case False{}:
      fold.n1960(U32.is_lt(c, 66764), c)

def fold.n1962(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104F5}"
    case False{}:
      "\u{104F6}"

def fold.n1963(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104F8}"
    case False{}:
      "\u{104F9}"

def fold.n1964(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104F7}"
    case False{}:
      fold.n1963(U32.is_lt(c, 66769), c)

def fold.n1965(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1962(U32.is_lt(c, 66766), c)
    case False{}:
      fold.n1964(U32.is_lt(c, 66768), c)

def fold.n1966(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1961(U32.is_lt(c, 66763), c)
    case False{}:
      fold.n1965(U32.is_lt(c, 66767), c)

def fold.n1967(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1958(U32.is_lt(c, 66757), c)
    case False{}:
      fold.n1966(U32.is_lt(c, 66765), c)

def fold.n1968(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1951(U32.is_lt(c, 66744), c)
    case False{}:
      fold.n1967(U32.is_lt(c, 66761), c)

def fold.n1969(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{104FA}"
    case False{}:
      "\u{104FB}"

def fold.n1970(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{10597}"

def fold.n1971(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1969(U32.is_lt(c, 66771), c)
    case False{}:
      fold.n1970(U32.is_lt(c, 66928), c)

def fold.n1972(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10598}"
    case False{}:
      "\u{10599}"

def fold.n1973(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1059A}"
    case False{}:
      "\u{1059B}"

def fold.n1974(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1972(U32.is_lt(c, 66930), c)
    case False{}:
      fold.n1973(U32.is_lt(c, 66932), c)

def fold.n1975(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1971(U32.is_lt(c, 66772), c)
    case False{}:
      fold.n1974(U32.is_lt(c, 66931), c)

def fold.n1976(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1059C}"
    case False{}:
      "\u{1059D}"

def fold.n1977(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1059E}"
    case False{}:
      "\u{1059F}"

def fold.n1978(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1976(U32.is_lt(c, 66934), c)
    case False{}:
      fold.n1977(U32.is_lt(c, 66936), c)

def fold.n1979(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105A0}"
    case False{}:
      "\u{105A1}"

def fold.n1980(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105A3}"
    case False{}:
      "\u{105A4}"

def fold.n1981(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n1980(U32.is_lt(c, 66941), c)

def fold.n1982(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1979(U32.is_lt(c, 66938), c)
    case False{}:
      fold.n1981(U32.is_lt(c, 66940), c)

def fold.n1983(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1978(U32.is_lt(c, 66935), c)
    case False{}:
      fold.n1982(U32.is_lt(c, 66939), c)

def fold.n1984(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1975(U32.is_lt(c, 66929), c)
    case False{}:
      fold.n1983(U32.is_lt(c, 66937), c)

def fold.n1985(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105A5}"
    case False{}:
      "\u{105A6}"

def fold.n1986(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105A7}"
    case False{}:
      "\u{105A8}"

def fold.n1987(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1985(U32.is_lt(c, 66943), c)
    case False{}:
      fold.n1986(U32.is_lt(c, 66945), c)

def fold.n1988(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105A9}"
    case False{}:
      "\u{105AA}"

def fold.n1989(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105AC}"
    case False{}:
      "\u{105AD}"

def fold.n1990(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105AB}"
    case False{}:
      fold.n1989(U32.is_lt(c, 66950), c)

def fold.n1991(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1988(U32.is_lt(c, 66947), c)
    case False{}:
      fold.n1990(U32.is_lt(c, 66949), c)

def fold.n1992(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1987(U32.is_lt(c, 66944), c)
    case False{}:
      fold.n1991(U32.is_lt(c, 66948), c)

def fold.n1993(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105AE}"
    case False{}:
      "\u{105AF}"

def fold.n1994(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105B0}"
    case False{}:
      "\u{105B1}"

def fold.n1995(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1993(U32.is_lt(c, 66952), c)
    case False{}:
      fold.n1994(U32.is_lt(c, 66954), c)

def fold.n1996(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{105B3}"

def fold.n1997(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105B5}"
    case False{}:
      "\u{105B6}"

def fold.n1998(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105B4}"
    case False{}:
      fold.n1997(U32.is_lt(c, 66959), c)

def fold.n1999(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1996(U32.is_lt(c, 66956), c)
    case False{}:
      fold.n1998(U32.is_lt(c, 66958), c)

def fold.n2000(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1995(U32.is_lt(c, 66953), c)
    case False{}:
      fold.n1999(U32.is_lt(c, 66957), c)

def fold.n2001(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1992(U32.is_lt(c, 66946), c)
    case False{}:
      fold.n2000(U32.is_lt(c, 66955), c)

def fold.n2002(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1984(U32.is_lt(c, 66933), c)
    case False{}:
      fold.n2001(U32.is_lt(c, 66951), c)

def fold.n2003(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1968(U32.is_lt(c, 66753), c)
    case False{}:
      fold.n2002(U32.is_lt(c, 66942), c)

def fold.n2004(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105B7}"
    case False{}:
      "\u{105B8}"

def fold.n2005(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105B9}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n2006(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2004(U32.is_lt(c, 66961), c)
    case False{}:
      fold.n2005(U32.is_lt(c, 66963), c)

def fold.n2007(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{105BB}"
    case False{}:
      "\u{105BC}"

def fold.n2008(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{10CC0}"

def fold.n2009(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2007(U32.is_lt(c, 66965), c)
    case False{}:
      fold.n2008(U32.is_lt(c, 68736), c)

def fold.n2010(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2006(U32.is_lt(c, 66962), c)
    case False{}:
      fold.n2009(U32.is_lt(c, 66966), c)

def fold.n2011(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CC1}"
    case False{}:
      "\u{10CC2}"

def fold.n2012(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CC3}"
    case False{}:
      "\u{10CC4}"

def fold.n2013(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2011(U32.is_lt(c, 68738), c)
    case False{}:
      fold.n2012(U32.is_lt(c, 68740), c)

def fold.n2014(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CC5}"
    case False{}:
      "\u{10CC6}"

def fold.n2015(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CC8}"
    case False{}:
      "\u{10CC9}"

def fold.n2016(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CC7}"
    case False{}:
      fold.n2015(U32.is_lt(c, 68745), c)

def fold.n2017(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2014(U32.is_lt(c, 68742), c)
    case False{}:
      fold.n2016(U32.is_lt(c, 68744), c)

def fold.n2018(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2013(U32.is_lt(c, 68739), c)
    case False{}:
      fold.n2017(U32.is_lt(c, 68743), c)

def fold.n2019(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2010(U32.is_lt(c, 66964), c)
    case False{}:
      fold.n2018(U32.is_lt(c, 68741), c)

def fold.n2020(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CCA}"
    case False{}:
      "\u{10CCB}"

def fold.n2021(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CCC}"
    case False{}:
      "\u{10CCD}"

def fold.n2022(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2020(U32.is_lt(c, 68747), c)
    case False{}:
      fold.n2021(U32.is_lt(c, 68749), c)

def fold.n2023(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CCE}"
    case False{}:
      "\u{10CCF}"

def fold.n2024(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD1}"
    case False{}:
      "\u{10CD2}"

def fold.n2025(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD0}"
    case False{}:
      fold.n2024(U32.is_lt(c, 68754), c)

def fold.n2026(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2023(U32.is_lt(c, 68751), c)
    case False{}:
      fold.n2025(U32.is_lt(c, 68753), c)

def fold.n2027(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2022(U32.is_lt(c, 68748), c)
    case False{}:
      fold.n2026(U32.is_lt(c, 68752), c)

def fold.n2028(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD3}"
    case False{}:
      "\u{10CD4}"

def fold.n2029(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD5}"
    case False{}:
      "\u{10CD6}"

def fold.n2030(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2028(U32.is_lt(c, 68756), c)
    case False{}:
      fold.n2029(U32.is_lt(c, 68758), c)

def fold.n2031(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD7}"
    case False{}:
      "\u{10CD8}"

def fold.n2032(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CDA}"
    case False{}:
      "\u{10CDB}"

def fold.n2033(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CD9}"
    case False{}:
      fold.n2032(U32.is_lt(c, 68763), c)

def fold.n2034(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2031(U32.is_lt(c, 68760), c)
    case False{}:
      fold.n2033(U32.is_lt(c, 68762), c)

def fold.n2035(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2030(U32.is_lt(c, 68757), c)
    case False{}:
      fold.n2034(U32.is_lt(c, 68761), c)

def fold.n2036(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2027(U32.is_lt(c, 68750), c)
    case False{}:
      fold.n2035(U32.is_lt(c, 68759), c)

def fold.n2037(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2019(U32.is_lt(c, 68737), c)
    case False{}:
      fold.n2036(U32.is_lt(c, 68755), c)

def fold.n2038(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CDC}"
    case False{}:
      "\u{10CDD}"

def fold.n2039(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CDE}"
    case False{}:
      "\u{10CDF}"

def fold.n2040(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2038(U32.is_lt(c, 68765), c)
    case False{}:
      fold.n2039(U32.is_lt(c, 68767), c)

def fold.n2041(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CE0}"
    case False{}:
      "\u{10CE1}"

def fold.n2042(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CE2}"
    case False{}:
      "\u{10CE3}"

def fold.n2043(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2041(U32.is_lt(c, 68769), c)
    case False{}:
      fold.n2042(U32.is_lt(c, 68771), c)

def fold.n2044(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2040(U32.is_lt(c, 68766), c)
    case False{}:
      fold.n2043(U32.is_lt(c, 68770), c)

def fold.n2045(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CE4}"
    case False{}:
      "\u{10CE5}"

def fold.n2046(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CE6}"
    case False{}:
      "\u{10CE7}"

def fold.n2047(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2045(U32.is_lt(c, 68773), c)
    case False{}:
      fold.n2046(U32.is_lt(c, 68775), c)

def fold.n2048(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CE8}"
    case False{}:
      "\u{10CE9}"

def fold.n2049(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CEB}"
    case False{}:
      "\u{10CEC}"

def fold.n2050(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CEA}"
    case False{}:
      fold.n2049(U32.is_lt(c, 68780), c)

def fold.n2051(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2048(U32.is_lt(c, 68777), c)
    case False{}:
      fold.n2050(U32.is_lt(c, 68779), c)

def fold.n2052(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2047(U32.is_lt(c, 68774), c)
    case False{}:
      fold.n2051(U32.is_lt(c, 68778), c)

def fold.n2053(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2044(U32.is_lt(c, 68768), c)
    case False{}:
      fold.n2052(U32.is_lt(c, 68776), c)

def fold.n2054(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CED}"
    case False{}:
      "\u{10CEE}"

def fold.n2055(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CEF}"
    case False{}:
      "\u{10CF0}"

def fold.n2056(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2054(U32.is_lt(c, 68782), c)
    case False{}:
      fold.n2055(U32.is_lt(c, 68784), c)

def fold.n2057(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10CF1}"
    case False{}:
      "\u{10CF2}"

def fold.n2058(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D70}"
    case False{}:
      "\u{10D71}"

def fold.n2059(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      fold.n2058(U32.is_lt(c, 68945), c)

def fold.n2060(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2057(U32.is_lt(c, 68786), c)
    case False{}:
      fold.n2059(U32.is_lt(c, 68944), c)

def fold.n2061(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2056(U32.is_lt(c, 68783), c)
    case False{}:
      fold.n2060(U32.is_lt(c, 68787), c)

def fold.n2062(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D72}"
    case False{}:
      "\u{10D73}"

def fold.n2063(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D74}"
    case False{}:
      "\u{10D75}"

def fold.n2064(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2062(U32.is_lt(c, 68947), c)
    case False{}:
      fold.n2063(U32.is_lt(c, 68949), c)

def fold.n2065(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D76}"
    case False{}:
      "\u{10D77}"

def fold.n2066(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D79}"
    case False{}:
      "\u{10D7A}"

def fold.n2067(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D78}"
    case False{}:
      fold.n2066(U32.is_lt(c, 68954), c)

def fold.n2068(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2065(U32.is_lt(c, 68951), c)
    case False{}:
      fold.n2067(U32.is_lt(c, 68953), c)

def fold.n2069(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2064(U32.is_lt(c, 68948), c)
    case False{}:
      fold.n2068(U32.is_lt(c, 68952), c)

def fold.n2070(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2061(U32.is_lt(c, 68785), c)
    case False{}:
      fold.n2069(U32.is_lt(c, 68950), c)

def fold.n2071(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2053(U32.is_lt(c, 68772), c)
    case False{}:
      fold.n2070(U32.is_lt(c, 68946), c)

def fold.n2072(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2037(U32.is_lt(c, 68746), c)
    case False{}:
      fold.n2071(U32.is_lt(c, 68781), c)

def fold.n2073(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2003(U32.is_lt(c, 66770), c)
    case False{}:
      fold.n2072(U32.is_lt(c, 68764), c)

def fold.n2074(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D7B}"
    case False{}:
      "\u{10D7C}"

def fold.n2075(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D7D}"
    case False{}:
      "\u{10D7E}"

def fold.n2076(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2074(U32.is_lt(c, 68956), c)
    case False{}:
      fold.n2075(U32.is_lt(c, 68958), c)

def fold.n2077(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D7F}"
    case False{}:
      "\u{10D80}"

def fold.n2078(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D81}"
    case False{}:
      "\u{10D82}"

def fold.n2079(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2077(U32.is_lt(c, 68960), c)
    case False{}:
      fold.n2078(U32.is_lt(c, 68962), c)

def fold.n2080(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2076(U32.is_lt(c, 68957), c)
    case False{}:
      fold.n2079(U32.is_lt(c, 68961), c)

def fold.n2081(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D83}"
    case False{}:
      "\u{10D84}"

def fold.n2082(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{10D85}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n2083(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2081(U32.is_lt(c, 68964), c)
    case False{}:
      fold.n2082(U32.is_lt(c, 68966), c)

def fold.n2084(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C0}"
    case False{}:
      "\u{118C1}"

def fold.n2085(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C3}"
    case False{}:
      "\u{118C4}"

def fold.n2086(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C2}"
    case False{}:
      fold.n2085(U32.is_lt(c, 71844), c)

def fold.n2087(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2084(U32.is_lt(c, 71841), c)
    case False{}:
      fold.n2086(U32.is_lt(c, 71843), c)

def fold.n2088(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2083(U32.is_lt(c, 68965), c)
    case False{}:
      fold.n2087(U32.is_lt(c, 71842), c)

def fold.n2089(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2080(U32.is_lt(c, 68959), c)
    case False{}:
      fold.n2088(U32.is_lt(c, 71840), c)

def fold.n2090(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C5}"
    case False{}:
      "\u{118C6}"

def fold.n2091(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C7}"
    case False{}:
      "\u{118C8}"

def fold.n2092(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2090(U32.is_lt(c, 71846), c)
    case False{}:
      fold.n2091(U32.is_lt(c, 71848), c)

def fold.n2093(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118C9}"
    case False{}:
      "\u{118CA}"

def fold.n2094(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118CB}"
    case False{}:
      "\u{118CC}"

def fold.n2095(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2093(U32.is_lt(c, 71850), c)
    case False{}:
      fold.n2094(U32.is_lt(c, 71852), c)

def fold.n2096(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2092(U32.is_lt(c, 71847), c)
    case False{}:
      fold.n2095(U32.is_lt(c, 71851), c)

def fold.n2097(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118CD}"
    case False{}:
      "\u{118CE}"

def fold.n2098(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118CF}"
    case False{}:
      "\u{118D0}"

def fold.n2099(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2097(U32.is_lt(c, 71854), c)
    case False{}:
      fold.n2098(U32.is_lt(c, 71856), c)

def fold.n2100(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118D1}"
    case False{}:
      "\u{118D2}"

def fold.n2101(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118D4}"
    case False{}:
      "\u{118D5}"

def fold.n2102(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118D3}"
    case False{}:
      fold.n2101(U32.is_lt(c, 71861), c)

def fold.n2103(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2100(U32.is_lt(c, 71858), c)
    case False{}:
      fold.n2102(U32.is_lt(c, 71860), c)

def fold.n2104(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2099(U32.is_lt(c, 71855), c)
    case False{}:
      fold.n2103(U32.is_lt(c, 71859), c)

def fold.n2105(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2096(U32.is_lt(c, 71849), c)
    case False{}:
      fold.n2104(U32.is_lt(c, 71857), c)

def fold.n2106(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2089(U32.is_lt(c, 68963), c)
    case False{}:
      fold.n2105(U32.is_lt(c, 71853), c)

def fold.n2107(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118D6}"
    case False{}:
      "\u{118D7}"

def fold.n2108(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118D8}"
    case False{}:
      "\u{118D9}"

def fold.n2109(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2107(U32.is_lt(c, 71863), c)
    case False{}:
      fold.n2108(U32.is_lt(c, 71865), c)

def fold.n2110(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118DA}"
    case False{}:
      "\u{118DB}"

def fold.n2111(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118DC}"
    case False{}:
      "\u{118DD}"

def fold.n2112(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2110(U32.is_lt(c, 71867), c)
    case False{}:
      fold.n2111(U32.is_lt(c, 71869), c)

def fold.n2113(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2109(U32.is_lt(c, 71864), c)
    case False{}:
      fold.n2112(U32.is_lt(c, 71868), c)

def fold.n2114(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{118DE}"
    case False{}:
      "\u{118DF}"

def fold.n2115(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{16E60}"

def fold.n2116(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2114(U32.is_lt(c, 71871), c)
    case False{}:
      fold.n2115(U32.is_lt(c, 93760), c)

def fold.n2117(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E61}"
    case False{}:
      "\u{16E62}"

def fold.n2118(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E64}"
    case False{}:
      "\u{16E65}"

def fold.n2119(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E63}"
    case False{}:
      fold.n2118(U32.is_lt(c, 93765), c)

def fold.n2120(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2117(U32.is_lt(c, 93762), c)
    case False{}:
      fold.n2119(U32.is_lt(c, 93764), c)

def fold.n2121(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2116(U32.is_lt(c, 71872), c)
    case False{}:
      fold.n2120(U32.is_lt(c, 93763), c)

def fold.n2122(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2113(U32.is_lt(c, 71866), c)
    case False{}:
      fold.n2121(U32.is_lt(c, 93761), c)

def fold.n2123(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E66}"
    case False{}:
      "\u{16E67}"

def fold.n2124(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E68}"
    case False{}:
      "\u{16E69}"

def fold.n2125(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2123(U32.is_lt(c, 93767), c)
    case False{}:
      fold.n2124(U32.is_lt(c, 93769), c)

def fold.n2126(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E6A}"
    case False{}:
      "\u{16E6B}"

def fold.n2127(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E6D}"
    case False{}:
      "\u{16E6E}"

def fold.n2128(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E6C}"
    case False{}:
      fold.n2127(U32.is_lt(c, 93774), c)

def fold.n2129(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2126(U32.is_lt(c, 93771), c)
    case False{}:
      fold.n2128(U32.is_lt(c, 93773), c)

def fold.n2130(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2125(U32.is_lt(c, 93768), c)
    case False{}:
      fold.n2129(U32.is_lt(c, 93772), c)

def fold.n2131(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E6F}"
    case False{}:
      "\u{16E70}"

def fold.n2132(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E71}"
    case False{}:
      "\u{16E72}"

def fold.n2133(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2131(U32.is_lt(c, 93776), c)
    case False{}:
      fold.n2132(U32.is_lt(c, 93778), c)

def fold.n2134(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E73}"
    case False{}:
      "\u{16E74}"

def fold.n2135(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E76}"
    case False{}:
      "\u{16E77}"

def fold.n2136(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E75}"
    case False{}:
      fold.n2135(U32.is_lt(c, 93783), c)

def fold.n2137(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2134(U32.is_lt(c, 93780), c)
    case False{}:
      fold.n2136(U32.is_lt(c, 93782), c)

def fold.n2138(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2133(U32.is_lt(c, 93777), c)
    case False{}:
      fold.n2137(U32.is_lt(c, 93781), c)

def fold.n2139(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2130(U32.is_lt(c, 93770), c)
    case False{}:
      fold.n2138(U32.is_lt(c, 93779), c)

def fold.n2140(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2122(U32.is_lt(c, 71870), c)
    case False{}:
      fold.n2139(U32.is_lt(c, 93775), c)

def fold.n2141(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2106(U32.is_lt(c, 71845), c)
    case False{}:
      fold.n2140(U32.is_lt(c, 93766), c)

def fold.n2142(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E78}"
    case False{}:
      "\u{16E79}"

def fold.n2143(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E7A}"
    case False{}:
      "\u{16E7B}"

def fold.n2144(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2142(U32.is_lt(c, 93785), c)
    case False{}:
      fold.n2143(U32.is_lt(c, 93787), c)

def fold.n2145(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E7C}"
    case False{}:
      "\u{16E7D}"

def fold.n2146(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16E7E}"
    case False{}:
      "\u{16E7F}"

def fold.n2147(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2145(U32.is_lt(c, 93789), c)
    case False{}:
      fold.n2146(U32.is_lt(c, 93791), c)

def fold.n2148(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2144(U32.is_lt(c, 93786), c)
    case False{}:
      fold.n2147(U32.is_lt(c, 93790), c)

def fold.n2149(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      SCon{Chr{c}, SNil{}}
    case False{}:
      "\u{16EBB}"

def fold.n2150(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EBC}"
    case False{}:
      "\u{16EBD}"

def fold.n2151(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2149(U32.is_lt(c, 93856), c)
    case False{}:
      fold.n2150(U32.is_lt(c, 93858), c)

def fold.n2152(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EBE}"
    case False{}:
      "\u{16EBF}"

def fold.n2153(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC1}"
    case False{}:
      "\u{16EC2}"

def fold.n2154(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC0}"
    case False{}:
      fold.n2153(U32.is_lt(c, 93863), c)

def fold.n2155(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2152(U32.is_lt(c, 93860), c)
    case False{}:
      fold.n2154(U32.is_lt(c, 93862), c)

def fold.n2156(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2151(U32.is_lt(c, 93857), c)
    case False{}:
      fold.n2155(U32.is_lt(c, 93861), c)

def fold.n2157(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2148(U32.is_lt(c, 93788), c)
    case False{}:
      fold.n2156(U32.is_lt(c, 93859), c)

def fold.n2158(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC3}"
    case False{}:
      "\u{16EC4}"

def fold.n2159(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC5}"
    case False{}:
      "\u{16EC6}"

def fold.n2160(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2158(U32.is_lt(c, 93865), c)
    case False{}:
      fold.n2159(U32.is_lt(c, 93867), c)

def fold.n2161(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC7}"
    case False{}:
      "\u{16EC8}"

def fold.n2162(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ECA}"
    case False{}:
      "\u{16ECB}"

def fold.n2163(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16EC9}"
    case False{}:
      fold.n2162(U32.is_lt(c, 93872), c)

def fold.n2164(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2161(U32.is_lt(c, 93869), c)
    case False{}:
      fold.n2163(U32.is_lt(c, 93871), c)

def fold.n2165(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2160(U32.is_lt(c, 93866), c)
    case False{}:
      fold.n2164(U32.is_lt(c, 93870), c)

def fold.n2166(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ECC}"
    case False{}:
      "\u{16ECD}"

def fold.n2167(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ECE}"
    case False{}:
      "\u{16ECF}"

def fold.n2168(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2166(U32.is_lt(c, 93874), c)
    case False{}:
      fold.n2167(U32.is_lt(c, 93876), c)

def fold.n2169(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ED0}"
    case False{}:
      "\u{16ED1}"

def fold.n2170(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ED3}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n2171(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{16ED2}"
    case False{}:
      fold.n2170(U32.is_lt(c, 93881), c)

def fold.n2172(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2169(U32.is_lt(c, 93878), c)
    case False{}:
      fold.n2171(U32.is_lt(c, 93880), c)

def fold.n2173(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2168(U32.is_lt(c, 93875), c)
    case False{}:
      fold.n2172(U32.is_lt(c, 93879), c)

def fold.n2174(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2165(U32.is_lt(c, 93868), c)
    case False{}:
      fold.n2173(U32.is_lt(c, 93877), c)

def fold.n2175(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2157(U32.is_lt(c, 93792), c)
    case False{}:
      fold.n2174(U32.is_lt(c, 93873), c)

def fold.n2176(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E922}"
    case False{}:
      "\u{1E923}"

def fold.n2177(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E924}"
    case False{}:
      "\u{1E925}"

def fold.n2178(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2176(U32.is_lt(c, 125185), c)
    case False{}:
      fold.n2177(U32.is_lt(c, 125187), c)

def fold.n2179(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E926}"
    case False{}:
      "\u{1E927}"

def fold.n2180(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E928}"
    case False{}:
      "\u{1E929}"

def fold.n2181(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2179(U32.is_lt(c, 125189), c)
    case False{}:
      fold.n2180(U32.is_lt(c, 125191), c)

def fold.n2182(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2178(U32.is_lt(c, 125186), c)
    case False{}:
      fold.n2181(U32.is_lt(c, 125190), c)

def fold.n2183(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E92A}"
    case False{}:
      "\u{1E92B}"

def fold.n2184(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E92C}"
    case False{}:
      "\u{1E92D}"

def fold.n2185(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2183(U32.is_lt(c, 125193), c)
    case False{}:
      fold.n2184(U32.is_lt(c, 125195), c)

def fold.n2186(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E92E}"
    case False{}:
      "\u{1E92F}"

def fold.n2187(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E931}"
    case False{}:
      "\u{1E932}"

def fold.n2188(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E930}"
    case False{}:
      fold.n2187(U32.is_lt(c, 125200), c)

def fold.n2189(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2186(U32.is_lt(c, 125197), c)
    case False{}:
      fold.n2188(U32.is_lt(c, 125199), c)

def fold.n2190(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2185(U32.is_lt(c, 125194), c)
    case False{}:
      fold.n2189(U32.is_lt(c, 125198), c)

def fold.n2191(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2182(U32.is_lt(c, 125188), c)
    case False{}:
      fold.n2190(U32.is_lt(c, 125196), c)

def fold.n2192(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E933}"
    case False{}:
      "\u{1E934}"

def fold.n2193(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E935}"
    case False{}:
      "\u{1E936}"

def fold.n2194(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2192(U32.is_lt(c, 125202), c)
    case False{}:
      fold.n2193(U32.is_lt(c, 125204), c)

def fold.n2195(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E937}"
    case False{}:
      "\u{1E938}"

def fold.n2196(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E93A}"
    case False{}:
      "\u{1E93B}"

def fold.n2197(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E939}"
    case False{}:
      fold.n2196(U32.is_lt(c, 125209), c)

def fold.n2198(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2195(U32.is_lt(c, 125206), c)
    case False{}:
      fold.n2197(U32.is_lt(c, 125208), c)

def fold.n2199(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2194(U32.is_lt(c, 125203), c)
    case False{}:
      fold.n2198(U32.is_lt(c, 125207), c)

def fold.n2200(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E93C}"
    case False{}:
      "\u{1E93D}"

def fold.n2201(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E93E}"
    case False{}:
      "\u{1E93F}"

def fold.n2202(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2200(U32.is_lt(c, 125211), c)
    case False{}:
      fold.n2201(U32.is_lt(c, 125213), c)

def fold.n2203(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E940}"
    case False{}:
      "\u{1E941}"

def fold.n2204(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E943}"
    case False{}:
      SCon{Chr{c}, SNil{}}

def fold.n2205(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      "\u{1E942}"
    case False{}:
      fold.n2204(U32.is_lt(c, 125218), c)

def fold.n2206(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2203(U32.is_lt(c, 125215), c)
    case False{}:
      fold.n2205(U32.is_lt(c, 125217), c)

def fold.n2207(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2202(U32.is_lt(c, 125212), c)
    case False{}:
      fold.n2206(U32.is_lt(c, 125216), c)

def fold.n2208(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2199(U32.is_lt(c, 125205), c)
    case False{}:
      fold.n2207(U32.is_lt(c, 125214), c)

def fold.n2209(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2191(U32.is_lt(c, 125192), c)
    case False{}:
      fold.n2208(U32.is_lt(c, 125210), c)

def fold.n2210(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2175(U32.is_lt(c, 93864), c)
    case False{}:
      fold.n2209(U32.is_lt(c, 125201), c)

def fold.n2211(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2141(U32.is_lt(c, 71862), c)
    case False{}:
      fold.n2210(U32.is_lt(c, 125184), c)

def fold.n2212(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n2073(U32.is_lt(c, 66960), c)
    case False{}:
      fold.n2211(U32.is_lt(c, 93784), c)

def fold.n2213(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1935(U32.is_lt(c, 43911), c)
    case False{}:
      fold.n2212(U32.is_lt(c, 68955), c)

def fold.n2214(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1659(U32.is_lt(c, 11297), c)
    case False{}:
      fold.n2213(U32.is_lt(c, 66736), c)

def fold.n2215(lt: Bool, +c: U32) -> String:
  match lt:
    case True{}:
      fold.n1106(U32.is_lt(c, 1153), c)
    case False{}:
      fold.n2214(U32.is_lt(c, 42846), c)

def fold(+c: U32) -> String:
  fold.n2215(U32.is_lt(c, 7920), c)

def gb.n0(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      2

def gb.n1(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      1

def gb.n2(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n0(U32.is_lt(c, 10), c)
    case False{}:
      gb.n1(U32.is_lt(c, 13), c)

def gb.n3(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n4(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n5(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n3(U32.is_lt(c, 32), c)
    case False{}:
      gb.n4(U32.is_lt(c, 160), c)

def gb.n6(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2(U32.is_lt(c, 11), c)
    case False{}:
      gb.n5(U32.is_lt(c, 127), c)

def gb.n7(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n8(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      16

def gb.n9(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n7(U32.is_lt(c, 170), c)
    case False{}:
      gb.n8(U32.is_lt(c, 174), c)

def gb.n10(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n11(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n12(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n10(U32.is_lt(c, 768), c)
    case False{}:
      gb.n11(U32.is_lt(c, 1155), c)

def gb.n13(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n9(U32.is_lt(c, 173), c)
    case False{}:
      gb.n12(U32.is_lt(c, 880), c)

def gb.n14(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n6(U32.is_lt(c, 14), c)
    case False{}:
      gb.n13(U32.is_lt(c, 175), c)

def gb.n15(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n16(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n17(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n15(U32.is_lt(c, 1425), c)
    case False{}:
      gb.n16(U32.is_lt(c, 1471), c)

def gb.n18(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n19(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n20(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n18(U32.is_lt(c, 1473), c)
    case False{}:
      gb.n19(U32.is_lt(c, 1476), c)

def gb.n21(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n17(U32.is_lt(c, 1470), c)
    case False{}:
      gb.n20(U32.is_lt(c, 1475), c)

def gb.n22(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n23(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def gb.n24(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n22(U32.is_lt(c, 1479), c)
    case False{}:
      gb.n23(U32.is_lt(c, 1536), c)

def gb.n25(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n26(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n27(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n26(U32.is_lt(c, 1565), c)

def gb.n28(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n25(U32.is_lt(c, 1552), c)
    case False{}:
      gb.n27(U32.is_lt(c, 1564), c)

def gb.n29(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n24(U32.is_lt(c, 1480), c)
    case False{}:
      gb.n28(U32.is_lt(c, 1563), c)

def gb.n30(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n21(U32.is_lt(c, 1472), c)
    case False{}:
      gb.n29(U32.is_lt(c, 1542), c)

def gb.n31(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n14(U32.is_lt(c, 169), c)
    case False{}:
      gb.n30(U32.is_lt(c, 1478), c)

def gb.n32(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n33(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n34(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n32(U32.is_lt(c, 1632), c)
    case False{}:
      gb.n33(U32.is_lt(c, 1649), c)

def gb.n35(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      7

def gb.n36(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n37(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n35(U32.is_lt(c, 1757), c)
    case False{}:
      gb.n36(U32.is_lt(c, 1759), c)

def gb.n38(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n34(U32.is_lt(c, 1648), c)
    case False{}:
      gb.n37(U32.is_lt(c, 1758), c)

def gb.n39(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n40(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n41(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n39(U32.is_lt(c, 1767), c)
    case False{}:
      gb.n40(U32.is_lt(c, 1770), c)

def gb.n42(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def gb.n43(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n44(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n43(U32.is_lt(c, 1810), c)

def gb.n45(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n42(U32.is_lt(c, 1807), c)
    case False{}:
      gb.n44(U32.is_lt(c, 1809), c)

def gb.n46(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n41(U32.is_lt(c, 1769), c)
    case False{}:
      gb.n45(U32.is_lt(c, 1808), c)

def gb.n47(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n38(U32.is_lt(c, 1750), c)
    case False{}:
      gb.n46(U32.is_lt(c, 1774), c)

def gb.n48(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n49(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n50(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n48(U32.is_lt(c, 1867), c)
    case False{}:
      gb.n49(U32.is_lt(c, 1969), c)

def gb.n51(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n52(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n53(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n51(U32.is_lt(c, 2036), c)
    case False{}:
      gb.n52(U32.is_lt(c, 2046), c)

def gb.n54(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n50(U32.is_lt(c, 1958), c)
    case False{}:
      gb.n53(U32.is_lt(c, 2045), c)

def gb.n55(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n56(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n57(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n55(U32.is_lt(c, 2074), c)
    case False{}:
      gb.n56(U32.is_lt(c, 2084), c)

def gb.n58(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n59(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n60(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n59(U32.is_lt(c, 2137), c)

def gb.n61(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n58(U32.is_lt(c, 2088), c)
    case False{}:
      gb.n60(U32.is_lt(c, 2094), c)

def gb.n62(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n57(U32.is_lt(c, 2075), c)
    case False{}:
      gb.n61(U32.is_lt(c, 2089), c)

def gb.n63(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n54(U32.is_lt(c, 2027), c)
    case False{}:
      gb.n62(U32.is_lt(c, 2085), c)

def gb.n64(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n47(U32.is_lt(c, 1765), c)
    case False{}:
      gb.n63(U32.is_lt(c, 2070), c)

def gb.n65(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n31(U32.is_lt(c, 1162), c)
    case False{}:
      gb.n64(U32.is_lt(c, 1840), c)

def gb.n66(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def gb.n67(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n68(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n66(U32.is_lt(c, 2192), c)
    case False{}:
      gb.n67(U32.is_lt(c, 2199), c)

def gb.n69(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n70(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      68

def gb.n71(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n69(U32.is_lt(c, 2250), c)
    case False{}:
      gb.n70(U32.is_lt(c, 2275), c)

def gb.n72(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n68(U32.is_lt(c, 2194), c)
    case False{}:
      gb.n71(U32.is_lt(c, 2274), c)

def gb.n73(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n74(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      68

def gb.n75(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n73(U32.is_lt(c, 2308), c)
    case False{}:
      gb.n74(U32.is_lt(c, 2362), c)

def gb.n76(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n77(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n78(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n77(U32.is_lt(c, 2369), c)

def gb.n79(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n76(U32.is_lt(c, 2364), c)
    case False{}:
      gb.n78(U32.is_lt(c, 2366), c)

def gb.n80(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n75(U32.is_lt(c, 2325), c)
    case False{}:
      gb.n79(U32.is_lt(c, 2365), c)

def gb.n81(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n72(U32.is_lt(c, 2208), c)
    case False{}:
      gb.n80(U32.is_lt(c, 2363), c)

def gb.n82(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      100

def gb.n83(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n84(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n82(U32.is_lt(c, 2381), c)
    case False{}:
      gb.n83(U32.is_lt(c, 2384), c)

def gb.n85(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n86(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n87(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n85(U32.is_lt(c, 2392), c)
    case False{}:
      gb.n86(U32.is_lt(c, 2402), c)

def gb.n88(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n84(U32.is_lt(c, 2382), c)
    case False{}:
      gb.n87(U32.is_lt(c, 2400), c)

def gb.n89(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n90(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n91(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n89(U32.is_lt(c, 2424), c)
    case False{}:
      gb.n90(U32.is_lt(c, 2433), c)

def gb.n92(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n93(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n94(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n93(U32.is_lt(c, 2474), c)

def gb.n95(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n92(U32.is_lt(c, 2436), c)
    case False{}:
      gb.n94(U32.is_lt(c, 2473), c)

def gb.n96(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n91(U32.is_lt(c, 2432), c)
    case False{}:
      gb.n95(U32.is_lt(c, 2453), c)

def gb.n97(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n88(U32.is_lt(c, 2385), c)
    case False{}:
      gb.n96(U32.is_lt(c, 2434), c)

def gb.n98(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n81(U32.is_lt(c, 2307), c)
    case False{}:
      gb.n97(U32.is_lt(c, 2404), c)

def gb.n99(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n100(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n101(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n99(U32.is_lt(c, 2482), c)
    case False{}:
      gb.n100(U32.is_lt(c, 2486), c)

def gb.n102(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n103(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n104(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n102(U32.is_lt(c, 2492), c)
    case False{}:
      gb.n103(U32.is_lt(c, 2494), c)

def gb.n105(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n101(U32.is_lt(c, 2483), c)
    case False{}:
      gb.n104(U32.is_lt(c, 2493), c)

def gb.n106(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n107(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n108(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n106(U32.is_lt(c, 2497), c)
    case False{}:
      gb.n107(U32.is_lt(c, 2503), c)

def gb.n109(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n110(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n111(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      gb.n110(U32.is_lt(c, 2519), c)

def gb.n112(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n109(U32.is_lt(c, 2507), c)
    case False{}:
      gb.n111(U32.is_lt(c, 2510), c)

def gb.n113(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n108(U32.is_lt(c, 2501), c)
    case False{}:
      gb.n112(U32.is_lt(c, 2509), c)

def gb.n114(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n105(U32.is_lt(c, 2490), c)
    case False{}:
      gb.n113(U32.is_lt(c, 2505), c)

def gb.n115(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n116(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n117(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n115(U32.is_lt(c, 2524), c)
    case False{}:
      gb.n116(U32.is_lt(c, 2527), c)

def gb.n118(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n119(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n120(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n118(U32.is_lt(c, 2530), c)
    case False{}:
      gb.n119(U32.is_lt(c, 2544), c)

def gb.n121(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n117(U32.is_lt(c, 2526), c)
    case False{}:
      gb.n120(U32.is_lt(c, 2532), c)

def gb.n122(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n123(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n124(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n122(U32.is_lt(c, 2558), c)
    case False{}:
      gb.n123(U32.is_lt(c, 2561), c)

def gb.n125(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n126(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n127(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n126(U32.is_lt(c, 2622), c)

def gb.n128(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n125(U32.is_lt(c, 2564), c)
    case False{}:
      gb.n127(U32.is_lt(c, 2621), c)

def gb.n129(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n124(U32.is_lt(c, 2559), c)
    case False{}:
      gb.n128(U32.is_lt(c, 2620), c)

def gb.n130(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n121(U32.is_lt(c, 2528), c)
    case False{}:
      gb.n129(U32.is_lt(c, 2563), c)

def gb.n131(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n114(U32.is_lt(c, 2495), c)
    case False{}:
      gb.n130(U32.is_lt(c, 2546), c)

def gb.n132(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n98(U32.is_lt(c, 2377), c)
    case False{}:
      gb.n131(U32.is_lt(c, 2520), c)

def gb.n133(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n65(U32.is_lt(c, 1611), c)
    case False{}:
      gb.n132(U32.is_lt(c, 2481), c)

def gb.n134(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n135(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n136(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n134(U32.is_lt(c, 2627), c)
    case False{}:
      gb.n135(U32.is_lt(c, 2633), c)

def gb.n137(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n138(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n139(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n137(U32.is_lt(c, 2638), c)
    case False{}:
      gb.n138(U32.is_lt(c, 2642), c)

def gb.n140(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n136(U32.is_lt(c, 2631), c)
    case False{}:
      gb.n139(U32.is_lt(c, 2641), c)

def gb.n141(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n142(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n143(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n141(U32.is_lt(c, 2674), c)
    case False{}:
      gb.n142(U32.is_lt(c, 2678), c)

def gb.n144(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n145(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n146(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n145(U32.is_lt(c, 2729), c)

def gb.n147(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n144(U32.is_lt(c, 2691), c)
    case False{}:
      gb.n146(U32.is_lt(c, 2709), c)

def gb.n148(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n143(U32.is_lt(c, 2677), c)
    case False{}:
      gb.n147(U32.is_lt(c, 2692), c)

def gb.n149(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n140(U32.is_lt(c, 2635), c)
    case False{}:
      gb.n148(U32.is_lt(c, 2689), c)

def gb.n150(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n151(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n152(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n150(U32.is_lt(c, 2737), c)
    case False{}:
      gb.n151(U32.is_lt(c, 2740), c)

def gb.n153(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n154(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n155(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n153(U32.is_lt(c, 2746), c)
    case False{}:
      gb.n154(U32.is_lt(c, 2749), c)

def gb.n156(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n152(U32.is_lt(c, 2738), c)
    case False{}:
      gb.n155(U32.is_lt(c, 2748), c)

def gb.n157(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n158(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n159(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n157(U32.is_lt(c, 2753), c)
    case False{}:
      gb.n158(U32.is_lt(c, 2759), c)

def gb.n160(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n161(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      0

def gb.n162(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      gb.n161(U32.is_lt(c, 2766), c)

def gb.n163(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n160(U32.is_lt(c, 2762), c)
    case False{}:
      gb.n162(U32.is_lt(c, 2765), c)

def gb.n164(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n159(U32.is_lt(c, 2758), c)
    case False{}:
      gb.n163(U32.is_lt(c, 2763), c)

def gb.n165(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n156(U32.is_lt(c, 2741), c)
    case False{}:
      gb.n164(U32.is_lt(c, 2761), c)

def gb.n166(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n149(U32.is_lt(c, 2672), c)
    case False{}:
      gb.n165(U32.is_lt(c, 2750), c)

def gb.n167(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n168(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      68

def gb.n169(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n167(U32.is_lt(c, 2788), c)
    case False{}:
      gb.n168(U32.is_lt(c, 2810), c)

def gb.n170(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n171(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n172(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n170(U32.is_lt(c, 2817), c)
    case False{}:
      gb.n171(U32.is_lt(c, 2820), c)

def gb.n173(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n169(U32.is_lt(c, 2809), c)
    case False{}:
      gb.n172(U32.is_lt(c, 2818), c)

def gb.n174(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n175(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n176(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n174(U32.is_lt(c, 2857), c)
    case False{}:
      gb.n175(U32.is_lt(c, 2865), c)

def gb.n177(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n178(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n179(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n178(U32.is_lt(c, 2876), c)

def gb.n180(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n177(U32.is_lt(c, 2868), c)
    case False{}:
      gb.n179(U32.is_lt(c, 2874), c)

def gb.n181(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n176(U32.is_lt(c, 2858), c)
    case False{}:
      gb.n180(U32.is_lt(c, 2869), c)

def gb.n182(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n173(U32.is_lt(c, 2816), c)
    case False{}:
      gb.n181(U32.is_lt(c, 2866), c)

def gb.n183(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n184(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n185(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n183(U32.is_lt(c, 2878), c)
    case False{}:
      gb.n184(U32.is_lt(c, 2881), c)

def gb.n186(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n187(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n188(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n186(U32.is_lt(c, 2887), c)
    case False{}:
      gb.n187(U32.is_lt(c, 2891), c)

def gb.n189(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n185(U32.is_lt(c, 2880), c)
    case False{}:
      gb.n188(U32.is_lt(c, 2889), c)

def gb.n190(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      0

def gb.n191(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n192(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n190(U32.is_lt(c, 2894), c)
    case False{}:
      gb.n191(U32.is_lt(c, 2904), c)

def gb.n193(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n194(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n195(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n194(U32.is_lt(c, 2914), c)

def gb.n196(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n193(U32.is_lt(c, 2910), c)
    case False{}:
      gb.n195(U32.is_lt(c, 2912), c)

def gb.n197(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n192(U32.is_lt(c, 2901), c)
    case False{}:
      gb.n196(U32.is_lt(c, 2911), c)

def gb.n198(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n189(U32.is_lt(c, 2885), c)
    case False{}:
      gb.n197(U32.is_lt(c, 2908), c)

def gb.n199(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n182(U32.is_lt(c, 2837), c)
    case False{}:
      gb.n198(U32.is_lt(c, 2893), c)

def gb.n200(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n166(U32.is_lt(c, 2730), c)
    case False{}:
      gb.n199(U32.is_lt(c, 2877), c)

def gb.n201(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n202(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n203(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n201(U32.is_lt(c, 2929), c)
    case False{}:
      gb.n202(U32.is_lt(c, 2946), c)

def gb.n204(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n205(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n206(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n204(U32.is_lt(c, 3006), c)
    case False{}:
      gb.n205(U32.is_lt(c, 3008), c)

def gb.n207(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n203(U32.is_lt(c, 2930), c)
    case False{}:
      gb.n206(U32.is_lt(c, 3007), c)

def gb.n208(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n209(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n210(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n208(U32.is_lt(c, 3011), c)
    case False{}:
      gb.n209(U32.is_lt(c, 3017), c)

def gb.n211(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n212(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n213(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n212(U32.is_lt(c, 3032), c)

def gb.n214(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n211(U32.is_lt(c, 3021), c)
    case False{}:
      gb.n213(U32.is_lt(c, 3031), c)

def gb.n215(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n210(U32.is_lt(c, 3014), c)
    case False{}:
      gb.n214(U32.is_lt(c, 3022), c)

def gb.n216(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n207(U32.is_lt(c, 2947), c)
    case False{}:
      gb.n215(U32.is_lt(c, 3018), c)

def gb.n217(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n218(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n219(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n217(U32.is_lt(c, 3073), c)
    case False{}:
      gb.n218(U32.is_lt(c, 3077), c)

def gb.n220(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n221(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n222(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n220(U32.is_lt(c, 3113), c)
    case False{}:
      gb.n221(U32.is_lt(c, 3130), c)

def gb.n223(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n219(U32.is_lt(c, 3076), c)
    case False{}:
      gb.n222(U32.is_lt(c, 3114), c)

def gb.n224(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n225(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n226(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n224(U32.is_lt(c, 3133), c)
    case False{}:
      gb.n225(U32.is_lt(c, 3137), c)

def gb.n227(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n228(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      100

def gb.n229(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n228(U32.is_lt(c, 3149), c)

def gb.n230(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n227(U32.is_lt(c, 3142), c)
    case False{}:
      gb.n229(U32.is_lt(c, 3146), c)

def gb.n231(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n226(U32.is_lt(c, 3134), c)
    case False{}:
      gb.n230(U32.is_lt(c, 3145), c)

def gb.n232(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n223(U32.is_lt(c, 3093), c)
    case False{}:
      gb.n231(U32.is_lt(c, 3141), c)

def gb.n233(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n216(U32.is_lt(c, 3009), c)
    case False{}:
      gb.n232(U32.is_lt(c, 3132), c)

def gb.n234(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n235(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n236(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n234(U32.is_lt(c, 3157), c)
    case False{}:
      gb.n235(U32.is_lt(c, 3160), c)

def gb.n237(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n238(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n239(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n237(U32.is_lt(c, 3170), c)
    case False{}:
      gb.n238(U32.is_lt(c, 3201), c)

def gb.n240(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n236(U32.is_lt(c, 3159), c)
    case False{}:
      gb.n239(U32.is_lt(c, 3172), c)

def gb.n241(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n242(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n243(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n241(U32.is_lt(c, 3204), c)
    case False{}:
      gb.n242(U32.is_lt(c, 3261), c)

def gb.n244(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n245(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n246(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      gb.n245(U32.is_lt(c, 3267), c)

def gb.n247(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n244(U32.is_lt(c, 3263), c)
    case False{}:
      gb.n246(U32.is_lt(c, 3266), c)

def gb.n248(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n243(U32.is_lt(c, 3260), c)
    case False{}:
      gb.n247(U32.is_lt(c, 3265), c)

def gb.n249(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n240(U32.is_lt(c, 3163), c)
    case False{}:
      gb.n248(U32.is_lt(c, 3262), c)

def gb.n250(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n251(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n252(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n250(U32.is_lt(c, 3270), c)
    case False{}:
      gb.n251(U32.is_lt(c, 3274), c)

def gb.n253(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n254(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n255(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n253(U32.is_lt(c, 3285), c)
    case False{}:
      gb.n254(U32.is_lt(c, 3298), c)

def gb.n256(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n252(U32.is_lt(c, 3273), c)
    case False{}:
      gb.n255(U32.is_lt(c, 3287), c)

def gb.n257(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n258(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n259(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n257(U32.is_lt(c, 3315), c)
    case False{}:
      gb.n258(U32.is_lt(c, 3328), c)

def gb.n260(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n261(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n262(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n261(U32.is_lt(c, 3389), c)

def gb.n263(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n260(U32.is_lt(c, 3332), c)
    case False{}:
      gb.n262(U32.is_lt(c, 3387), c)

def gb.n264(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n259(U32.is_lt(c, 3316), c)
    case False{}:
      gb.n263(U32.is_lt(c, 3349), c)

def gb.n265(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n256(U32.is_lt(c, 3278), c)
    case False{}:
      gb.n264(U32.is_lt(c, 3330), c)

def gb.n266(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n249(U32.is_lt(c, 3202), c)
    case False{}:
      gb.n265(U32.is_lt(c, 3300), c)

def gb.n267(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n233(U32.is_lt(c, 3072), c)
    case False{}:
      gb.n266(U32.is_lt(c, 3269), c)

def gb.n268(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n200(U32.is_lt(c, 2786), c)
    case False{}:
      gb.n267(U32.is_lt(c, 3150), c)

def gb.n269(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n133(U32.is_lt(c, 2140), c)
    case False{}:
      gb.n268(U32.is_lt(c, 2916), c)

def gb.n270(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n271(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n272(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n270(U32.is_lt(c, 3391), c)
    case False{}:
      gb.n271(U32.is_lt(c, 3397), c)

def gb.n273(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n274(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      100

def gb.n275(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n273(U32.is_lt(c, 3401), c)
    case False{}:
      gb.n274(U32.is_lt(c, 3405), c)

def gb.n276(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n272(U32.is_lt(c, 3393), c)
    case False{}:
      gb.n275(U32.is_lt(c, 3402), c)

def gb.n277(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      0

def gb.n278(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n279(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n277(U32.is_lt(c, 3407), c)
    case False{}:
      gb.n278(U32.is_lt(c, 3416), c)

def gb.n280(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n281(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n282(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n280(U32.is_lt(c, 3428), c)
    case False{}:
      gb.n281(U32.is_lt(c, 3458), c)

def gb.n283(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n279(U32.is_lt(c, 3415), c)
    case False{}:
      gb.n282(U32.is_lt(c, 3457), c)

def gb.n284(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n276(U32.is_lt(c, 3398), c)
    case False{}:
      gb.n283(U32.is_lt(c, 3426), c)

def gb.n285(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n286(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n287(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n285(U32.is_lt(c, 3530), c)
    case False{}:
      gb.n286(U32.is_lt(c, 3535), c)

def gb.n288(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n289(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n290(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n288(U32.is_lt(c, 3538), c)
    case False{}:
      gb.n289(U32.is_lt(c, 3542), c)

def gb.n291(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n287(U32.is_lt(c, 3531), c)
    case False{}:
      gb.n290(U32.is_lt(c, 3541), c)

def gb.n292(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n293(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n294(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n292(U32.is_lt(c, 3544), c)
    case False{}:
      gb.n293(U32.is_lt(c, 3552), c)

def gb.n295(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n296(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n297(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n296(U32.is_lt(c, 3635), c)

def gb.n298(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n295(U32.is_lt(c, 3572), c)
    case False{}:
      gb.n297(U32.is_lt(c, 3634), c)

def gb.n299(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n294(U32.is_lt(c, 3551), c)
    case False{}:
      gb.n298(U32.is_lt(c, 3633), c)

def gb.n300(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n291(U32.is_lt(c, 3536), c)
    case False{}:
      gb.n299(U32.is_lt(c, 3570), c)

def gb.n301(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n284(U32.is_lt(c, 3406), c)
    case False{}:
      gb.n300(U32.is_lt(c, 3543), c)

def gb.n302(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n303(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n304(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n302(U32.is_lt(c, 3643), c)
    case False{}:
      gb.n303(U32.is_lt(c, 3663), c)

def gb.n305(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n306(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n307(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n305(U32.is_lt(c, 3762), c)
    case False{}:
      gb.n306(U32.is_lt(c, 3764), c)

def gb.n308(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n304(U32.is_lt(c, 3655), c)
    case False{}:
      gb.n307(U32.is_lt(c, 3763), c)

def gb.n309(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n310(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n311(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n309(U32.is_lt(c, 3784), c)
    case False{}:
      gb.n310(U32.is_lt(c, 3864), c)

def gb.n312(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n313(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n314(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n313(U32.is_lt(c, 3896), c)

def gb.n315(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n312(U32.is_lt(c, 3893), c)
    case False{}:
      gb.n314(U32.is_lt(c, 3895), c)

def gb.n316(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n311(U32.is_lt(c, 3791), c)
    case False{}:
      gb.n315(U32.is_lt(c, 3894), c)

def gb.n317(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n308(U32.is_lt(c, 3761), c)
    case False{}:
      gb.n316(U32.is_lt(c, 3866), c)

def gb.n318(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n319(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n320(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n318(U32.is_lt(c, 3898), c)
    case False{}:
      gb.n319(U32.is_lt(c, 3904), c)

def gb.n321(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n322(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n323(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n321(U32.is_lt(c, 3967), c)
    case False{}:
      gb.n322(U32.is_lt(c, 3973), c)

def gb.n324(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n320(U32.is_lt(c, 3902), c)
    case False{}:
      gb.n323(U32.is_lt(c, 3968), c)

def gb.n325(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n326(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n327(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n325(U32.is_lt(c, 3976), c)
    case False{}:
      gb.n326(U32.is_lt(c, 3992), c)

def gb.n328(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n329(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n330(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n329(U32.is_lt(c, 4096), c)

def gb.n331(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n328(U32.is_lt(c, 4029), c)
    case False{}:
      gb.n330(U32.is_lt(c, 4039), c)

def gb.n332(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n327(U32.is_lt(c, 3981), c)
    case False{}:
      gb.n331(U32.is_lt(c, 4038), c)

def gb.n333(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n324(U32.is_lt(c, 3953), c)
    case False{}:
      gb.n332(U32.is_lt(c, 3993), c)

def gb.n334(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n317(U32.is_lt(c, 3773), c)
    case False{}:
      gb.n333(U32.is_lt(c, 3974), c)

def gb.n335(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n301(U32.is_lt(c, 3460), c)
    case False{}:
      gb.n334(U32.is_lt(c, 3897), c)

def gb.n336(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n337(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n338(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n336(U32.is_lt(c, 4141), c)
    case False{}:
      gb.n337(U32.is_lt(c, 4146), c)

def gb.n339(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      100

def gb.n340(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n341(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n339(U32.is_lt(c, 4153), c)
    case False{}:
      gb.n340(U32.is_lt(c, 4155), c)

def gb.n342(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n338(U32.is_lt(c, 4145), c)
    case False{}:
      gb.n341(U32.is_lt(c, 4154), c)

def gb.n343(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n344(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n345(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n343(U32.is_lt(c, 4159), c)
    case False{}:
      gb.n344(U32.is_lt(c, 4176), c)

def gb.n346(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n347(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n348(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n347(U32.is_lt(c, 4193), c)

def gb.n349(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n346(U32.is_lt(c, 4184), c)
    case False{}:
      gb.n348(U32.is_lt(c, 4190), c)

def gb.n350(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n345(U32.is_lt(c, 4160), c)
    case False{}:
      gb.n349(U32.is_lt(c, 4186), c)

def gb.n351(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n342(U32.is_lt(c, 4152), c)
    case False{}:
      gb.n350(U32.is_lt(c, 4182), c)

def gb.n352(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n353(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n354(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n352(U32.is_lt(c, 4197), c)
    case False{}:
      gb.n353(U32.is_lt(c, 4206), c)

def gb.n355(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n356(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n357(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n355(U32.is_lt(c, 4213), c)
    case False{}:
      gb.n356(U32.is_lt(c, 4227), c)

def gb.n358(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n354(U32.is_lt(c, 4199), c)
    case False{}:
      gb.n357(U32.is_lt(c, 4226), c)

def gb.n359(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n360(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n361(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n359(U32.is_lt(c, 4229), c)
    case False{}:
      gb.n360(U32.is_lt(c, 4237), c)

def gb.n362(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n363(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def gb.n364(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n363(U32.is_lt(c, 4352), c)

def gb.n365(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n362(U32.is_lt(c, 4239), c)
    case False{}:
      gb.n364(U32.is_lt(c, 4254), c)

def gb.n366(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n361(U32.is_lt(c, 4231), c)
    case False{}:
      gb.n365(U32.is_lt(c, 4253), c)

def gb.n367(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n358(U32.is_lt(c, 4209), c)
    case False{}:
      gb.n366(U32.is_lt(c, 4238), c)

def gb.n368(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n351(U32.is_lt(c, 4157), c)
    case False{}:
      gb.n367(U32.is_lt(c, 4228), c)

def gb.n369(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      10
    case False{}:
      11

def gb.n370(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n371(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n369(U32.is_lt(c, 4520), c)
    case False{}:
      gb.n370(U32.is_lt(c, 4957), c)

def gb.n372(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n373(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n374(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n372(U32.is_lt(c, 5906), c)
    case False{}:
      gb.n373(U32.is_lt(c, 5938), c)

def gb.n375(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n371(U32.is_lt(c, 4608), c)
    case False{}:
      gb.n374(U32.is_lt(c, 5910), c)

def gb.n376(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n377(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n378(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n376(U32.is_lt(c, 5970), c)
    case False{}:
      gb.n377(U32.is_lt(c, 6002), c)

def gb.n379(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n380(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n381(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n380(U32.is_lt(c, 6071), c)

def gb.n382(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n379(U32.is_lt(c, 6016), c)
    case False{}:
      gb.n381(U32.is_lt(c, 6070), c)

def gb.n383(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n378(U32.is_lt(c, 5972), c)
    case False{}:
      gb.n382(U32.is_lt(c, 6068), c)

def gb.n384(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n375(U32.is_lt(c, 4960), c)
    case False{}:
      gb.n383(U32.is_lt(c, 6004), c)

def gb.n385(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n386(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n387(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n385(U32.is_lt(c, 6086), c)
    case False{}:
      gb.n386(U32.is_lt(c, 6089), c)

def gb.n388(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      68

def gb.n389(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n390(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n388(U32.is_lt(c, 6099), c)
    case False{}:
      gb.n389(U32.is_lt(c, 6109), c)

def gb.n391(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n387(U32.is_lt(c, 6087), c)
    case False{}:
      gb.n390(U32.is_lt(c, 6100), c)

def gb.n392(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n393(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      68

def gb.n394(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n392(U32.is_lt(c, 6155), c)
    case False{}:
      gb.n393(U32.is_lt(c, 6159), c)

def gb.n395(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n396(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n397(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n396(U32.is_lt(c, 6314), c)

def gb.n398(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n395(U32.is_lt(c, 6277), c)
    case False{}:
      gb.n397(U32.is_lt(c, 6313), c)

def gb.n399(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n394(U32.is_lt(c, 6158), c)
    case False{}:
      gb.n398(U32.is_lt(c, 6279), c)

def gb.n400(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n391(U32.is_lt(c, 6098), c)
    case False{}:
      gb.n399(U32.is_lt(c, 6160), c)

def gb.n401(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n384(U32.is_lt(c, 5941), c)
    case False{}:
      gb.n400(U32.is_lt(c, 6110), c)

def gb.n402(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n368(U32.is_lt(c, 4194), c)
    case False{}:
      gb.n401(U32.is_lt(c, 6078), c)

def gb.n403(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n335(U32.is_lt(c, 3636), c)
    case False{}:
      gb.n402(U32.is_lt(c, 4448), c)

def gb.n404(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n405(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n406(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n404(U32.is_lt(c, 6435), c)
    case False{}:
      gb.n405(U32.is_lt(c, 6441), c)

def gb.n407(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n408(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n409(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n407(U32.is_lt(c, 6448), c)
    case False{}:
      gb.n408(U32.is_lt(c, 6451), c)

def gb.n410(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n406(U32.is_lt(c, 6439), c)
    case False{}:
      gb.n409(U32.is_lt(c, 6450), c)

def gb.n411(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n412(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n413(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n411(U32.is_lt(c, 6460), c)
    case False{}:
      gb.n412(U32.is_lt(c, 6681), c)

def gb.n414(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n415(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n416(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n415(U32.is_lt(c, 6742), c)

def gb.n417(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n414(U32.is_lt(c, 6684), c)
    case False{}:
      gb.n416(U32.is_lt(c, 6741), c)

def gb.n418(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n413(U32.is_lt(c, 6679), c)
    case False{}:
      gb.n417(U32.is_lt(c, 6688), c)

def gb.n419(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n410(U32.is_lt(c, 6444), c)
    case False{}:
      gb.n418(U32.is_lt(c, 6683), c)

def gb.n420(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n421(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      100

def gb.n422(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n420(U32.is_lt(c, 6744), c)
    case False{}:
      gb.n421(U32.is_lt(c, 6752), c)

def gb.n423(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n424(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n425(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n423(U32.is_lt(c, 6754), c)
    case False{}:
      gb.n424(U32.is_lt(c, 6757), c)

def gb.n426(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n422(U32.is_lt(c, 6751), c)
    case False{}:
      gb.n425(U32.is_lt(c, 6755), c)

def gb.n427(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n428(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n429(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n427(U32.is_lt(c, 6771), c)
    case False{}:
      gb.n428(U32.is_lt(c, 6783), c)

def gb.n430(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n431(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n432(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n431(U32.is_lt(c, 6892), c)

def gb.n433(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n430(U32.is_lt(c, 6832), c)
    case False{}:
      gb.n432(U32.is_lt(c, 6880), c)

def gb.n434(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n429(U32.is_lt(c, 6781), c)
    case False{}:
      gb.n433(U32.is_lt(c, 6878), c)

def gb.n435(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n426(U32.is_lt(c, 6753), c)
    case False{}:
      gb.n434(U32.is_lt(c, 6784), c)

def gb.n436(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n419(U32.is_lt(c, 6457), c)
    case False{}:
      gb.n435(U32.is_lt(c, 6765), c)

def gb.n437(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n438(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n439(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n437(U32.is_lt(c, 6916), c)
    case False{}:
      gb.n438(U32.is_lt(c, 6923), c)

def gb.n440(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n441(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n442(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n440(U32.is_lt(c, 6931), c)
    case False{}:
      gb.n441(U32.is_lt(c, 6974), c)

def gb.n443(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n439(U32.is_lt(c, 6917), c)
    case False{}:
      gb.n442(U32.is_lt(c, 6964), c)

def gb.n444(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      100

def gb.n445(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n446(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n444(U32.is_lt(c, 6980), c)
    case False{}:
      gb.n445(U32.is_lt(c, 6989), c)

def gb.n447(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n448(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      32

def gb.n449(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n448(U32.is_lt(c, 7043), c)

def gb.n450(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n447(U32.is_lt(c, 7028), c)
    case False{}:
      gb.n449(U32.is_lt(c, 7042), c)

def gb.n451(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n446(U32.is_lt(c, 6981), c)
    case False{}:
      gb.n450(U32.is_lt(c, 7040), c)

def gb.n452(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n443(U32.is_lt(c, 6925), c)
    case False{}:
      gb.n451(U32.is_lt(c, 7019), c)

def gb.n453(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n454(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n455(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n453(U32.is_lt(c, 7074), c)
    case False{}:
      gb.n454(U32.is_lt(c, 7080), c)

def gb.n456(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      68

def gb.n457(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n458(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n456(U32.is_lt(c, 7084), c)
    case False{}:
      gb.n457(U32.is_lt(c, 7088), c)

def gb.n459(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n455(U32.is_lt(c, 7078), c)
    case False{}:
      gb.n458(U32.is_lt(c, 7086), c)

def gb.n460(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n461(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n462(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n460(U32.is_lt(c, 7102), c)
    case False{}:
      gb.n461(U32.is_lt(c, 7143), c)

def gb.n463(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n464(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n465(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n464(U32.is_lt(c, 7151), c)

def gb.n466(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n463(U32.is_lt(c, 7146), c)
    case False{}:
      gb.n465(U32.is_lt(c, 7150), c)

def gb.n467(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n462(U32.is_lt(c, 7142), c)
    case False{}:
      gb.n466(U32.is_lt(c, 7149), c)

def gb.n468(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n459(U32.is_lt(c, 7083), c)
    case False{}:
      gb.n467(U32.is_lt(c, 7144), c)

def gb.n469(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n452(U32.is_lt(c, 6978), c)
    case False{}:
      gb.n468(U32.is_lt(c, 7099), c)

def gb.n470(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n436(U32.is_lt(c, 6743), c)
    case False{}:
      gb.n469(U32.is_lt(c, 7073), c)

def gb.n471(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n472(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n473(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n471(U32.is_lt(c, 7204), c)
    case False{}:
      gb.n472(U32.is_lt(c, 7220), c)

def gb.n474(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n475(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n476(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n474(U32.is_lt(c, 7224), c)
    case False{}:
      gb.n475(U32.is_lt(c, 7379), c)

def gb.n477(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n473(U32.is_lt(c, 7212), c)
    case False{}:
      gb.n476(U32.is_lt(c, 7376), c)

def gb.n478(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n479(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n480(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n478(U32.is_lt(c, 7393), c)
    case False{}:
      gb.n479(U32.is_lt(c, 7401), c)

def gb.n481(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n482(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n483(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n482(U32.is_lt(c, 7415), c)

def gb.n484(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n481(U32.is_lt(c, 7406), c)
    case False{}:
      gb.n483(U32.is_lt(c, 7413), c)

def gb.n485(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n480(U32.is_lt(c, 7394), c)
    case False{}:
      gb.n484(U32.is_lt(c, 7412), c)

def gb.n486(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n477(U32.is_lt(c, 7222), c)
    case False{}:
      gb.n485(U32.is_lt(c, 7405), c)

def gb.n487(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n488(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n489(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n487(U32.is_lt(c, 7418), c)
    case False{}:
      gb.n488(U32.is_lt(c, 7680), c)

def gb.n490(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      4

def gb.n491(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      69
    case False{}:
      3

def gb.n492(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n490(U32.is_lt(c, 8204), c)
    case False{}:
      gb.n491(U32.is_lt(c, 8206), c)

def gb.n493(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n489(U32.is_lt(c, 7616), c)
    case False{}:
      gb.n492(U32.is_lt(c, 8205), c)

def gb.n494(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      3

def gb.n495(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n496(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n494(U32.is_lt(c, 8232), c)
    case False{}:
      gb.n495(U32.is_lt(c, 8252), c)

def gb.n497(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n498(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n499(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n498(U32.is_lt(c, 8304), c)

def gb.n500(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n497(U32.is_lt(c, 8265), c)
    case False{}:
      gb.n499(U32.is_lt(c, 8288), c)

def gb.n501(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n496(U32.is_lt(c, 8239), c)
    case False{}:
      gb.n500(U32.is_lt(c, 8266), c)

def gb.n502(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n493(U32.is_lt(c, 8203), c)
    case False{}:
      gb.n501(U32.is_lt(c, 8253), c)

def gb.n503(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n486(U32.is_lt(c, 7380), c)
    case False{}:
      gb.n502(U32.is_lt(c, 8208), c)

def gb.n504(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n505(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n506(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n504(U32.is_lt(c, 8433), c)
    case False{}:
      gb.n505(U32.is_lt(c, 8483), c)

def gb.n507(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n508(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n509(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n507(U32.is_lt(c, 8506), c)
    case False{}:
      gb.n508(U32.is_lt(c, 8602), c)

def gb.n510(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n506(U32.is_lt(c, 8482), c)
    case False{}:
      gb.n509(U32.is_lt(c, 8596), c)

def gb.n511(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n512(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n513(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n511(U32.is_lt(c, 8619), c)
    case False{}:
      gb.n512(U32.is_lt(c, 8988), c)

def gb.n514(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n515(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n516(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n515(U32.is_lt(c, 9193), c)

def gb.n517(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n514(U32.is_lt(c, 9001), c)
    case False{}:
      gb.n516(U32.is_lt(c, 9168), c)

def gb.n518(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n513(U32.is_lt(c, 8986), c)
    case False{}:
      gb.n517(U32.is_lt(c, 9167), c)

def gb.n519(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n510(U32.is_lt(c, 8505), c)
    case False{}:
      gb.n518(U32.is_lt(c, 9000), c)

def gb.n520(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n521(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n522(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n520(U32.is_lt(c, 9208), c)
    case False{}:
      gb.n521(U32.is_lt(c, 9410), c)

def gb.n523(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n524(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n525(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n523(U32.is_lt(c, 9642), c)
    case False{}:
      gb.n524(U32.is_lt(c, 9654), c)

def gb.n526(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n522(U32.is_lt(c, 9211), c)
    case False{}:
      gb.n525(U32.is_lt(c, 9644), c)

def gb.n527(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n528(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n529(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n527(U32.is_lt(c, 9664), c)
    case False{}:
      gb.n528(U32.is_lt(c, 9723), c)

def gb.n530(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n531(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n532(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n531(U32.is_lt(c, 9743), c)

def gb.n533(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n530(U32.is_lt(c, 9728), c)
    case False{}:
      gb.n532(U32.is_lt(c, 9742), c)

def gb.n534(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n529(U32.is_lt(c, 9665), c)
    case False{}:
      gb.n533(U32.is_lt(c, 9733), c)

def gb.n535(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n526(U32.is_lt(c, 9411), c)
    case False{}:
      gb.n534(U32.is_lt(c, 9727), c)

def gb.n536(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n519(U32.is_lt(c, 8617), c)
    case False{}:
      gb.n535(U32.is_lt(c, 9655), c)

def gb.n537(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n503(U32.is_lt(c, 7416), c)
    case False{}:
      gb.n536(U32.is_lt(c, 9204), c)

def gb.n538(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n470(U32.is_lt(c, 6912), c)
    case False{}:
      gb.n537(U32.is_lt(c, 8400), c)

def gb.n539(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n403(U32.is_lt(c, 4139), c)
    case False{}:
      gb.n538(U32.is_lt(c, 7156), c)

def gb.n540(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n269(U32.is_lt(c, 2625), c)
    case False{}:
      gb.n539(U32.is_lt(c, 6432), c)

def gb.n541(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n542(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n543(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n541(U32.is_lt(c, 9746), c)
    case False{}:
      gb.n542(U32.is_lt(c, 9750), c)

def gb.n544(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n545(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n546(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n544(U32.is_lt(c, 9753), c)
    case False{}:
      gb.n545(U32.is_lt(c, 9758), c)

def gb.n547(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n543(U32.is_lt(c, 9748), c)
    case False{}:
      gb.n546(U32.is_lt(c, 9757), c)

def gb.n548(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n549(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n550(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n548(U32.is_lt(c, 9761), c)
    case False{}:
      gb.n549(U32.is_lt(c, 9764), c)

def gb.n551(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n552(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n553(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n551(U32.is_lt(c, 9767), c)
    case False{}:
      gb.n552(U32.is_lt(c, 9771), c)

def gb.n554(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n550(U32.is_lt(c, 9762), c)
    case False{}:
      gb.n553(U32.is_lt(c, 9770), c)

def gb.n555(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n547(U32.is_lt(c, 9752), c)
    case False{}:
      gb.n554(U32.is_lt(c, 9766), c)

def gb.n556(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n557(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n558(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n556(U32.is_lt(c, 9776), c)
    case False{}:
      gb.n557(U32.is_lt(c, 9787), c)

def gb.n559(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n560(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n561(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n559(U32.is_lt(c, 9793), c)
    case False{}:
      gb.n560(U32.is_lt(c, 9795), c)

def gb.n562(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n558(U32.is_lt(c, 9784), c)
    case False{}:
      gb.n561(U32.is_lt(c, 9794), c)

def gb.n563(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n564(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n565(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n563(U32.is_lt(c, 9812), c)
    case False{}:
      gb.n564(U32.is_lt(c, 9825), c)

def gb.n566(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n567(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n568(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n567(U32.is_lt(c, 9832), c)

def gb.n569(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n566(U32.is_lt(c, 9828), c)
    case False{}:
      gb.n568(U32.is_lt(c, 9831), c)

def gb.n570(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n565(U32.is_lt(c, 9823), c)
    case False{}:
      gb.n569(U32.is_lt(c, 9829), c)

def gb.n571(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n562(U32.is_lt(c, 9792), c)
    case False{}:
      gb.n570(U32.is_lt(c, 9827), c)

def gb.n572(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n555(U32.is_lt(c, 9760), c)
    case False{}:
      gb.n571(U32.is_lt(c, 9800), c)

def gb.n573(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n574(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n575(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n573(U32.is_lt(c, 9851), c)
    case False{}:
      gb.n574(U32.is_lt(c, 9854), c)

def gb.n576(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n577(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n578(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n576(U32.is_lt(c, 9874), c)
    case False{}:
      gb.n577(U32.is_lt(c, 9881), c)

def gb.n579(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n575(U32.is_lt(c, 9852), c)
    case False{}:
      gb.n578(U32.is_lt(c, 9880), c)

def gb.n580(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n581(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n582(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n580(U32.is_lt(c, 9883), c)
    case False{}:
      gb.n581(U32.is_lt(c, 9888), c)

def gb.n583(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n584(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n585(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n584(U32.is_lt(c, 9900), c)

def gb.n586(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n583(U32.is_lt(c, 9895), c)
    case False{}:
      gb.n585(U32.is_lt(c, 9898), c)

def gb.n587(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n582(U32.is_lt(c, 9885), c)
    case False{}:
      gb.n586(U32.is_lt(c, 9896), c)

def gb.n588(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n579(U32.is_lt(c, 9856), c)
    case False{}:
      gb.n587(U32.is_lt(c, 9890), c)

def gb.n589(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n590(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n591(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n589(U32.is_lt(c, 9906), c)
    case False{}:
      gb.n590(U32.is_lt(c, 9919), c)

def gb.n592(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n593(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n594(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n592(U32.is_lt(c, 9926), c)
    case False{}:
      gb.n593(U32.is_lt(c, 9929), c)

def gb.n595(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n591(U32.is_lt(c, 9917), c)
    case False{}:
      gb.n594(U32.is_lt(c, 9928), c)

def gb.n596(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n597(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n598(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n596(U32.is_lt(c, 9936), c)
    case False{}:
      gb.n597(U32.is_lt(c, 9938), c)

def gb.n599(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n600(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n601(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n600(U32.is_lt(c, 9968), c)

def gb.n602(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n599(U32.is_lt(c, 9941), c)
    case False{}:
      gb.n601(U32.is_lt(c, 9963), c)

def gb.n603(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n598(U32.is_lt(c, 9937), c)
    case False{}:
      gb.n602(U32.is_lt(c, 9961), c)

def gb.n604(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n595(U32.is_lt(c, 9924), c)
    case False{}:
      gb.n603(U32.is_lt(c, 9939), c)

def gb.n605(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n588(U32.is_lt(c, 9882), c)
    case False{}:
      gb.n604(U32.is_lt(c, 9934), c)

def gb.n606(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n572(U32.is_lt(c, 9774), c)
    case False{}:
      gb.n605(U32.is_lt(c, 9904), c)

def gb.n607(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n608(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n609(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n607(U32.is_lt(c, 9975), c)
    case False{}:
      gb.n608(U32.is_lt(c, 9981), c)

def gb.n610(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n611(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n612(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n610(U32.is_lt(c, 9986), c)
    case False{}:
      gb.n611(U32.is_lt(c, 9989), c)

def gb.n613(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n609(U32.is_lt(c, 9979), c)
    case False{}:
      gb.n612(U32.is_lt(c, 9987), c)

def gb.n614(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n615(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n616(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n614(U32.is_lt(c, 9992), c)
    case False{}:
      gb.n615(U32.is_lt(c, 9999), c)

def gb.n617(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n618(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n619(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n618(U32.is_lt(c, 10005), c)

def gb.n620(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n617(U32.is_lt(c, 10002), c)
    case False{}:
      gb.n619(U32.is_lt(c, 10004), c)

def gb.n621(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n616(U32.is_lt(c, 9998), c)
    case False{}:
      gb.n620(U32.is_lt(c, 10003), c)

def gb.n622(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n613(U32.is_lt(c, 9982), c)
    case False{}:
      gb.n621(U32.is_lt(c, 10000), c)

def gb.n623(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n624(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n625(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n623(U32.is_lt(c, 10007), c)
    case False{}:
      gb.n624(U32.is_lt(c, 10014), c)

def gb.n626(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n627(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n628(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n626(U32.is_lt(c, 10018), c)
    case False{}:
      gb.n627(U32.is_lt(c, 10025), c)

def gb.n629(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n625(U32.is_lt(c, 10013), c)
    case False{}:
      gb.n628(U32.is_lt(c, 10024), c)

def gb.n630(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n631(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n632(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n630(U32.is_lt(c, 10037), c)
    case False{}:
      gb.n631(U32.is_lt(c, 10053), c)

def gb.n633(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n634(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n635(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n634(U32.is_lt(c, 10062), c)

def gb.n636(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n633(U32.is_lt(c, 10056), c)
    case False{}:
      gb.n635(U32.is_lt(c, 10061), c)

def gb.n637(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n632(U32.is_lt(c, 10052), c)
    case False{}:
      gb.n636(U32.is_lt(c, 10060), c)

def gb.n638(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n629(U32.is_lt(c, 10017), c)
    case False{}:
      gb.n637(U32.is_lt(c, 10055), c)

def gb.n639(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n622(U32.is_lt(c, 9990), c)
    case False{}:
      gb.n638(U32.is_lt(c, 10035), c)

def gb.n640(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n641(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n642(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n640(U32.is_lt(c, 10067), c)
    case False{}:
      gb.n641(U32.is_lt(c, 10071), c)

def gb.n643(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n644(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n645(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n643(U32.is_lt(c, 10083), c)
    case False{}:
      gb.n644(U32.is_lt(c, 10133), c)

def gb.n646(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n642(U32.is_lt(c, 10070), c)
    case False{}:
      gb.n645(U32.is_lt(c, 10085), c)

def gb.n647(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n648(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n649(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n647(U32.is_lt(c, 10145), c)
    case False{}:
      gb.n648(U32.is_lt(c, 10160), c)

def gb.n650(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n651(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n652(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n651(U32.is_lt(c, 10550), c)

def gb.n653(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n650(U32.is_lt(c, 10175), c)
    case False{}:
      gb.n652(U32.is_lt(c, 10548), c)

def gb.n654(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n649(U32.is_lt(c, 10146), c)
    case False{}:
      gb.n653(U32.is_lt(c, 10176), c)

def gb.n655(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n646(U32.is_lt(c, 10072), c)
    case False{}:
      gb.n654(U32.is_lt(c, 10161), c)

def gb.n656(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n657(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n658(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n656(U32.is_lt(c, 11016), c)
    case False{}:
      gb.n657(U32.is_lt(c, 11037), c)

def gb.n659(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n660(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n661(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n659(U32.is_lt(c, 11089), c)
    case False{}:
      gb.n660(U32.is_lt(c, 11094), c)

def gb.n662(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n658(U32.is_lt(c, 11035), c)
    case False{}:
      gb.n661(U32.is_lt(c, 11093), c)

def gb.n663(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n664(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n665(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n663(U32.is_lt(c, 11506), c)
    case False{}:
      gb.n664(U32.is_lt(c, 11648), c)

def gb.n666(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n667(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n668(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n667(U32.is_lt(c, 12337), c)

def gb.n669(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n666(U32.is_lt(c, 11776), c)
    case False{}:
      gb.n668(U32.is_lt(c, 12336), c)

def gb.n670(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n665(U32.is_lt(c, 11647), c)
    case False{}:
      gb.n669(U32.is_lt(c, 12330), c)

def gb.n671(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n662(U32.is_lt(c, 11088), c)
    case False{}:
      gb.n670(U32.is_lt(c, 11744), c)

def gb.n672(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n655(U32.is_lt(c, 10136), c)
    case False{}:
      gb.n671(U32.is_lt(c, 11503), c)

def gb.n673(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n639(U32.is_lt(c, 10006), c)
    case False{}:
      gb.n672(U32.is_lt(c, 11013), c)

def gb.n674(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n606(U32.is_lt(c, 9833), c)
    case False{}:
      gb.n673(U32.is_lt(c, 10063), c)

def gb.n675(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n676(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n677(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n675(U32.is_lt(c, 12350), c)
    case False{}:
      gb.n676(U32.is_lt(c, 12443), c)

def gb.n678(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n679(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n680(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n678(U32.is_lt(c, 12952), c)
    case False{}:
      gb.n679(U32.is_lt(c, 12954), c)

def gb.n681(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n677(U32.is_lt(c, 12441), c)
    case False{}:
      gb.n680(U32.is_lt(c, 12953), c)

def gb.n682(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n683(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n684(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n682(U32.is_lt(c, 42611), c)
    case False{}:
      gb.n683(U32.is_lt(c, 42622), c)

def gb.n685(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n686(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n687(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n686(U32.is_lt(c, 43010), c)

def gb.n688(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n685(U32.is_lt(c, 42656), c)
    case False{}:
      gb.n687(U32.is_lt(c, 42738), c)

def gb.n689(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n684(U32.is_lt(c, 42612), c)
    case False{}:
      gb.n688(U32.is_lt(c, 42736), c)

def gb.n690(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n681(U32.is_lt(c, 12951), c)
    case False{}:
      gb.n689(U32.is_lt(c, 42654), c)

def gb.n691(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n692(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n693(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n691(U32.is_lt(c, 43014), c)
    case False{}:
      gb.n692(U32.is_lt(c, 43019), c)

def gb.n694(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n695(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n696(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n694(U32.is_lt(c, 43043), c)
    case False{}:
      gb.n695(U32.is_lt(c, 43047), c)

def gb.n697(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n693(U32.is_lt(c, 43015), c)
    case False{}:
      gb.n696(U32.is_lt(c, 43045), c)

def gb.n698(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n699(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n700(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n698(U32.is_lt(c, 43052), c)
    case False{}:
      gb.n699(U32.is_lt(c, 43136), c)

def gb.n701(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n702(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n703(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n702(U32.is_lt(c, 43232), c)

def gb.n704(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n701(U32.is_lt(c, 43188), c)
    case False{}:
      gb.n703(U32.is_lt(c, 43206), c)

def gb.n705(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n700(U32.is_lt(c, 43053), c)
    case False{}:
      gb.n704(U32.is_lt(c, 43204), c)

def gb.n706(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n697(U32.is_lt(c, 43020), c)
    case False{}:
      gb.n705(U32.is_lt(c, 43138), c)

def gb.n707(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n690(U32.is_lt(c, 42607), c)
    case False{}:
      gb.n706(U32.is_lt(c, 43048), c)

def gb.n708(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n709(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n710(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n708(U32.is_lt(c, 43263), c)
    case False{}:
      gb.n709(U32.is_lt(c, 43302), c)

def gb.n711(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n712(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n713(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n711(U32.is_lt(c, 43335), c)
    case False{}:
      gb.n712(U32.is_lt(c, 43347), c)

def gb.n714(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n710(U32.is_lt(c, 43264), c)
    case False{}:
      gb.n713(U32.is_lt(c, 43346), c)

def gb.n715(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      9

def gb.n716(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n717(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n715(U32.is_lt(c, 43360), c)
    case False{}:
      gb.n716(U32.is_lt(c, 43392), c)

def gb.n718(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n719(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n720(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n719(U32.is_lt(c, 43407), c)

def gb.n721(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n718(U32.is_lt(c, 43396), c)
    case False{}:
      gb.n720(U32.is_lt(c, 43404), c)

def gb.n722(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n717(U32.is_lt(c, 43389), c)
    case False{}:
      gb.n721(U32.is_lt(c, 43401), c)

def gb.n723(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n714(U32.is_lt(c, 43310), c)
    case False{}:
      gb.n722(U32.is_lt(c, 43395), c)

def gb.n724(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n725(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n726(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n724(U32.is_lt(c, 43444), c)
    case False{}:
      gb.n725(U32.is_lt(c, 43450), c)

def gb.n727(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n728(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      0

def gb.n729(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n727(U32.is_lt(c, 43454), c)
    case False{}:
      gb.n728(U32.is_lt(c, 43457), c)

def gb.n730(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n726(U32.is_lt(c, 43446), c)
    case False{}:
      gb.n729(U32.is_lt(c, 43456), c)

def gb.n731(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      68

def gb.n732(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n733(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n731(U32.is_lt(c, 43493), c)
    case False{}:
      gb.n732(U32.is_lt(c, 43495), c)

def gb.n734(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n735(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n736(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n735(U32.is_lt(c, 43567), c)

def gb.n737(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n734(U32.is_lt(c, 43514), c)
    case False{}:
      gb.n736(U32.is_lt(c, 43561), c)

def gb.n738(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n733(U32.is_lt(c, 43494), c)
    case False{}:
      gb.n737(U32.is_lt(c, 43519), c)

def gb.n739(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n730(U32.is_lt(c, 43452), c)
    case False{}:
      gb.n738(U32.is_lt(c, 43504), c)

def gb.n740(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n723(U32.is_lt(c, 43348), c)
    case False{}:
      gb.n739(U32.is_lt(c, 43488), c)

def gb.n741(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n707(U32.is_lt(c, 43011), c)
    case False{}:
      gb.n740(U32.is_lt(c, 43443), c)

def gb.n742(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n743(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n744(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n742(U32.is_lt(c, 43571), c)
    case False{}:
      gb.n743(U32.is_lt(c, 43575), c)

def gb.n745(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n746(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n747(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n745(U32.is_lt(c, 43588), c)
    case False{}:
      gb.n746(U32.is_lt(c, 43597), c)

def gb.n748(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n744(U32.is_lt(c, 43573), c)
    case False{}:
      gb.n747(U32.is_lt(c, 43596), c)

def gb.n749(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n750(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n751(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n749(U32.is_lt(c, 43616), c)
    case False{}:
      gb.n750(U32.is_lt(c, 43633), c)

def gb.n752(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n753(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n754(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n753(U32.is_lt(c, 43645), c)

def gb.n755(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n752(U32.is_lt(c, 43642), c)
    case False{}:
      gb.n754(U32.is_lt(c, 43644), c)

def gb.n756(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n751(U32.is_lt(c, 43632), c)
    case False{}:
      gb.n755(U32.is_lt(c, 43643), c)

def gb.n757(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n748(U32.is_lt(c, 43587), c)
    case False{}:
      gb.n756(U32.is_lt(c, 43636), c)

def gb.n758(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n759(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n760(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n758(U32.is_lt(c, 43648), c)
    case False{}:
      gb.n759(U32.is_lt(c, 43697), c)

def gb.n761(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n762(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n763(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n761(U32.is_lt(c, 43701), c)
    case False{}:
      gb.n762(U32.is_lt(c, 43705), c)

def gb.n764(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n760(U32.is_lt(c, 43696), c)
    case False{}:
      gb.n763(U32.is_lt(c, 43703), c)

def gb.n765(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n766(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n767(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n765(U32.is_lt(c, 43712), c)
    case False{}:
      gb.n766(U32.is_lt(c, 43714), c)

def gb.n768(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      8

def gb.n769(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n770(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n769(U32.is_lt(c, 43760), c)

def gb.n771(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n768(U32.is_lt(c, 43755), c)
    case False{}:
      gb.n770(U32.is_lt(c, 43758), c)

def gb.n772(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n767(U32.is_lt(c, 43713), c)
    case False{}:
      gb.n771(U32.is_lt(c, 43756), c)

def gb.n773(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n764(U32.is_lt(c, 43698), c)
    case False{}:
      gb.n772(U32.is_lt(c, 43744), c)

def gb.n774(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n757(U32.is_lt(c, 43598), c)
    case False{}:
      gb.n773(U32.is_lt(c, 43710), c)

def gb.n775(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      100

def gb.n776(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n777(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n775(U32.is_lt(c, 43766), c)
    case False{}:
      gb.n776(U32.is_lt(c, 43968), c)

def gb.n778(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n779(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n780(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n778(U32.is_lt(c, 44003), c)
    case False{}:
      gb.n779(U32.is_lt(c, 44006), c)

def gb.n781(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n777(U32.is_lt(c, 43767), c)
    case False{}:
      gb.n780(U32.is_lt(c, 44005), c)

def gb.n782(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n783(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n784(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n782(U32.is_lt(c, 44009), c)
    case False{}:
      gb.n783(U32.is_lt(c, 44012), c)

def gb.n785(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n786(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n787(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n786(U32.is_lt(c, 44060), c)

def gb.n788(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n785(U32.is_lt(c, 44014), c)
    case False{}:
      gb.n787(U32.is_lt(c, 44033), c)

def gb.n789(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n784(U32.is_lt(c, 44011), c)
    case False{}:
      gb.n788(U32.is_lt(c, 44032), c)

def gb.n790(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n781(U32.is_lt(c, 43995), c)
    case False{}:
      gb.n789(U32.is_lt(c, 44013), c)

def gb.n791(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n792(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n793(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n791(U32.is_lt(c, 44088), c)
    case False{}:
      gb.n792(U32.is_lt(c, 44116), c)

def gb.n794(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n795(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n796(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n794(U32.is_lt(c, 44144), c)
    case False{}:
      gb.n795(U32.is_lt(c, 44172), c)

def gb.n797(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n793(U32.is_lt(c, 44089), c)
    case False{}:
      gb.n796(U32.is_lt(c, 44145), c)

def gb.n798(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n799(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n800(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n798(U32.is_lt(c, 44200), c)
    case False{}:
      gb.n799(U32.is_lt(c, 44228), c)

def gb.n801(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n802(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n803(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n802(U32.is_lt(c, 44285), c)

def gb.n804(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n801(U32.is_lt(c, 44256), c)
    case False{}:
      gb.n803(U32.is_lt(c, 44284), c)

def gb.n805(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n800(U32.is_lt(c, 44201), c)
    case False{}:
      gb.n804(U32.is_lt(c, 44257), c)

def gb.n806(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n797(U32.is_lt(c, 44117), c)
    case False{}:
      gb.n805(U32.is_lt(c, 44229), c)

def gb.n807(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n790(U32.is_lt(c, 44008), c)
    case False{}:
      gb.n806(U32.is_lt(c, 44173), c)

def gb.n808(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n774(U32.is_lt(c, 43646), c)
    case False{}:
      gb.n807(U32.is_lt(c, 44061), c)

def gb.n809(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n741(U32.is_lt(c, 43250), c)
    case False{}:
      gb.n808(U32.is_lt(c, 43765), c)

def gb.n810(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n674(U32.is_lt(c, 9974), c)
    case False{}:
      gb.n809(U32.is_lt(c, 43569), c)

def gb.n811(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n812(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n813(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n811(U32.is_lt(c, 44313), c)
    case False{}:
      gb.n812(U32.is_lt(c, 44341), c)

def gb.n814(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n815(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n816(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n814(U32.is_lt(c, 44369), c)
    case False{}:
      gb.n815(U32.is_lt(c, 44397), c)

def gb.n817(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n813(U32.is_lt(c, 44340), c)
    case False{}:
      gb.n816(U32.is_lt(c, 44396), c)

def gb.n818(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n819(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n820(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n818(U32.is_lt(c, 44425), c)
    case False{}:
      gb.n819(U32.is_lt(c, 44453), c)

def gb.n821(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n822(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n823(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n821(U32.is_lt(c, 44481), c)
    case False{}:
      gb.n822(U32.is_lt(c, 44509), c)

def gb.n824(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n820(U32.is_lt(c, 44452), c)
    case False{}:
      gb.n823(U32.is_lt(c, 44508), c)

def gb.n825(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n817(U32.is_lt(c, 44368), c)
    case False{}:
      gb.n824(U32.is_lt(c, 44480), c)

def gb.n826(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n827(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n828(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n826(U32.is_lt(c, 44537), c)
    case False{}:
      gb.n827(U32.is_lt(c, 44565), c)

def gb.n829(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n830(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n831(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n829(U32.is_lt(c, 44593), c)
    case False{}:
      gb.n830(U32.is_lt(c, 44621), c)

def gb.n832(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n828(U32.is_lt(c, 44564), c)
    case False{}:
      gb.n831(U32.is_lt(c, 44620), c)

def gb.n833(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n834(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n835(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n833(U32.is_lt(c, 44649), c)
    case False{}:
      gb.n834(U32.is_lt(c, 44677), c)

def gb.n836(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n837(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n838(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n837(U32.is_lt(c, 44760), c)

def gb.n839(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n836(U32.is_lt(c, 44705), c)
    case False{}:
      gb.n838(U32.is_lt(c, 44733), c)

def gb.n840(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n835(U32.is_lt(c, 44676), c)
    case False{}:
      gb.n839(U32.is_lt(c, 44732), c)

def gb.n841(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n832(U32.is_lt(c, 44592), c)
    case False{}:
      gb.n840(U32.is_lt(c, 44704), c)

def gb.n842(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n825(U32.is_lt(c, 44424), c)
    case False{}:
      gb.n841(U32.is_lt(c, 44648), c)

def gb.n843(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n844(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n845(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n843(U32.is_lt(c, 44788), c)
    case False{}:
      gb.n844(U32.is_lt(c, 44816), c)

def gb.n846(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n847(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n848(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n846(U32.is_lt(c, 44844), c)
    case False{}:
      gb.n847(U32.is_lt(c, 44872), c)

def gb.n849(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n845(U32.is_lt(c, 44789), c)
    case False{}:
      gb.n848(U32.is_lt(c, 44845), c)

def gb.n850(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n851(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n852(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n850(U32.is_lt(c, 44900), c)
    case False{}:
      gb.n851(U32.is_lt(c, 44928), c)

def gb.n853(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n854(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n855(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n854(U32.is_lt(c, 44985), c)

def gb.n856(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n853(U32.is_lt(c, 44956), c)
    case False{}:
      gb.n855(U32.is_lt(c, 44984), c)

def gb.n857(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n852(U32.is_lt(c, 44901), c)
    case False{}:
      gb.n856(U32.is_lt(c, 44957), c)

def gb.n858(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n849(U32.is_lt(c, 44817), c)
    case False{}:
      gb.n857(U32.is_lt(c, 44929), c)

def gb.n859(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n860(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n861(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n859(U32.is_lt(c, 45013), c)
    case False{}:
      gb.n860(U32.is_lt(c, 45041), c)

def gb.n862(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n863(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n864(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n862(U32.is_lt(c, 45069), c)
    case False{}:
      gb.n863(U32.is_lt(c, 45097), c)

def gb.n865(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n861(U32.is_lt(c, 45040), c)
    case False{}:
      gb.n864(U32.is_lt(c, 45096), c)

def gb.n866(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n867(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n868(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n866(U32.is_lt(c, 45125), c)
    case False{}:
      gb.n867(U32.is_lt(c, 45153), c)

def gb.n869(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n870(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n871(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n870(U32.is_lt(c, 45236), c)

def gb.n872(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n869(U32.is_lt(c, 45181), c)
    case False{}:
      gb.n871(U32.is_lt(c, 45209), c)

def gb.n873(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n868(U32.is_lt(c, 45152), c)
    case False{}:
      gb.n872(U32.is_lt(c, 45208), c)

def gb.n874(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n865(U32.is_lt(c, 45068), c)
    case False{}:
      gb.n873(U32.is_lt(c, 45180), c)

def gb.n875(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n858(U32.is_lt(c, 44873), c)
    case False{}:
      gb.n874(U32.is_lt(c, 45124), c)

def gb.n876(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n842(U32.is_lt(c, 44536), c)
    case False{}:
      gb.n875(U32.is_lt(c, 45012), c)

def gb.n877(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n878(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n879(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n877(U32.is_lt(c, 45264), c)
    case False{}:
      gb.n878(U32.is_lt(c, 45292), c)

def gb.n880(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n881(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n882(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n880(U32.is_lt(c, 45320), c)
    case False{}:
      gb.n881(U32.is_lt(c, 45348), c)

def gb.n883(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n879(U32.is_lt(c, 45265), c)
    case False{}:
      gb.n882(U32.is_lt(c, 45321), c)

def gb.n884(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n885(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n886(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n884(U32.is_lt(c, 45376), c)
    case False{}:
      gb.n885(U32.is_lt(c, 45404), c)

def gb.n887(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n888(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n889(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n888(U32.is_lt(c, 45461), c)

def gb.n890(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n887(U32.is_lt(c, 45432), c)
    case False{}:
      gb.n889(U32.is_lt(c, 45460), c)

def gb.n891(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n886(U32.is_lt(c, 45377), c)
    case False{}:
      gb.n890(U32.is_lt(c, 45433), c)

def gb.n892(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n883(U32.is_lt(c, 45293), c)
    case False{}:
      gb.n891(U32.is_lt(c, 45405), c)

def gb.n893(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n894(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n895(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n893(U32.is_lt(c, 45489), c)
    case False{}:
      gb.n894(U32.is_lt(c, 45517), c)

def gb.n896(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n897(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n898(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n896(U32.is_lt(c, 45545), c)
    case False{}:
      gb.n897(U32.is_lt(c, 45573), c)

def gb.n899(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n895(U32.is_lt(c, 45516), c)
    case False{}:
      gb.n898(U32.is_lt(c, 45572), c)

def gb.n900(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n901(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n902(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n900(U32.is_lt(c, 45601), c)
    case False{}:
      gb.n901(U32.is_lt(c, 45629), c)

def gb.n903(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n904(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n905(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n904(U32.is_lt(c, 45712), c)

def gb.n906(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n903(U32.is_lt(c, 45657), c)
    case False{}:
      gb.n905(U32.is_lt(c, 45685), c)

def gb.n907(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n902(U32.is_lt(c, 45628), c)
    case False{}:
      gb.n906(U32.is_lt(c, 45684), c)

def gb.n908(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n899(U32.is_lt(c, 45544), c)
    case False{}:
      gb.n907(U32.is_lt(c, 45656), c)

def gb.n909(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n892(U32.is_lt(c, 45349), c)
    case False{}:
      gb.n908(U32.is_lt(c, 45600), c)

def gb.n910(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n911(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n912(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n910(U32.is_lt(c, 45740), c)
    case False{}:
      gb.n911(U32.is_lt(c, 45768), c)

def gb.n913(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n914(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n915(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n913(U32.is_lt(c, 45796), c)
    case False{}:
      gb.n914(U32.is_lt(c, 45824), c)

def gb.n916(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n912(U32.is_lt(c, 45741), c)
    case False{}:
      gb.n915(U32.is_lt(c, 45797), c)

def gb.n917(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n918(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n919(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n917(U32.is_lt(c, 45852), c)
    case False{}:
      gb.n918(U32.is_lt(c, 45880), c)

def gb.n920(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n921(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n922(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n921(U32.is_lt(c, 45937), c)

def gb.n923(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n920(U32.is_lt(c, 45908), c)
    case False{}:
      gb.n922(U32.is_lt(c, 45936), c)

def gb.n924(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n919(U32.is_lt(c, 45853), c)
    case False{}:
      gb.n923(U32.is_lt(c, 45909), c)

def gb.n925(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n916(U32.is_lt(c, 45769), c)
    case False{}:
      gb.n924(U32.is_lt(c, 45881), c)

def gb.n926(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n927(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n928(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n926(U32.is_lt(c, 45965), c)
    case False{}:
      gb.n927(U32.is_lt(c, 45993), c)

def gb.n929(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n930(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n931(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n929(U32.is_lt(c, 46021), c)
    case False{}:
      gb.n930(U32.is_lt(c, 46049), c)

def gb.n932(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n928(U32.is_lt(c, 45992), c)
    case False{}:
      gb.n931(U32.is_lt(c, 46048), c)

def gb.n933(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n934(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n935(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n933(U32.is_lt(c, 46077), c)
    case False{}:
      gb.n934(U32.is_lt(c, 46105), c)

def gb.n936(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n937(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n938(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n937(U32.is_lt(c, 46188), c)

def gb.n939(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n936(U32.is_lt(c, 46133), c)
    case False{}:
      gb.n938(U32.is_lt(c, 46161), c)

def gb.n940(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n935(U32.is_lt(c, 46104), c)
    case False{}:
      gb.n939(U32.is_lt(c, 46160), c)

def gb.n941(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n932(U32.is_lt(c, 46020), c)
    case False{}:
      gb.n940(U32.is_lt(c, 46132), c)

def gb.n942(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n925(U32.is_lt(c, 45825), c)
    case False{}:
      gb.n941(U32.is_lt(c, 46076), c)

def gb.n943(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n909(U32.is_lt(c, 45488), c)
    case False{}:
      gb.n942(U32.is_lt(c, 45964), c)

def gb.n944(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n876(U32.is_lt(c, 44761), c)
    case False{}:
      gb.n943(U32.is_lt(c, 45713), c)

def gb.n945(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n946(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n947(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n945(U32.is_lt(c, 46216), c)
    case False{}:
      gb.n946(U32.is_lt(c, 46244), c)

def gb.n948(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n949(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n950(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n948(U32.is_lt(c, 46272), c)
    case False{}:
      gb.n949(U32.is_lt(c, 46300), c)

def gb.n951(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n947(U32.is_lt(c, 46217), c)
    case False{}:
      gb.n950(U32.is_lt(c, 46273), c)

def gb.n952(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n953(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n954(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n952(U32.is_lt(c, 46328), c)
    case False{}:
      gb.n953(U32.is_lt(c, 46356), c)

def gb.n955(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n956(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n957(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n956(U32.is_lt(c, 46413), c)

def gb.n958(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n955(U32.is_lt(c, 46384), c)
    case False{}:
      gb.n957(U32.is_lt(c, 46412), c)

def gb.n959(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n954(U32.is_lt(c, 46329), c)
    case False{}:
      gb.n958(U32.is_lt(c, 46385), c)

def gb.n960(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n951(U32.is_lt(c, 46245), c)
    case False{}:
      gb.n959(U32.is_lt(c, 46357), c)

def gb.n961(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n962(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n963(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n961(U32.is_lt(c, 46441), c)
    case False{}:
      gb.n962(U32.is_lt(c, 46469), c)

def gb.n964(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n965(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n966(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n964(U32.is_lt(c, 46497), c)
    case False{}:
      gb.n965(U32.is_lt(c, 46525), c)

def gb.n967(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n963(U32.is_lt(c, 46468), c)
    case False{}:
      gb.n966(U32.is_lt(c, 46524), c)

def gb.n968(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n969(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n970(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n968(U32.is_lt(c, 46553), c)
    case False{}:
      gb.n969(U32.is_lt(c, 46581), c)

def gb.n971(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n972(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n973(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n972(U32.is_lt(c, 46664), c)

def gb.n974(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n971(U32.is_lt(c, 46609), c)
    case False{}:
      gb.n973(U32.is_lt(c, 46637), c)

def gb.n975(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n970(U32.is_lt(c, 46580), c)
    case False{}:
      gb.n974(U32.is_lt(c, 46636), c)

def gb.n976(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n967(U32.is_lt(c, 46496), c)
    case False{}:
      gb.n975(U32.is_lt(c, 46608), c)

def gb.n977(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n960(U32.is_lt(c, 46301), c)
    case False{}:
      gb.n976(U32.is_lt(c, 46552), c)

def gb.n978(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n979(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n980(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n978(U32.is_lt(c, 46692), c)
    case False{}:
      gb.n979(U32.is_lt(c, 46720), c)

def gb.n981(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n982(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n983(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n981(U32.is_lt(c, 46748), c)
    case False{}:
      gb.n982(U32.is_lt(c, 46776), c)

def gb.n984(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n980(U32.is_lt(c, 46693), c)
    case False{}:
      gb.n983(U32.is_lt(c, 46749), c)

def gb.n985(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n986(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n987(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n985(U32.is_lt(c, 46804), c)
    case False{}:
      gb.n986(U32.is_lt(c, 46832), c)

def gb.n988(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n989(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n990(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n989(U32.is_lt(c, 46889), c)

def gb.n991(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n988(U32.is_lt(c, 46860), c)
    case False{}:
      gb.n990(U32.is_lt(c, 46888), c)

def gb.n992(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n987(U32.is_lt(c, 46805), c)
    case False{}:
      gb.n991(U32.is_lt(c, 46861), c)

def gb.n993(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n984(U32.is_lt(c, 46721), c)
    case False{}:
      gb.n992(U32.is_lt(c, 46833), c)

def gb.n994(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n995(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n996(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n994(U32.is_lt(c, 46917), c)
    case False{}:
      gb.n995(U32.is_lt(c, 46945), c)

def gb.n997(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n998(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n999(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n997(U32.is_lt(c, 46973), c)
    case False{}:
      gb.n998(U32.is_lt(c, 47001), c)

def gb.n1000(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n996(U32.is_lt(c, 46944), c)
    case False{}:
      gb.n999(U32.is_lt(c, 47000), c)

def gb.n1001(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1002(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1003(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1001(U32.is_lt(c, 47029), c)
    case False{}:
      gb.n1002(U32.is_lt(c, 47057), c)

def gb.n1004(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1005(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1006(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1005(U32.is_lt(c, 47140), c)

def gb.n1007(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1004(U32.is_lt(c, 47085), c)
    case False{}:
      gb.n1006(U32.is_lt(c, 47113), c)

def gb.n1008(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1003(U32.is_lt(c, 47056), c)
    case False{}:
      gb.n1007(U32.is_lt(c, 47112), c)

def gb.n1009(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1000(U32.is_lt(c, 46972), c)
    case False{}:
      gb.n1008(U32.is_lt(c, 47084), c)

def gb.n1010(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n993(U32.is_lt(c, 46777), c)
    case False{}:
      gb.n1009(U32.is_lt(c, 47028), c)

def gb.n1011(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n977(U32.is_lt(c, 46440), c)
    case False{}:
      gb.n1010(U32.is_lt(c, 46916), c)

def gb.n1012(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1013(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1014(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1012(U32.is_lt(c, 47168), c)
    case False{}:
      gb.n1013(U32.is_lt(c, 47196), c)

def gb.n1015(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1016(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1017(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1015(U32.is_lt(c, 47224), c)
    case False{}:
      gb.n1016(U32.is_lt(c, 47252), c)

def gb.n1018(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1014(U32.is_lt(c, 47169), c)
    case False{}:
      gb.n1017(U32.is_lt(c, 47225), c)

def gb.n1019(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1020(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1021(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1019(U32.is_lt(c, 47280), c)
    case False{}:
      gb.n1020(U32.is_lt(c, 47308), c)

def gb.n1022(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1023(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1024(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1023(U32.is_lt(c, 47365), c)

def gb.n1025(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1022(U32.is_lt(c, 47336), c)
    case False{}:
      gb.n1024(U32.is_lt(c, 47364), c)

def gb.n1026(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1021(U32.is_lt(c, 47281), c)
    case False{}:
      gb.n1025(U32.is_lt(c, 47337), c)

def gb.n1027(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1018(U32.is_lt(c, 47197), c)
    case False{}:
      gb.n1026(U32.is_lt(c, 47309), c)

def gb.n1028(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1029(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1030(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1028(U32.is_lt(c, 47393), c)
    case False{}:
      gb.n1029(U32.is_lt(c, 47421), c)

def gb.n1031(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1032(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1033(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1031(U32.is_lt(c, 47449), c)
    case False{}:
      gb.n1032(U32.is_lt(c, 47477), c)

def gb.n1034(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1030(U32.is_lt(c, 47420), c)
    case False{}:
      gb.n1033(U32.is_lt(c, 47476), c)

def gb.n1035(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1036(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1037(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1035(U32.is_lt(c, 47505), c)
    case False{}:
      gb.n1036(U32.is_lt(c, 47533), c)

def gb.n1038(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1039(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1040(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1039(U32.is_lt(c, 47616), c)

def gb.n1041(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1038(U32.is_lt(c, 47561), c)
    case False{}:
      gb.n1040(U32.is_lt(c, 47589), c)

def gb.n1042(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1037(U32.is_lt(c, 47532), c)
    case False{}:
      gb.n1041(U32.is_lt(c, 47588), c)

def gb.n1043(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1034(U32.is_lt(c, 47448), c)
    case False{}:
      gb.n1042(U32.is_lt(c, 47560), c)

def gb.n1044(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1027(U32.is_lt(c, 47253), c)
    case False{}:
      gb.n1043(U32.is_lt(c, 47504), c)

def gb.n1045(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1046(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1047(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1045(U32.is_lt(c, 47644), c)
    case False{}:
      gb.n1046(U32.is_lt(c, 47672), c)

def gb.n1048(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1049(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1050(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1048(U32.is_lt(c, 47700), c)
    case False{}:
      gb.n1049(U32.is_lt(c, 47728), c)

def gb.n1051(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1047(U32.is_lt(c, 47645), c)
    case False{}:
      gb.n1050(U32.is_lt(c, 47701), c)

def gb.n1052(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1053(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1054(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1052(U32.is_lt(c, 47756), c)
    case False{}:
      gb.n1053(U32.is_lt(c, 47784), c)

def gb.n1055(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1056(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1057(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1056(U32.is_lt(c, 47841), c)

def gb.n1058(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1055(U32.is_lt(c, 47812), c)
    case False{}:
      gb.n1057(U32.is_lt(c, 47840), c)

def gb.n1059(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1054(U32.is_lt(c, 47757), c)
    case False{}:
      gb.n1058(U32.is_lt(c, 47813), c)

def gb.n1060(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1051(U32.is_lt(c, 47673), c)
    case False{}:
      gb.n1059(U32.is_lt(c, 47785), c)

def gb.n1061(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1062(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1063(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1061(U32.is_lt(c, 47869), c)
    case False{}:
      gb.n1062(U32.is_lt(c, 47897), c)

def gb.n1064(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1065(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1066(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1064(U32.is_lt(c, 47925), c)
    case False{}:
      gb.n1065(U32.is_lt(c, 47953), c)

def gb.n1067(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1063(U32.is_lt(c, 47896), c)
    case False{}:
      gb.n1066(U32.is_lt(c, 47952), c)

def gb.n1068(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1069(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1070(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1068(U32.is_lt(c, 47981), c)
    case False{}:
      gb.n1069(U32.is_lt(c, 48009), c)

def gb.n1071(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1072(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1073(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1072(U32.is_lt(c, 48092), c)

def gb.n1074(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1071(U32.is_lt(c, 48037), c)
    case False{}:
      gb.n1073(U32.is_lt(c, 48065), c)

def gb.n1075(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1070(U32.is_lt(c, 48008), c)
    case False{}:
      gb.n1074(U32.is_lt(c, 48064), c)

def gb.n1076(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1067(U32.is_lt(c, 47924), c)
    case False{}:
      gb.n1075(U32.is_lt(c, 48036), c)

def gb.n1077(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1060(U32.is_lt(c, 47729), c)
    case False{}:
      gb.n1076(U32.is_lt(c, 47980), c)

def gb.n1078(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1044(U32.is_lt(c, 47392), c)
    case False{}:
      gb.n1077(U32.is_lt(c, 47868), c)

def gb.n1079(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1011(U32.is_lt(c, 46665), c)
    case False{}:
      gb.n1078(U32.is_lt(c, 47617), c)

def gb.n1080(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n944(U32.is_lt(c, 45237), c)
    case False{}:
      gb.n1079(U32.is_lt(c, 47141), c)

def gb.n1081(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n810(U32.is_lt(c, 12349), c)
    case False{}:
      gb.n1080(U32.is_lt(c, 46189), c)

def gb.n1082(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n540(U32.is_lt(c, 3390), c)
    case False{}:
      gb.n1081(U32.is_lt(c, 44312), c)

def gb.n1083(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1084(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1085(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1083(U32.is_lt(c, 48120), c)
    case False{}:
      gb.n1084(U32.is_lt(c, 48148), c)

def gb.n1086(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1087(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1088(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1086(U32.is_lt(c, 48176), c)
    case False{}:
      gb.n1087(U32.is_lt(c, 48204), c)

def gb.n1089(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1085(U32.is_lt(c, 48121), c)
    case False{}:
      gb.n1088(U32.is_lt(c, 48177), c)

def gb.n1090(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1091(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1092(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1090(U32.is_lt(c, 48232), c)
    case False{}:
      gb.n1091(U32.is_lt(c, 48260), c)

def gb.n1093(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1094(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1095(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1093(U32.is_lt(c, 48288), c)
    case False{}:
      gb.n1094(U32.is_lt(c, 48316), c)

def gb.n1096(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1092(U32.is_lt(c, 48233), c)
    case False{}:
      gb.n1095(U32.is_lt(c, 48289), c)

def gb.n1097(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1089(U32.is_lt(c, 48149), c)
    case False{}:
      gb.n1096(U32.is_lt(c, 48261), c)

def gb.n1098(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1099(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1100(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1098(U32.is_lt(c, 48344), c)
    case False{}:
      gb.n1099(U32.is_lt(c, 48372), c)

def gb.n1101(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1102(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1103(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1101(U32.is_lt(c, 48400), c)
    case False{}:
      gb.n1102(U32.is_lt(c, 48428), c)

def gb.n1104(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1100(U32.is_lt(c, 48345), c)
    case False{}:
      gb.n1103(U32.is_lt(c, 48401), c)

def gb.n1105(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1106(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1107(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1105(U32.is_lt(c, 48456), c)
    case False{}:
      gb.n1106(U32.is_lt(c, 48484), c)

def gb.n1108(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1109(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1110(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1109(U32.is_lt(c, 48541), c)

def gb.n1111(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1108(U32.is_lt(c, 48512), c)
    case False{}:
      gb.n1110(U32.is_lt(c, 48540), c)

def gb.n1112(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1107(U32.is_lt(c, 48457), c)
    case False{}:
      gb.n1111(U32.is_lt(c, 48513), c)

def gb.n1113(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1104(U32.is_lt(c, 48373), c)
    case False{}:
      gb.n1112(U32.is_lt(c, 48485), c)

def gb.n1114(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1097(U32.is_lt(c, 48205), c)
    case False{}:
      gb.n1113(U32.is_lt(c, 48429), c)

def gb.n1115(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1116(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1117(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1115(U32.is_lt(c, 48569), c)
    case False{}:
      gb.n1116(U32.is_lt(c, 48597), c)

def gb.n1118(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1119(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1120(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1118(U32.is_lt(c, 48625), c)
    case False{}:
      gb.n1119(U32.is_lt(c, 48653), c)

def gb.n1121(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1117(U32.is_lt(c, 48596), c)
    case False{}:
      gb.n1120(U32.is_lt(c, 48652), c)

def gb.n1122(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1123(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1124(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1122(U32.is_lt(c, 48681), c)
    case False{}:
      gb.n1123(U32.is_lt(c, 48709), c)

def gb.n1125(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1126(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1127(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1126(U32.is_lt(c, 48792), c)

def gb.n1128(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1125(U32.is_lt(c, 48737), c)
    case False{}:
      gb.n1127(U32.is_lt(c, 48765), c)

def gb.n1129(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1124(U32.is_lt(c, 48708), c)
    case False{}:
      gb.n1128(U32.is_lt(c, 48764), c)

def gb.n1130(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1121(U32.is_lt(c, 48624), c)
    case False{}:
      gb.n1129(U32.is_lt(c, 48736), c)

def gb.n1131(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1132(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1133(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1131(U32.is_lt(c, 48820), c)
    case False{}:
      gb.n1132(U32.is_lt(c, 48848), c)

def gb.n1134(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1135(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1136(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1134(U32.is_lt(c, 48876), c)
    case False{}:
      gb.n1135(U32.is_lt(c, 48904), c)

def gb.n1137(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1133(U32.is_lt(c, 48821), c)
    case False{}:
      gb.n1136(U32.is_lt(c, 48877), c)

def gb.n1138(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1139(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1140(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1138(U32.is_lt(c, 48932), c)
    case False{}:
      gb.n1139(U32.is_lt(c, 48960), c)

def gb.n1141(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1142(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1143(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1142(U32.is_lt(c, 49017), c)

def gb.n1144(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1141(U32.is_lt(c, 48988), c)
    case False{}:
      gb.n1143(U32.is_lt(c, 49016), c)

def gb.n1145(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1140(U32.is_lt(c, 48933), c)
    case False{}:
      gb.n1144(U32.is_lt(c, 48989), c)

def gb.n1146(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1137(U32.is_lt(c, 48849), c)
    case False{}:
      gb.n1145(U32.is_lt(c, 48961), c)

def gb.n1147(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1130(U32.is_lt(c, 48680), c)
    case False{}:
      gb.n1146(U32.is_lt(c, 48905), c)

def gb.n1148(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1114(U32.is_lt(c, 48317), c)
    case False{}:
      gb.n1147(U32.is_lt(c, 48793), c)

def gb.n1149(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1150(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1151(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1149(U32.is_lt(c, 49045), c)
    case False{}:
      gb.n1150(U32.is_lt(c, 49073), c)

def gb.n1152(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1153(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1154(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1152(U32.is_lt(c, 49101), c)
    case False{}:
      gb.n1153(U32.is_lt(c, 49129), c)

def gb.n1155(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1151(U32.is_lt(c, 49072), c)
    case False{}:
      gb.n1154(U32.is_lt(c, 49128), c)

def gb.n1156(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1157(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1158(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1156(U32.is_lt(c, 49157), c)
    case False{}:
      gb.n1157(U32.is_lt(c, 49185), c)

def gb.n1159(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1160(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1161(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1160(U32.is_lt(c, 49268), c)

def gb.n1162(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1159(U32.is_lt(c, 49213), c)
    case False{}:
      gb.n1161(U32.is_lt(c, 49241), c)

def gb.n1163(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1158(U32.is_lt(c, 49184), c)
    case False{}:
      gb.n1162(U32.is_lt(c, 49240), c)

def gb.n1164(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1155(U32.is_lt(c, 49100), c)
    case False{}:
      gb.n1163(U32.is_lt(c, 49212), c)

def gb.n1165(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1166(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1167(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1165(U32.is_lt(c, 49296), c)
    case False{}:
      gb.n1166(U32.is_lt(c, 49324), c)

def gb.n1168(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1169(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1170(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1168(U32.is_lt(c, 49352), c)
    case False{}:
      gb.n1169(U32.is_lt(c, 49380), c)

def gb.n1171(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1167(U32.is_lt(c, 49297), c)
    case False{}:
      gb.n1170(U32.is_lt(c, 49353), c)

def gb.n1172(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1173(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1174(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1172(U32.is_lt(c, 49408), c)
    case False{}:
      gb.n1173(U32.is_lt(c, 49436), c)

def gb.n1175(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1176(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1177(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1176(U32.is_lt(c, 49493), c)

def gb.n1178(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1175(U32.is_lt(c, 49464), c)
    case False{}:
      gb.n1177(U32.is_lt(c, 49492), c)

def gb.n1179(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1174(U32.is_lt(c, 49409), c)
    case False{}:
      gb.n1178(U32.is_lt(c, 49465), c)

def gb.n1180(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1171(U32.is_lt(c, 49325), c)
    case False{}:
      gb.n1179(U32.is_lt(c, 49437), c)

def gb.n1181(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1164(U32.is_lt(c, 49156), c)
    case False{}:
      gb.n1180(U32.is_lt(c, 49381), c)

def gb.n1182(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1183(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1184(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1182(U32.is_lt(c, 49521), c)
    case False{}:
      gb.n1183(U32.is_lt(c, 49549), c)

def gb.n1185(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1186(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1187(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1185(U32.is_lt(c, 49577), c)
    case False{}:
      gb.n1186(U32.is_lt(c, 49605), c)

def gb.n1188(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1184(U32.is_lt(c, 49548), c)
    case False{}:
      gb.n1187(U32.is_lt(c, 49604), c)

def gb.n1189(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1190(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1191(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1189(U32.is_lt(c, 49633), c)
    case False{}:
      gb.n1190(U32.is_lt(c, 49661), c)

def gb.n1192(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1193(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1194(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1193(U32.is_lt(c, 49744), c)

def gb.n1195(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1192(U32.is_lt(c, 49689), c)
    case False{}:
      gb.n1194(U32.is_lt(c, 49717), c)

def gb.n1196(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1191(U32.is_lt(c, 49660), c)
    case False{}:
      gb.n1195(U32.is_lt(c, 49716), c)

def gb.n1197(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1188(U32.is_lt(c, 49576), c)
    case False{}:
      gb.n1196(U32.is_lt(c, 49688), c)

def gb.n1198(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1199(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1200(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1198(U32.is_lt(c, 49772), c)
    case False{}:
      gb.n1199(U32.is_lt(c, 49800), c)

def gb.n1201(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1202(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1203(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1201(U32.is_lt(c, 49828), c)
    case False{}:
      gb.n1202(U32.is_lt(c, 49856), c)

def gb.n1204(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1200(U32.is_lt(c, 49773), c)
    case False{}:
      gb.n1203(U32.is_lt(c, 49829), c)

def gb.n1205(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1206(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1207(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1205(U32.is_lt(c, 49884), c)
    case False{}:
      gb.n1206(U32.is_lt(c, 49912), c)

def gb.n1208(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1209(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1210(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1209(U32.is_lt(c, 49969), c)

def gb.n1211(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1208(U32.is_lt(c, 49940), c)
    case False{}:
      gb.n1210(U32.is_lt(c, 49968), c)

def gb.n1212(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1207(U32.is_lt(c, 49885), c)
    case False{}:
      gb.n1211(U32.is_lt(c, 49941), c)

def gb.n1213(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1204(U32.is_lt(c, 49801), c)
    case False{}:
      gb.n1212(U32.is_lt(c, 49913), c)

def gb.n1214(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1197(U32.is_lt(c, 49632), c)
    case False{}:
      gb.n1213(U32.is_lt(c, 49857), c)

def gb.n1215(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1181(U32.is_lt(c, 49269), c)
    case False{}:
      gb.n1214(U32.is_lt(c, 49745), c)

def gb.n1216(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1148(U32.is_lt(c, 48568), c)
    case False{}:
      gb.n1215(U32.is_lt(c, 49520), c)

def gb.n1217(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1218(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1219(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1217(U32.is_lt(c, 49997), c)
    case False{}:
      gb.n1218(U32.is_lt(c, 50025), c)

def gb.n1220(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1221(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1222(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1220(U32.is_lt(c, 50053), c)
    case False{}:
      gb.n1221(U32.is_lt(c, 50081), c)

def gb.n1223(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1219(U32.is_lt(c, 50024), c)
    case False{}:
      gb.n1222(U32.is_lt(c, 50080), c)

def gb.n1224(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1225(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1226(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1224(U32.is_lt(c, 50109), c)
    case False{}:
      gb.n1225(U32.is_lt(c, 50137), c)

def gb.n1227(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1228(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1229(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1228(U32.is_lt(c, 50220), c)

def gb.n1230(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1227(U32.is_lt(c, 50165), c)
    case False{}:
      gb.n1229(U32.is_lt(c, 50193), c)

def gb.n1231(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1226(U32.is_lt(c, 50136), c)
    case False{}:
      gb.n1230(U32.is_lt(c, 50192), c)

def gb.n1232(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1223(U32.is_lt(c, 50052), c)
    case False{}:
      gb.n1231(U32.is_lt(c, 50164), c)

def gb.n1233(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1234(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1235(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1233(U32.is_lt(c, 50248), c)
    case False{}:
      gb.n1234(U32.is_lt(c, 50276), c)

def gb.n1236(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1237(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1238(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1236(U32.is_lt(c, 50304), c)
    case False{}:
      gb.n1237(U32.is_lt(c, 50332), c)

def gb.n1239(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1235(U32.is_lt(c, 50249), c)
    case False{}:
      gb.n1238(U32.is_lt(c, 50305), c)

def gb.n1240(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1241(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1242(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1240(U32.is_lt(c, 50360), c)
    case False{}:
      gb.n1241(U32.is_lt(c, 50388), c)

def gb.n1243(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1244(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1245(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1244(U32.is_lt(c, 50445), c)

def gb.n1246(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1243(U32.is_lt(c, 50416), c)
    case False{}:
      gb.n1245(U32.is_lt(c, 50444), c)

def gb.n1247(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1242(U32.is_lt(c, 50361), c)
    case False{}:
      gb.n1246(U32.is_lt(c, 50417), c)

def gb.n1248(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1239(U32.is_lt(c, 50277), c)
    case False{}:
      gb.n1247(U32.is_lt(c, 50389), c)

def gb.n1249(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1232(U32.is_lt(c, 50108), c)
    case False{}:
      gb.n1248(U32.is_lt(c, 50333), c)

def gb.n1250(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1251(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1252(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1250(U32.is_lt(c, 50473), c)
    case False{}:
      gb.n1251(U32.is_lt(c, 50501), c)

def gb.n1253(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1254(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1255(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1253(U32.is_lt(c, 50529), c)
    case False{}:
      gb.n1254(U32.is_lt(c, 50557), c)

def gb.n1256(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1252(U32.is_lt(c, 50500), c)
    case False{}:
      gb.n1255(U32.is_lt(c, 50556), c)

def gb.n1257(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1258(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1259(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1257(U32.is_lt(c, 50585), c)
    case False{}:
      gb.n1258(U32.is_lt(c, 50613), c)

def gb.n1260(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1261(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1262(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1261(U32.is_lt(c, 50696), c)

def gb.n1263(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1260(U32.is_lt(c, 50641), c)
    case False{}:
      gb.n1262(U32.is_lt(c, 50669), c)

def gb.n1264(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1259(U32.is_lt(c, 50612), c)
    case False{}:
      gb.n1263(U32.is_lt(c, 50668), c)

def gb.n1265(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1256(U32.is_lt(c, 50528), c)
    case False{}:
      gb.n1264(U32.is_lt(c, 50640), c)

def gb.n1266(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1267(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1268(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1266(U32.is_lt(c, 50724), c)
    case False{}:
      gb.n1267(U32.is_lt(c, 50752), c)

def gb.n1269(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1270(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1271(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1269(U32.is_lt(c, 50780), c)
    case False{}:
      gb.n1270(U32.is_lt(c, 50808), c)

def gb.n1272(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1268(U32.is_lt(c, 50725), c)
    case False{}:
      gb.n1271(U32.is_lt(c, 50781), c)

def gb.n1273(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1274(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1275(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1273(U32.is_lt(c, 50836), c)
    case False{}:
      gb.n1274(U32.is_lt(c, 50864), c)

def gb.n1276(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1277(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1278(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1277(U32.is_lt(c, 50921), c)

def gb.n1279(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1276(U32.is_lt(c, 50892), c)
    case False{}:
      gb.n1278(U32.is_lt(c, 50920), c)

def gb.n1280(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1275(U32.is_lt(c, 50837), c)
    case False{}:
      gb.n1279(U32.is_lt(c, 50893), c)

def gb.n1281(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1272(U32.is_lt(c, 50753), c)
    case False{}:
      gb.n1280(U32.is_lt(c, 50865), c)

def gb.n1282(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1265(U32.is_lt(c, 50584), c)
    case False{}:
      gb.n1281(U32.is_lt(c, 50809), c)

def gb.n1283(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1249(U32.is_lt(c, 50221), c)
    case False{}:
      gb.n1282(U32.is_lt(c, 50697), c)

def gb.n1284(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1285(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1286(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1284(U32.is_lt(c, 50949), c)
    case False{}:
      gb.n1285(U32.is_lt(c, 50977), c)

def gb.n1287(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1288(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1289(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1287(U32.is_lt(c, 51005), c)
    case False{}:
      gb.n1288(U32.is_lt(c, 51033), c)

def gb.n1290(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1286(U32.is_lt(c, 50976), c)
    case False{}:
      gb.n1289(U32.is_lt(c, 51032), c)

def gb.n1291(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1292(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1293(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1291(U32.is_lt(c, 51061), c)
    case False{}:
      gb.n1292(U32.is_lt(c, 51089), c)

def gb.n1294(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1295(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1296(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1295(U32.is_lt(c, 51172), c)

def gb.n1297(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1294(U32.is_lt(c, 51117), c)
    case False{}:
      gb.n1296(U32.is_lt(c, 51145), c)

def gb.n1298(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1293(U32.is_lt(c, 51088), c)
    case False{}:
      gb.n1297(U32.is_lt(c, 51144), c)

def gb.n1299(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1290(U32.is_lt(c, 51004), c)
    case False{}:
      gb.n1298(U32.is_lt(c, 51116), c)

def gb.n1300(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1301(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1302(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1300(U32.is_lt(c, 51200), c)
    case False{}:
      gb.n1301(U32.is_lt(c, 51228), c)

def gb.n1303(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1304(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1305(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1303(U32.is_lt(c, 51256), c)
    case False{}:
      gb.n1304(U32.is_lt(c, 51284), c)

def gb.n1306(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1302(U32.is_lt(c, 51201), c)
    case False{}:
      gb.n1305(U32.is_lt(c, 51257), c)

def gb.n1307(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1308(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1309(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1307(U32.is_lt(c, 51312), c)
    case False{}:
      gb.n1308(U32.is_lt(c, 51340), c)

def gb.n1310(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1311(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1312(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1311(U32.is_lt(c, 51397), c)

def gb.n1313(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1310(U32.is_lt(c, 51368), c)
    case False{}:
      gb.n1312(U32.is_lt(c, 51396), c)

def gb.n1314(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1309(U32.is_lt(c, 51313), c)
    case False{}:
      gb.n1313(U32.is_lt(c, 51369), c)

def gb.n1315(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1306(U32.is_lt(c, 51229), c)
    case False{}:
      gb.n1314(U32.is_lt(c, 51341), c)

def gb.n1316(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1299(U32.is_lt(c, 51060), c)
    case False{}:
      gb.n1315(U32.is_lt(c, 51285), c)

def gb.n1317(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1318(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1319(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1317(U32.is_lt(c, 51425), c)
    case False{}:
      gb.n1318(U32.is_lt(c, 51453), c)

def gb.n1320(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1321(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1322(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1320(U32.is_lt(c, 51481), c)
    case False{}:
      gb.n1321(U32.is_lt(c, 51509), c)

def gb.n1323(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1319(U32.is_lt(c, 51452), c)
    case False{}:
      gb.n1322(U32.is_lt(c, 51508), c)

def gb.n1324(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1325(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1326(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1324(U32.is_lt(c, 51537), c)
    case False{}:
      gb.n1325(U32.is_lt(c, 51565), c)

def gb.n1327(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1328(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1329(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1328(U32.is_lt(c, 51648), c)

def gb.n1330(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1327(U32.is_lt(c, 51593), c)
    case False{}:
      gb.n1329(U32.is_lt(c, 51621), c)

def gb.n1331(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1326(U32.is_lt(c, 51564), c)
    case False{}:
      gb.n1330(U32.is_lt(c, 51620), c)

def gb.n1332(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1323(U32.is_lt(c, 51480), c)
    case False{}:
      gb.n1331(U32.is_lt(c, 51592), c)

def gb.n1333(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1334(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1335(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1333(U32.is_lt(c, 51676), c)
    case False{}:
      gb.n1334(U32.is_lt(c, 51704), c)

def gb.n1336(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1337(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1338(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1336(U32.is_lt(c, 51732), c)
    case False{}:
      gb.n1337(U32.is_lt(c, 51760), c)

def gb.n1339(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1335(U32.is_lt(c, 51677), c)
    case False{}:
      gb.n1338(U32.is_lt(c, 51733), c)

def gb.n1340(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1341(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1342(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1340(U32.is_lt(c, 51788), c)
    case False{}:
      gb.n1341(U32.is_lt(c, 51816), c)

def gb.n1343(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1344(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1345(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1344(U32.is_lt(c, 51873), c)

def gb.n1346(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1343(U32.is_lt(c, 51844), c)
    case False{}:
      gb.n1345(U32.is_lt(c, 51872), c)

def gb.n1347(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1342(U32.is_lt(c, 51789), c)
    case False{}:
      gb.n1346(U32.is_lt(c, 51845), c)

def gb.n1348(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1339(U32.is_lt(c, 51705), c)
    case False{}:
      gb.n1347(U32.is_lt(c, 51817), c)

def gb.n1349(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1332(U32.is_lt(c, 51536), c)
    case False{}:
      gb.n1348(U32.is_lt(c, 51761), c)

def gb.n1350(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1316(U32.is_lt(c, 51173), c)
    case False{}:
      gb.n1349(U32.is_lt(c, 51649), c)

def gb.n1351(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1283(U32.is_lt(c, 50472), c)
    case False{}:
      gb.n1350(U32.is_lt(c, 51424), c)

def gb.n1352(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1216(U32.is_lt(c, 49044), c)
    case False{}:
      gb.n1351(U32.is_lt(c, 50948), c)

def gb.n1353(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1354(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1355(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1353(U32.is_lt(c, 51901), c)
    case False{}:
      gb.n1354(U32.is_lt(c, 51929), c)

def gb.n1356(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1357(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1358(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1356(U32.is_lt(c, 51957), c)
    case False{}:
      gb.n1357(U32.is_lt(c, 51985), c)

def gb.n1359(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1355(U32.is_lt(c, 51928), c)
    case False{}:
      gb.n1358(U32.is_lt(c, 51984), c)

def gb.n1360(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1361(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1362(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1360(U32.is_lt(c, 52013), c)
    case False{}:
      gb.n1361(U32.is_lt(c, 52041), c)

def gb.n1363(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1364(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1365(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1363(U32.is_lt(c, 52069), c)
    case False{}:
      gb.n1364(U32.is_lt(c, 52097), c)

def gb.n1366(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1362(U32.is_lt(c, 52040), c)
    case False{}:
      gb.n1365(U32.is_lt(c, 52096), c)

def gb.n1367(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1359(U32.is_lt(c, 51956), c)
    case False{}:
      gb.n1366(U32.is_lt(c, 52068), c)

def gb.n1368(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1369(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1370(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1368(U32.is_lt(c, 52125), c)
    case False{}:
      gb.n1369(U32.is_lt(c, 52153), c)

def gb.n1371(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1372(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1373(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1371(U32.is_lt(c, 52181), c)
    case False{}:
      gb.n1372(U32.is_lt(c, 52209), c)

def gb.n1374(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1370(U32.is_lt(c, 52152), c)
    case False{}:
      gb.n1373(U32.is_lt(c, 52208), c)

def gb.n1375(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1376(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1377(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1375(U32.is_lt(c, 52237), c)
    case False{}:
      gb.n1376(U32.is_lt(c, 52265), c)

def gb.n1378(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1379(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1380(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1379(U32.is_lt(c, 52348), c)

def gb.n1381(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1378(U32.is_lt(c, 52293), c)
    case False{}:
      gb.n1380(U32.is_lt(c, 52321), c)

def gb.n1382(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1377(U32.is_lt(c, 52264), c)
    case False{}:
      gb.n1381(U32.is_lt(c, 52320), c)

def gb.n1383(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1374(U32.is_lt(c, 52180), c)
    case False{}:
      gb.n1382(U32.is_lt(c, 52292), c)

def gb.n1384(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1367(U32.is_lt(c, 52012), c)
    case False{}:
      gb.n1383(U32.is_lt(c, 52236), c)

def gb.n1385(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1386(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1387(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1385(U32.is_lt(c, 52376), c)
    case False{}:
      gb.n1386(U32.is_lt(c, 52404), c)

def gb.n1388(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1389(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1390(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1388(U32.is_lt(c, 52432), c)
    case False{}:
      gb.n1389(U32.is_lt(c, 52460), c)

def gb.n1391(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1387(U32.is_lt(c, 52377), c)
    case False{}:
      gb.n1390(U32.is_lt(c, 52433), c)

def gb.n1392(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1393(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1394(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1392(U32.is_lt(c, 52488), c)
    case False{}:
      gb.n1393(U32.is_lt(c, 52516), c)

def gb.n1395(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1396(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1397(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1396(U32.is_lt(c, 52573), c)

def gb.n1398(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1395(U32.is_lt(c, 52544), c)
    case False{}:
      gb.n1397(U32.is_lt(c, 52572), c)

def gb.n1399(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1394(U32.is_lt(c, 52489), c)
    case False{}:
      gb.n1398(U32.is_lt(c, 52545), c)

def gb.n1400(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1391(U32.is_lt(c, 52405), c)
    case False{}:
      gb.n1399(U32.is_lt(c, 52517), c)

def gb.n1401(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1402(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1403(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1401(U32.is_lt(c, 52601), c)
    case False{}:
      gb.n1402(U32.is_lt(c, 52629), c)

def gb.n1404(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1405(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1406(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1404(U32.is_lt(c, 52657), c)
    case False{}:
      gb.n1405(U32.is_lt(c, 52685), c)

def gb.n1407(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1403(U32.is_lt(c, 52628), c)
    case False{}:
      gb.n1406(U32.is_lt(c, 52684), c)

def gb.n1408(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1409(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1410(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1408(U32.is_lt(c, 52713), c)
    case False{}:
      gb.n1409(U32.is_lt(c, 52741), c)

def gb.n1411(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1412(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1413(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1412(U32.is_lt(c, 52824), c)

def gb.n1414(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1411(U32.is_lt(c, 52769), c)
    case False{}:
      gb.n1413(U32.is_lt(c, 52797), c)

def gb.n1415(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1410(U32.is_lt(c, 52740), c)
    case False{}:
      gb.n1414(U32.is_lt(c, 52796), c)

def gb.n1416(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1407(U32.is_lt(c, 52656), c)
    case False{}:
      gb.n1415(U32.is_lt(c, 52768), c)

def gb.n1417(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1400(U32.is_lt(c, 52461), c)
    case False{}:
      gb.n1416(U32.is_lt(c, 52712), c)

def gb.n1418(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1384(U32.is_lt(c, 52124), c)
    case False{}:
      gb.n1417(U32.is_lt(c, 52600), c)

def gb.n1419(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1420(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1421(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1419(U32.is_lt(c, 52852), c)
    case False{}:
      gb.n1420(U32.is_lt(c, 52880), c)

def gb.n1422(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1423(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1424(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1422(U32.is_lt(c, 52908), c)
    case False{}:
      gb.n1423(U32.is_lt(c, 52936), c)

def gb.n1425(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1421(U32.is_lt(c, 52853), c)
    case False{}:
      gb.n1424(U32.is_lt(c, 52909), c)

def gb.n1426(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1427(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1428(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1426(U32.is_lt(c, 52964), c)
    case False{}:
      gb.n1427(U32.is_lt(c, 52992), c)

def gb.n1429(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1430(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1431(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1430(U32.is_lt(c, 53049), c)

def gb.n1432(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1429(U32.is_lt(c, 53020), c)
    case False{}:
      gb.n1431(U32.is_lt(c, 53048), c)

def gb.n1433(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1428(U32.is_lt(c, 52965), c)
    case False{}:
      gb.n1432(U32.is_lt(c, 53021), c)

def gb.n1434(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1425(U32.is_lt(c, 52881), c)
    case False{}:
      gb.n1433(U32.is_lt(c, 52993), c)

def gb.n1435(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1436(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1437(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1435(U32.is_lt(c, 53077), c)
    case False{}:
      gb.n1436(U32.is_lt(c, 53105), c)

def gb.n1438(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1439(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1440(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1438(U32.is_lt(c, 53133), c)
    case False{}:
      gb.n1439(U32.is_lt(c, 53161), c)

def gb.n1441(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1437(U32.is_lt(c, 53104), c)
    case False{}:
      gb.n1440(U32.is_lt(c, 53160), c)

def gb.n1442(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1443(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1444(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1442(U32.is_lt(c, 53189), c)
    case False{}:
      gb.n1443(U32.is_lt(c, 53217), c)

def gb.n1445(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1446(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1447(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1446(U32.is_lt(c, 53300), c)

def gb.n1448(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1445(U32.is_lt(c, 53245), c)
    case False{}:
      gb.n1447(U32.is_lt(c, 53273), c)

def gb.n1449(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1444(U32.is_lt(c, 53216), c)
    case False{}:
      gb.n1448(U32.is_lt(c, 53272), c)

def gb.n1450(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1441(U32.is_lt(c, 53132), c)
    case False{}:
      gb.n1449(U32.is_lt(c, 53244), c)

def gb.n1451(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1434(U32.is_lt(c, 52937), c)
    case False{}:
      gb.n1450(U32.is_lt(c, 53188), c)

def gb.n1452(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1453(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1454(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1452(U32.is_lt(c, 53328), c)
    case False{}:
      gb.n1453(U32.is_lt(c, 53356), c)

def gb.n1455(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1456(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1457(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1455(U32.is_lt(c, 53384), c)
    case False{}:
      gb.n1456(U32.is_lt(c, 53412), c)

def gb.n1458(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1454(U32.is_lt(c, 53329), c)
    case False{}:
      gb.n1457(U32.is_lt(c, 53385), c)

def gb.n1459(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1460(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1461(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1459(U32.is_lt(c, 53440), c)
    case False{}:
      gb.n1460(U32.is_lt(c, 53468), c)

def gb.n1462(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1463(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1464(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1463(U32.is_lt(c, 53525), c)

def gb.n1465(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1462(U32.is_lt(c, 53496), c)
    case False{}:
      gb.n1464(U32.is_lt(c, 53524), c)

def gb.n1466(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1461(U32.is_lt(c, 53441), c)
    case False{}:
      gb.n1465(U32.is_lt(c, 53497), c)

def gb.n1467(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1458(U32.is_lt(c, 53357), c)
    case False{}:
      gb.n1466(U32.is_lt(c, 53469), c)

def gb.n1468(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1469(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1470(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1468(U32.is_lt(c, 53553), c)
    case False{}:
      gb.n1469(U32.is_lt(c, 53581), c)

def gb.n1471(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1472(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1473(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1471(U32.is_lt(c, 53609), c)
    case False{}:
      gb.n1472(U32.is_lt(c, 53637), c)

def gb.n1474(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1470(U32.is_lt(c, 53580), c)
    case False{}:
      gb.n1473(U32.is_lt(c, 53636), c)

def gb.n1475(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1476(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1477(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1475(U32.is_lt(c, 53665), c)
    case False{}:
      gb.n1476(U32.is_lt(c, 53693), c)

def gb.n1478(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1479(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1480(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1479(U32.is_lt(c, 53776), c)

def gb.n1481(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1478(U32.is_lt(c, 53721), c)
    case False{}:
      gb.n1480(U32.is_lt(c, 53749), c)

def gb.n1482(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1477(U32.is_lt(c, 53692), c)
    case False{}:
      gb.n1481(U32.is_lt(c, 53748), c)

def gb.n1483(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1474(U32.is_lt(c, 53608), c)
    case False{}:
      gb.n1482(U32.is_lt(c, 53720), c)

def gb.n1484(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1467(U32.is_lt(c, 53413), c)
    case False{}:
      gb.n1483(U32.is_lt(c, 53664), c)

def gb.n1485(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1451(U32.is_lt(c, 53076), c)
    case False{}:
      gb.n1484(U32.is_lt(c, 53552), c)

def gb.n1486(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1418(U32.is_lt(c, 52349), c)
    case False{}:
      gb.n1485(U32.is_lt(c, 53301), c)

def gb.n1487(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1488(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1489(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1487(U32.is_lt(c, 53804), c)
    case False{}:
      gb.n1488(U32.is_lt(c, 53832), c)

def gb.n1490(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1491(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1492(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1490(U32.is_lt(c, 53860), c)
    case False{}:
      gb.n1491(U32.is_lt(c, 53888), c)

def gb.n1493(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1489(U32.is_lt(c, 53805), c)
    case False{}:
      gb.n1492(U32.is_lt(c, 53861), c)

def gb.n1494(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1495(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1496(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1494(U32.is_lt(c, 53916), c)
    case False{}:
      gb.n1495(U32.is_lt(c, 53944), c)

def gb.n1497(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1498(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1499(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1498(U32.is_lt(c, 54001), c)

def gb.n1500(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1497(U32.is_lt(c, 53972), c)
    case False{}:
      gb.n1499(U32.is_lt(c, 54000), c)

def gb.n1501(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1496(U32.is_lt(c, 53917), c)
    case False{}:
      gb.n1500(U32.is_lt(c, 53973), c)

def gb.n1502(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1493(U32.is_lt(c, 53833), c)
    case False{}:
      gb.n1501(U32.is_lt(c, 53945), c)

def gb.n1503(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1504(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1505(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1503(U32.is_lt(c, 54029), c)
    case False{}:
      gb.n1504(U32.is_lt(c, 54057), c)

def gb.n1506(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1507(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1508(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1506(U32.is_lt(c, 54085), c)
    case False{}:
      gb.n1507(U32.is_lt(c, 54113), c)

def gb.n1509(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1505(U32.is_lt(c, 54056), c)
    case False{}:
      gb.n1508(U32.is_lt(c, 54112), c)

def gb.n1510(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1511(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1512(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1510(U32.is_lt(c, 54141), c)
    case False{}:
      gb.n1511(U32.is_lt(c, 54169), c)

def gb.n1513(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1514(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1515(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1514(U32.is_lt(c, 54252), c)

def gb.n1516(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1513(U32.is_lt(c, 54197), c)
    case False{}:
      gb.n1515(U32.is_lt(c, 54225), c)

def gb.n1517(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1512(U32.is_lt(c, 54168), c)
    case False{}:
      gb.n1516(U32.is_lt(c, 54224), c)

def gb.n1518(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1509(U32.is_lt(c, 54084), c)
    case False{}:
      gb.n1517(U32.is_lt(c, 54196), c)

def gb.n1519(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1502(U32.is_lt(c, 53889), c)
    case False{}:
      gb.n1518(U32.is_lt(c, 54140), c)

def gb.n1520(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1521(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1522(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1520(U32.is_lt(c, 54280), c)
    case False{}:
      gb.n1521(U32.is_lt(c, 54308), c)

def gb.n1523(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1524(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1525(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1523(U32.is_lt(c, 54336), c)
    case False{}:
      gb.n1524(U32.is_lt(c, 54364), c)

def gb.n1526(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1522(U32.is_lt(c, 54281), c)
    case False{}:
      gb.n1525(U32.is_lt(c, 54337), c)

def gb.n1527(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1528(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1529(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1527(U32.is_lt(c, 54392), c)
    case False{}:
      gb.n1528(U32.is_lt(c, 54420), c)

def gb.n1530(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1531(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1532(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1531(U32.is_lt(c, 54477), c)

def gb.n1533(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1530(U32.is_lt(c, 54448), c)
    case False{}:
      gb.n1532(U32.is_lt(c, 54476), c)

def gb.n1534(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1529(U32.is_lt(c, 54393), c)
    case False{}:
      gb.n1533(U32.is_lt(c, 54449), c)

def gb.n1535(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1526(U32.is_lt(c, 54309), c)
    case False{}:
      gb.n1534(U32.is_lt(c, 54421), c)

def gb.n1536(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1537(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1538(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1536(U32.is_lt(c, 54505), c)
    case False{}:
      gb.n1537(U32.is_lt(c, 54533), c)

def gb.n1539(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1540(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1541(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1539(U32.is_lt(c, 54561), c)
    case False{}:
      gb.n1540(U32.is_lt(c, 54589), c)

def gb.n1542(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1538(U32.is_lt(c, 54532), c)
    case False{}:
      gb.n1541(U32.is_lt(c, 54588), c)

def gb.n1543(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1544(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1545(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1543(U32.is_lt(c, 54617), c)
    case False{}:
      gb.n1544(U32.is_lt(c, 54645), c)

def gb.n1546(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1547(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1548(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1547(U32.is_lt(c, 54728), c)

def gb.n1549(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1546(U32.is_lt(c, 54673), c)
    case False{}:
      gb.n1548(U32.is_lt(c, 54701), c)

def gb.n1550(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1545(U32.is_lt(c, 54644), c)
    case False{}:
      gb.n1549(U32.is_lt(c, 54700), c)

def gb.n1551(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1542(U32.is_lt(c, 54560), c)
    case False{}:
      gb.n1550(U32.is_lt(c, 54672), c)

def gb.n1552(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1535(U32.is_lt(c, 54365), c)
    case False{}:
      gb.n1551(U32.is_lt(c, 54616), c)

def gb.n1553(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1519(U32.is_lt(c, 54028), c)
    case False{}:
      gb.n1552(U32.is_lt(c, 54504), c)

def gb.n1554(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1555(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1556(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1554(U32.is_lt(c, 54756), c)
    case False{}:
      gb.n1555(U32.is_lt(c, 54784), c)

def gb.n1557(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1558(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1559(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1557(U32.is_lt(c, 54812), c)
    case False{}:
      gb.n1558(U32.is_lt(c, 54840), c)

def gb.n1560(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1556(U32.is_lt(c, 54757), c)
    case False{}:
      gb.n1559(U32.is_lt(c, 54813), c)

def gb.n1561(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1562(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1563(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1561(U32.is_lt(c, 54868), c)
    case False{}:
      gb.n1562(U32.is_lt(c, 54896), c)

def gb.n1564(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      12

def gb.n1565(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1566(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      gb.n1565(U32.is_lt(c, 54953), c)

def gb.n1567(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1564(U32.is_lt(c, 54924), c)
    case False{}:
      gb.n1566(U32.is_lt(c, 54952), c)

def gb.n1568(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1563(U32.is_lt(c, 54869), c)
    case False{}:
      gb.n1567(U32.is_lt(c, 54925), c)

def gb.n1569(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1560(U32.is_lt(c, 54785), c)
    case False{}:
      gb.n1568(U32.is_lt(c, 54897), c)

def gb.n1570(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1571(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1572(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1570(U32.is_lt(c, 54981), c)
    case False{}:
      gb.n1571(U32.is_lt(c, 55009), c)

def gb.n1573(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1574(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1575(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1573(U32.is_lt(c, 55037), c)
    case False{}:
      gb.n1574(U32.is_lt(c, 55065), c)

def gb.n1576(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1572(U32.is_lt(c, 55008), c)
    case False{}:
      gb.n1575(U32.is_lt(c, 55064), c)

def gb.n1577(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1578(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1579(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1577(U32.is_lt(c, 55093), c)
    case False{}:
      gb.n1578(U32.is_lt(c, 55121), c)

def gb.n1580(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      13

def gb.n1581(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      13
    case False{}:
      0

def gb.n1582(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      12
    case False{}:
      gb.n1581(U32.is_lt(c, 55204), c)

def gb.n1583(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1580(U32.is_lt(c, 55149), c)
    case False{}:
      gb.n1582(U32.is_lt(c, 55177), c)

def gb.n1584(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1579(U32.is_lt(c, 55120), c)
    case False{}:
      gb.n1583(U32.is_lt(c, 55176), c)

def gb.n1585(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1576(U32.is_lt(c, 55036), c)
    case False{}:
      gb.n1584(U32.is_lt(c, 55148), c)

def gb.n1586(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1569(U32.is_lt(c, 54841), c)
    case False{}:
      gb.n1585(U32.is_lt(c, 55092), c)

def gb.n1587(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      10
    case False{}:
      0

def gb.n1588(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      11
    case False{}:
      0

def gb.n1589(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1587(U32.is_lt(c, 55239), c)
    case False{}:
      gb.n1588(U32.is_lt(c, 55292), c)

def gb.n1590(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1591(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1592(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1590(U32.is_lt(c, 64287), c)
    case False{}:
      gb.n1591(U32.is_lt(c, 65040), c)

def gb.n1593(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1589(U32.is_lt(c, 55243), c)
    case False{}:
      gb.n1592(U32.is_lt(c, 65024), c)

def gb.n1594(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1595(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n1596(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1594(U32.is_lt(c, 65072), c)
    case False{}:
      gb.n1595(U32.is_lt(c, 65280), c)

def gb.n1597(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1598(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1599(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      gb.n1598(U32.is_lt(c, 66045), c)

def gb.n1600(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1597(U32.is_lt(c, 65440), c)
    case False{}:
      gb.n1599(U32.is_lt(c, 65532), c)

def gb.n1601(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1596(U32.is_lt(c, 65279), c)
    case False{}:
      gb.n1600(U32.is_lt(c, 65520), c)

def gb.n1602(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1593(U32.is_lt(c, 64286), c)
    case False{}:
      gb.n1601(U32.is_lt(c, 65438), c)

def gb.n1603(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1604(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1605(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1603(U32.is_lt(c, 66272), c)
    case False{}:
      gb.n1604(U32.is_lt(c, 66422), c)

def gb.n1606(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n1607(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1608(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1606(U32.is_lt(c, 68096), c)
    case False{}:
      gb.n1607(U32.is_lt(c, 68100), c)

def gb.n1609(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1605(U32.is_lt(c, 66273), c)
    case False{}:
      gb.n1608(U32.is_lt(c, 68097), c)

def gb.n1610(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1611(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n1612(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1610(U32.is_lt(c, 68103), c)
    case False{}:
      gb.n1611(U32.is_lt(c, 68112), c)

def gb.n1613(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n1614(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1615(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1614(U32.is_lt(c, 68150), c)

def gb.n1616(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1613(U32.is_lt(c, 68117), c)
    case False{}:
      gb.n1615(U32.is_lt(c, 68121), c)

def gb.n1617(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1612(U32.is_lt(c, 68108), c)
    case False{}:
      gb.n1616(U32.is_lt(c, 68120), c)

def gb.n1618(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1609(U32.is_lt(c, 66427), c)
    case False{}:
      gb.n1617(U32.is_lt(c, 68116), c)

def gb.n1619(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1602(U32.is_lt(c, 65056), c)
    case False{}:
      gb.n1618(U32.is_lt(c, 68101), c)

def gb.n1620(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1586(U32.is_lt(c, 54980), c)
    case False{}:
      gb.n1619(U32.is_lt(c, 66046), c)

def gb.n1621(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1553(U32.is_lt(c, 54253), c)
    case False{}:
      gb.n1620(U32.is_lt(c, 55216), c)

def gb.n1622(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1486(U32.is_lt(c, 52825), c)
    case False{}:
      gb.n1621(U32.is_lt(c, 54729), c)

def gb.n1623(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1352(U32.is_lt(c, 49996), c)
    case False{}:
      gb.n1622(U32.is_lt(c, 53777), c)

def gb.n1624(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1625(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      0

def gb.n1626(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1624(U32.is_lt(c, 68155), c)
    case False{}:
      gb.n1625(U32.is_lt(c, 68160), c)

def gb.n1627(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1628(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1629(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1627(U32.is_lt(c, 68327), c)
    case False{}:
      gb.n1628(U32.is_lt(c, 68904), c)

def gb.n1630(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1626(U32.is_lt(c, 68159), c)
    case False{}:
      gb.n1629(U32.is_lt(c, 68900), c)

def gb.n1631(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1632(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1633(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1631(U32.is_lt(c, 68974), c)
    case False{}:
      gb.n1632(U32.is_lt(c, 69293), c)

def gb.n1634(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1635(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1636(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1634(U32.is_lt(c, 69376), c)
    case False{}:
      gb.n1635(U32.is_lt(c, 69457), c)

def gb.n1637(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1633(U32.is_lt(c, 69291), c)
    case False{}:
      gb.n1636(U32.is_lt(c, 69446), c)

def gb.n1638(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1630(U32.is_lt(c, 68325), c)
    case False{}:
      gb.n1637(U32.is_lt(c, 69370), c)

def gb.n1639(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1640(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1641(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1639(U32.is_lt(c, 69510), c)
    case False{}:
      gb.n1640(U32.is_lt(c, 69633), c)

def gb.n1642(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1643(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1644(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1642(U32.is_lt(c, 69635), c)
    case False{}:
      gb.n1643(U32.is_lt(c, 69703), c)

def gb.n1645(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1641(U32.is_lt(c, 69632), c)
    case False{}:
      gb.n1644(U32.is_lt(c, 69688), c)

def gb.n1646(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1647(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1648(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1646(U32.is_lt(c, 69745), c)
    case False{}:
      gb.n1647(U32.is_lt(c, 69749), c)

def gb.n1649(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1650(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1651(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1650(U32.is_lt(c, 69811), c)

def gb.n1652(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1649(U32.is_lt(c, 69762), c)
    case False{}:
      gb.n1651(U32.is_lt(c, 69808), c)

def gb.n1653(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1648(U32.is_lt(c, 69747), c)
    case False{}:
      gb.n1652(U32.is_lt(c, 69763), c)

def gb.n1654(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1645(U32.is_lt(c, 69634), c)
    case False{}:
      gb.n1653(U32.is_lt(c, 69759), c)

def gb.n1655(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1638(U32.is_lt(c, 68969), c)
    case False{}:
      gb.n1654(U32.is_lt(c, 69744), c)

def gb.n1656(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1657(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def gb.n1658(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1656(U32.is_lt(c, 69817), c)
    case False{}:
      gb.n1657(U32.is_lt(c, 69821), c)

def gb.n1659(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1660(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      7

def gb.n1661(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1659(U32.is_lt(c, 69826), c)
    case False{}:
      gb.n1660(U32.is_lt(c, 69837), c)

def gb.n1662(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1658(U32.is_lt(c, 69819), c)
    case False{}:
      gb.n1661(U32.is_lt(c, 69827), c)

def gb.n1663(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1664(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      68

def gb.n1665(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1663(U32.is_lt(c, 69888), c)
    case False{}:
      gb.n1664(U32.is_lt(c, 69927), c)

def gb.n1666(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1667(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1668(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      gb.n1667(U32.is_lt(c, 69941), c)

def gb.n1669(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1666(U32.is_lt(c, 69933), c)
    case False{}:
      gb.n1668(U32.is_lt(c, 69940), c)

def gb.n1670(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1665(U32.is_lt(c, 69891), c)
    case False{}:
      gb.n1669(U32.is_lt(c, 69939), c)

def gb.n1671(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1662(U32.is_lt(c, 69822), c)
    case False{}:
      gb.n1670(U32.is_lt(c, 69932), c)

def gb.n1672(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      8

def gb.n1673(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1674(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1672(U32.is_lt(c, 69957), c)
    case False{}:
      gb.n1673(U32.is_lt(c, 69960), c)

def gb.n1675(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1676(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1677(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1675(U32.is_lt(c, 70004), c)
    case False{}:
      gb.n1676(U32.is_lt(c, 70018), c)

def gb.n1678(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1674(U32.is_lt(c, 69959), c)
    case False{}:
      gb.n1677(U32.is_lt(c, 70016), c)

def gb.n1679(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1680(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1681(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1679(U32.is_lt(c, 70067), c)
    case False{}:
      gb.n1680(U32.is_lt(c, 70079), c)

def gb.n1682(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1683(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1684(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      7
    case False{}:
      gb.n1683(U32.is_lt(c, 70089), c)

def gb.n1685(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1682(U32.is_lt(c, 70081), c)
    case False{}:
      gb.n1684(U32.is_lt(c, 70084), c)

def gb.n1686(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1681(U32.is_lt(c, 70070), c)
    case False{}:
      gb.n1685(U32.is_lt(c, 70082), c)

def gb.n1687(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1678(U32.is_lt(c, 70003), c)
    case False{}:
      gb.n1686(U32.is_lt(c, 70080), c)

def gb.n1688(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1671(U32.is_lt(c, 69838), c)
    case False{}:
      gb.n1687(U32.is_lt(c, 70019), c)

def gb.n1689(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1655(U32.is_lt(c, 69506), c)
    case False{}:
      gb.n1688(U32.is_lt(c, 69956), c)

def gb.n1690(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1691(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1692(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1690(U32.is_lt(c, 70094), c)
    case False{}:
      gb.n1691(U32.is_lt(c, 70096), c)

def gb.n1693(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1694(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1695(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1693(U32.is_lt(c, 70191), c)
    case False{}:
      gb.n1694(U32.is_lt(c, 70196), c)

def gb.n1696(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1692(U32.is_lt(c, 70095), c)
    case False{}:
      gb.n1695(U32.is_lt(c, 70194), c)

def gb.n1697(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1698(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1699(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1697(U32.is_lt(c, 70206), c)
    case False{}:
      gb.n1698(U32.is_lt(c, 70209), c)

def gb.n1700(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1701(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1702(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      gb.n1701(U32.is_lt(c, 70379), c)

def gb.n1703(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1700(U32.is_lt(c, 70367), c)
    case False{}:
      gb.n1702(U32.is_lt(c, 70371), c)

def gb.n1704(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1699(U32.is_lt(c, 70207), c)
    case False{}:
      gb.n1703(U32.is_lt(c, 70368), c)

def gb.n1705(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1696(U32.is_lt(c, 70188), c)
    case False{}:
      gb.n1704(U32.is_lt(c, 70210), c)

def gb.n1706(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1707(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1708(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1706(U32.is_lt(c, 70402), c)
    case False{}:
      gb.n1707(U32.is_lt(c, 70459), c)

def gb.n1709(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1710(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1711(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1709(U32.is_lt(c, 70462), c)
    case False{}:
      gb.n1710(U32.is_lt(c, 70464), c)

def gb.n1712(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1708(U32.is_lt(c, 70404), c)
    case False{}:
      gb.n1711(U32.is_lt(c, 70463), c)

def gb.n1713(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1714(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1715(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1713(U32.is_lt(c, 70469), c)
    case False{}:
      gb.n1714(U32.is_lt(c, 70473), c)

def gb.n1716(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1717(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1718(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1717(U32.is_lt(c, 70488), c)

def gb.n1719(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1716(U32.is_lt(c, 70477), c)
    case False{}:
      gb.n1718(U32.is_lt(c, 70487), c)

def gb.n1720(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1715(U32.is_lt(c, 70471), c)
    case False{}:
      gb.n1719(U32.is_lt(c, 70478), c)

def gb.n1721(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1712(U32.is_lt(c, 70461), c)
    case False{}:
      gb.n1720(U32.is_lt(c, 70475), c)

def gb.n1722(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1705(U32.is_lt(c, 70200), c)
    case False{}:
      gb.n1721(U32.is_lt(c, 70465), c)

def gb.n1723(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1724(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1725(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1723(U32.is_lt(c, 70500), c)
    case False{}:
      gb.n1724(U32.is_lt(c, 70509), c)

def gb.n1726(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1727(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1728(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1726(U32.is_lt(c, 70517), c)
    case False{}:
      gb.n1727(U32.is_lt(c, 70538), c)

def gb.n1729(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1725(U32.is_lt(c, 70502), c)
    case False{}:
      gb.n1728(U32.is_lt(c, 70528), c)

def gb.n1730(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1731(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1732(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1730(U32.is_lt(c, 70540), c)
    case False{}:
      gb.n1731(U32.is_lt(c, 70543), c)

def gb.n1733(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1734(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1735(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1734(U32.is_lt(c, 70587), c)

def gb.n1736(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1733(U32.is_lt(c, 70582), c)
    case False{}:
      gb.n1735(U32.is_lt(c, 70585), c)

def gb.n1737(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1732(U32.is_lt(c, 70542), c)
    case False{}:
      gb.n1736(U32.is_lt(c, 70584), c)

def gb.n1738(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1729(U32.is_lt(c, 70512), c)
    case False{}:
      gb.n1737(U32.is_lt(c, 70544), c)

def gb.n1739(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1740(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1741(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1739(U32.is_lt(c, 70594), c)
    case False{}:
      gb.n1740(U32.is_lt(c, 70597), c)

def gb.n1742(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1743(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1744(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1742(U32.is_lt(c, 70599), c)
    case False{}:
      gb.n1743(U32.is_lt(c, 70603), c)

def gb.n1745(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1741(U32.is_lt(c, 70595), c)
    case False{}:
      gb.n1744(U32.is_lt(c, 70602), c)

def gb.n1746(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1747(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      7

def gb.n1748(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1746(U32.is_lt(c, 70606), c)
    case False{}:
      gb.n1747(U32.is_lt(c, 70609), c)

def gb.n1749(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1750(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1751(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1750(U32.is_lt(c, 70709), c)

def gb.n1752(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1749(U32.is_lt(c, 70611), c)
    case False{}:
      gb.n1751(U32.is_lt(c, 70627), c)

def gb.n1753(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1748(U32.is_lt(c, 70608), c)
    case False{}:
      gb.n1752(U32.is_lt(c, 70625), c)

def gb.n1754(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1745(U32.is_lt(c, 70598), c)
    case False{}:
      gb.n1753(U32.is_lt(c, 70610), c)

def gb.n1755(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1738(U32.is_lt(c, 70539), c)
    case False{}:
      gb.n1754(U32.is_lt(c, 70604), c)

def gb.n1756(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1722(U32.is_lt(c, 70400), c)
    case False{}:
      gb.n1755(U32.is_lt(c, 70593), c)

def gb.n1757(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1689(U32.is_lt(c, 69815), c)
    case False{}:
      gb.n1756(U32.is_lt(c, 70498), c)

def gb.n1758(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1759(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1760(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1758(U32.is_lt(c, 70720), c)
    case False{}:
      gb.n1759(U32.is_lt(c, 70725), c)

def gb.n1761(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1762(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1763(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1761(U32.is_lt(c, 70727), c)
    case False{}:
      gb.n1762(U32.is_lt(c, 70751), c)

def gb.n1764(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1760(U32.is_lt(c, 70722), c)
    case False{}:
      gb.n1763(U32.is_lt(c, 70750), c)

def gb.n1765(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1766(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1767(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1765(U32.is_lt(c, 70833), c)
    case False{}:
      gb.n1766(U32.is_lt(c, 70841), c)

def gb.n1768(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1769(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1770(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1769(U32.is_lt(c, 70847), c)

def gb.n1771(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1768(U32.is_lt(c, 70843), c)
    case False{}:
      gb.n1770(U32.is_lt(c, 70846), c)

def gb.n1772(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1767(U32.is_lt(c, 70835), c)
    case False{}:
      gb.n1771(U32.is_lt(c, 70845), c)

def gb.n1773(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1764(U32.is_lt(c, 70726), c)
    case False{}:
      gb.n1772(U32.is_lt(c, 70842), c)

def gb.n1774(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1775(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1776(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1774(U32.is_lt(c, 70850), c)
    case False{}:
      gb.n1775(U32.is_lt(c, 71087), c)

def gb.n1777(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1778(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1779(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1777(U32.is_lt(c, 71090), c)
    case False{}:
      gb.n1778(U32.is_lt(c, 71096), c)

def gb.n1780(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1776(U32.is_lt(c, 70852), c)
    case False{}:
      gb.n1779(U32.is_lt(c, 71094), c)

def gb.n1781(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1782(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1783(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1781(U32.is_lt(c, 71102), c)
    case False{}:
      gb.n1782(U32.is_lt(c, 71105), c)

def gb.n1784(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1785(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1786(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      gb.n1785(U32.is_lt(c, 71227), c)

def gb.n1787(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1784(U32.is_lt(c, 71134), c)
    case False{}:
      gb.n1786(U32.is_lt(c, 71219), c)

def gb.n1788(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1783(U32.is_lt(c, 71103), c)
    case False{}:
      gb.n1787(U32.is_lt(c, 71216), c)

def gb.n1789(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1780(U32.is_lt(c, 71088), c)
    case False{}:
      gb.n1788(U32.is_lt(c, 71132), c)

def gb.n1790(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1773(U32.is_lt(c, 70832), c)
    case False{}:
      gb.n1789(U32.is_lt(c, 71100), c)

def gb.n1791(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1792(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1793(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1791(U32.is_lt(c, 71230), c)
    case False{}:
      gb.n1792(U32.is_lt(c, 71233), c)

def gb.n1794(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1795(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1796(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1794(U32.is_lt(c, 71340), c)
    case False{}:
      gb.n1795(U32.is_lt(c, 71342), c)

def gb.n1797(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1793(U32.is_lt(c, 71231), c)
    case False{}:
      gb.n1796(U32.is_lt(c, 71341), c)

def gb.n1798(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1799(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1800(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1798(U32.is_lt(c, 71352), c)
    case False{}:
      gb.n1799(U32.is_lt(c, 71454), c)

def gb.n1801(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1802(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1803(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1802(U32.is_lt(c, 71463), c)

def gb.n1804(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1801(U32.is_lt(c, 71456), c)
    case False{}:
      gb.n1803(U32.is_lt(c, 71462), c)

def gb.n1805(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1800(U32.is_lt(c, 71453), c)
    case False{}:
      gb.n1804(U32.is_lt(c, 71458), c)

def gb.n1806(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1797(U32.is_lt(c, 71339), c)
    case False{}:
      gb.n1805(U32.is_lt(c, 71455), c)

def gb.n1807(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1808(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1809(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1807(U32.is_lt(c, 71724), c)
    case False{}:
      gb.n1808(U32.is_lt(c, 71736), c)

def gb.n1810(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1811(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1812(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1810(U32.is_lt(c, 71739), c)
    case False{}:
      gb.n1811(U32.is_lt(c, 71943), c)

def gb.n1813(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1809(U32.is_lt(c, 71727), c)
    case False{}:
      gb.n1812(U32.is_lt(c, 71936), c)

def gb.n1814(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1815(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1816(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1814(U32.is_lt(c, 71946), c)
    case False{}:
      gb.n1815(U32.is_lt(c, 71956), c)

def gb.n1817(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      0

def gb.n1818(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1819(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      gb.n1818(U32.is_lt(c, 71985), c)

def gb.n1820(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1817(U32.is_lt(c, 71959), c)
    case False{}:
      gb.n1819(U32.is_lt(c, 71984), c)

def gb.n1821(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1816(U32.is_lt(c, 71948), c)
    case False{}:
      gb.n1820(U32.is_lt(c, 71960), c)

def gb.n1822(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1813(U32.is_lt(c, 71737), c)
    case False{}:
      gb.n1821(U32.is_lt(c, 71957), c)

def gb.n1823(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1806(U32.is_lt(c, 71344), c)
    case False{}:
      gb.n1822(U32.is_lt(c, 71945), c)

def gb.n1824(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1790(U32.is_lt(c, 70849), c)
    case False{}:
      gb.n1823(U32.is_lt(c, 71468), c)

def gb.n1825(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1826(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1827(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1825(U32.is_lt(c, 71991), c)
    case False{}:
      gb.n1826(U32.is_lt(c, 71995), c)

def gb.n1828(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      100
    case False{}:
      7

def gb.n1829(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      7

def gb.n1830(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1828(U32.is_lt(c, 71999), c)
    case False{}:
      gb.n1829(U32.is_lt(c, 72001), c)

def gb.n1831(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1827(U32.is_lt(c, 71993), c)
    case False{}:
      gb.n1830(U32.is_lt(c, 72000), c)

def gb.n1832(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1833(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1834(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1832(U32.is_lt(c, 72003), c)
    case False{}:
      gb.n1833(U32.is_lt(c, 72145), c)

def gb.n1835(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1836(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1837(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1836(U32.is_lt(c, 72160), c)

def gb.n1838(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1835(U32.is_lt(c, 72152), c)
    case False{}:
      gb.n1837(U32.is_lt(c, 72156), c)

def gb.n1839(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1834(U32.is_lt(c, 72004), c)
    case False{}:
      gb.n1838(U32.is_lt(c, 72154), c)

def gb.n1840(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1831(U32.is_lt(c, 71998), c)
    case False{}:
      gb.n1839(U32.is_lt(c, 72148), c)

def gb.n1841(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1842(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n1843(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1841(U32.is_lt(c, 72164), c)
    case False{}:
      gb.n1842(U32.is_lt(c, 72192), c)

def gb.n1844(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      32

def gb.n1845(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1846(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1844(U32.is_lt(c, 72203), c)
    case False{}:
      gb.n1845(U32.is_lt(c, 72249), c)

def gb.n1847(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1843(U32.is_lt(c, 72165), c)
    case False{}:
      gb.n1846(U32.is_lt(c, 72243), c)

def gb.n1848(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1849(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      100

def gb.n1850(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1848(U32.is_lt(c, 72251), c)
    case False{}:
      gb.n1849(U32.is_lt(c, 72263), c)

def gb.n1851(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n1852(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1853(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1852(U32.is_lt(c, 72281), c)

def gb.n1854(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1851(U32.is_lt(c, 72272), c)
    case False{}:
      gb.n1853(U32.is_lt(c, 72279), c)

def gb.n1855(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1850(U32.is_lt(c, 72255), c)
    case False{}:
      gb.n1854(U32.is_lt(c, 72273), c)

def gb.n1856(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1847(U32.is_lt(c, 72193), c)
    case False{}:
      gb.n1855(U32.is_lt(c, 72264), c)

def gb.n1857(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1840(U32.is_lt(c, 72002), c)
    case False{}:
      gb.n1856(U32.is_lt(c, 72250), c)

def gb.n1858(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      32
    case False{}:
      7

def gb.n1859(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1860(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1858(U32.is_lt(c, 72324), c)
    case False{}:
      gb.n1859(U32.is_lt(c, 72343), c)

def gb.n1861(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      100

def gb.n1862(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1863(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1861(U32.is_lt(c, 72345), c)
    case False{}:
      gb.n1862(U32.is_lt(c, 72544), c)

def gb.n1864(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1860(U32.is_lt(c, 72330), c)
    case False{}:
      gb.n1863(U32.is_lt(c, 72346), c)

def gb.n1865(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1866(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1867(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1865(U32.is_lt(c, 72546), c)
    case False{}:
      gb.n1866(U32.is_lt(c, 72550), c)

def gb.n1868(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1869(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1870(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      gb.n1869(U32.is_lt(c, 72759), c)

def gb.n1871(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1868(U32.is_lt(c, 72552), c)
    case False{}:
      gb.n1870(U32.is_lt(c, 72752), c)

def gb.n1872(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1867(U32.is_lt(c, 72549), c)
    case False{}:
      gb.n1871(U32.is_lt(c, 72751), c)

def gb.n1873(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1864(U32.is_lt(c, 72344), c)
    case False{}:
      gb.n1872(U32.is_lt(c, 72551), c)

def gb.n1874(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      8

def gb.n1875(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1876(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1874(U32.is_lt(c, 72766), c)
    case False{}:
      gb.n1875(U32.is_lt(c, 72768), c)

def gb.n1877(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1878(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1879(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1877(U32.is_lt(c, 72872), c)
    case False{}:
      gb.n1878(U32.is_lt(c, 72874), c)

def gb.n1880(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1876(U32.is_lt(c, 72767), c)
    case False{}:
      gb.n1879(U32.is_lt(c, 72873), c)

def gb.n1881(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1882(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1883(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1881(U32.is_lt(c, 72882), c)
    case False{}:
      gb.n1882(U32.is_lt(c, 72885), c)

def gb.n1884(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1885(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1886(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1885(U32.is_lt(c, 73019), c)

def gb.n1887(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1884(U32.is_lt(c, 73009), c)
    case False{}:
      gb.n1886(U32.is_lt(c, 73018), c)

def gb.n1888(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1883(U32.is_lt(c, 72884), c)
    case False{}:
      gb.n1887(U32.is_lt(c, 73015), c)

def gb.n1889(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1880(U32.is_lt(c, 72850), c)
    case False{}:
      gb.n1888(U32.is_lt(c, 72887), c)

def gb.n1890(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1873(U32.is_lt(c, 72545), c)
    case False{}:
      gb.n1889(U32.is_lt(c, 72881), c)

def gb.n1891(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1857(U32.is_lt(c, 72161), c)
    case False{}:
      gb.n1890(U32.is_lt(c, 72760), c)

def gb.n1892(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1824(U32.is_lt(c, 71229), c)
    case False{}:
      gb.n1891(U32.is_lt(c, 72284), c)

def gb.n1893(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1757(U32.is_lt(c, 70093), c)
    case False{}:
      gb.n1892(U32.is_lt(c, 71990), c)

def gb.n1894(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1895(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      7

def gb.n1896(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1894(U32.is_lt(c, 73022), c)
    case False{}:
      gb.n1895(U32.is_lt(c, 73030), c)

def gb.n1897(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1898(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1899(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1897(U32.is_lt(c, 73032), c)
    case False{}:
      gb.n1898(U32.is_lt(c, 73103), c)

def gb.n1900(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1896(U32.is_lt(c, 73023), c)
    case False{}:
      gb.n1899(U32.is_lt(c, 73098), c)

def gb.n1901(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1902(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1903(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1901(U32.is_lt(c, 73106), c)
    case False{}:
      gb.n1902(U32.is_lt(c, 73109), c)

def gb.n1904(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1905(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1906(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1904(U32.is_lt(c, 73111), c)
    case False{}:
      gb.n1905(U32.is_lt(c, 73459), c)

def gb.n1907(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1903(U32.is_lt(c, 73107), c)
    case False{}:
      gb.n1906(U32.is_lt(c, 73112), c)

def gb.n1908(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1900(U32.is_lt(c, 73031), c)
    case False{}:
      gb.n1907(U32.is_lt(c, 73110), c)

def gb.n1909(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1910(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      7

def gb.n1911(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1909(U32.is_lt(c, 73463), c)
    case False{}:
      gb.n1910(U32.is_lt(c, 73474), c)

def gb.n1912(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      32

def gb.n1913(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      32

def gb.n1914(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1912(U32.is_lt(c, 73476), c)
    case False{}:
      gb.n1913(U32.is_lt(c, 73490), c)

def gb.n1915(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1911(U32.is_lt(c, 73472), c)
    case False{}:
      gb.n1914(U32.is_lt(c, 73489), c)

def gb.n1916(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1917(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      8

def gb.n1918(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1916(U32.is_lt(c, 73526), c)
    case False{}:
      gb.n1917(U32.is_lt(c, 73534), c)

def gb.n1919(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      100

def gb.n1920(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1921(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1920(U32.is_lt(c, 73563), c)

def gb.n1922(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1919(U32.is_lt(c, 73538), c)
    case False{}:
      gb.n1921(U32.is_lt(c, 73562), c)

def gb.n1923(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1918(U32.is_lt(c, 73531), c)
    case False{}:
      gb.n1922(U32.is_lt(c, 73539), c)

def gb.n1924(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1915(U32.is_lt(c, 73475), c)
    case False{}:
      gb.n1923(U32.is_lt(c, 73536), c)

def gb.n1925(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1908(U32.is_lt(c, 73104), c)
    case False{}:
      gb.n1924(U32.is_lt(c, 73524), c)

def gb.n1926(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      68

def gb.n1927(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1928(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1926(U32.is_lt(c, 78912), c)
    case False{}:
      gb.n1927(U32.is_lt(c, 78919), c)

def gb.n1929(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1930(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      68

def gb.n1931(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1929(U32.is_lt(c, 90398), c)
    case False{}:
      gb.n1930(U32.is_lt(c, 90413), c)

def gb.n1932(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1928(U32.is_lt(c, 78913), c)
    case False{}:
      gb.n1931(U32.is_lt(c, 90410), c)

def gb.n1933(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1934(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1935(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1933(U32.is_lt(c, 92912), c)
    case False{}:
      gb.n1934(U32.is_lt(c, 92976), c)

def gb.n1936(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      10

def gb.n1937(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      10
    case False{}:
      0

def gb.n1938(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1937(U32.is_lt(c, 93547), c)

def gb.n1939(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1936(U32.is_lt(c, 93539), c)
    case False{}:
      gb.n1938(U32.is_lt(c, 93543), c)

def gb.n1940(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1935(U32.is_lt(c, 92917), c)
    case False{}:
      gb.n1939(U32.is_lt(c, 93540), c)

def gb.n1941(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1932(U32.is_lt(c, 78934), c)
    case False{}:
      gb.n1940(U32.is_lt(c, 92983), c)

def gb.n1942(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1943(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      8
    case False{}:
      0

def gb.n1944(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1942(U32.is_lt(c, 94032), c)
    case False{}:
      gb.n1943(U32.is_lt(c, 94088), c)

def gb.n1945(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1946(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1947(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1945(U32.is_lt(c, 94099), c)
    case False{}:
      gb.n1946(U32.is_lt(c, 94181), c)

def gb.n1948(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1944(U32.is_lt(c, 94033), c)
    case False{}:
      gb.n1947(U32.is_lt(c, 94180), c)

def gb.n1949(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1950(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1951(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1949(U32.is_lt(c, 94194), c)
    case False{}:
      gb.n1950(U32.is_lt(c, 113823), c)

def gb.n1952(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n1953(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1954(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1953(U32.is_lt(c, 118576), c)

def gb.n1955(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1952(U32.is_lt(c, 113828), c)
    case False{}:
      gb.n1954(U32.is_lt(c, 118574), c)

def gb.n1956(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1951(U32.is_lt(c, 113821), c)
    case False{}:
      gb.n1955(U32.is_lt(c, 118528), c)

def gb.n1957(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1948(U32.is_lt(c, 94095), c)
    case False{}:
      gb.n1956(U32.is_lt(c, 113824), c)

def gb.n1958(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1941(U32.is_lt(c, 90416), c)
    case False{}:
      gb.n1957(U32.is_lt(c, 94192), c)

def gb.n1959(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1925(U32.is_lt(c, 73461), c)
    case False{}:
      gb.n1958(U32.is_lt(c, 94031), c)

def gb.n1960(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1961(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1962(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1960(U32.is_lt(c, 119141), c)
    case False{}:
      gb.n1961(U32.is_lt(c, 119149), c)

def gb.n1963(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      68

def gb.n1964(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1965(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1963(U32.is_lt(c, 119163), c)
    case False{}:
      gb.n1964(U32.is_lt(c, 119173), c)

def gb.n1966(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1962(U32.is_lt(c, 119146), c)
    case False{}:
      gb.n1965(U32.is_lt(c, 119171), c)

def gb.n1967(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1968(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1969(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1967(U32.is_lt(c, 119210), c)
    case False{}:
      gb.n1968(U32.is_lt(c, 119362), c)

def gb.n1970(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1971(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1972(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n1971(U32.is_lt(c, 121453), c)

def gb.n1973(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1970(U32.is_lt(c, 121344), c)
    case False{}:
      gb.n1972(U32.is_lt(c, 121403), c)

def gb.n1974(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1969(U32.is_lt(c, 119214), c)
    case False{}:
      gb.n1973(U32.is_lt(c, 121399), c)

def gb.n1975(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1966(U32.is_lt(c, 119155), c)
    case False{}:
      gb.n1974(U32.is_lt(c, 119365), c)

def gb.n1976(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1977(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1978(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1976(U32.is_lt(c, 121462), c)
    case False{}:
      gb.n1977(U32.is_lt(c, 121477), c)

def gb.n1979(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1980(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1981(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1979(U32.is_lt(c, 121504), c)
    case False{}:
      gb.n1980(U32.is_lt(c, 121520), c)

def gb.n1982(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1978(U32.is_lt(c, 121476), c)
    case False{}:
      gb.n1981(U32.is_lt(c, 121505), c)

def gb.n1983(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1984(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1985(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1983(U32.is_lt(c, 122887), c)
    case False{}:
      gb.n1984(U32.is_lt(c, 122905), c)

def gb.n1986(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n1987(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1988(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n1987(U32.is_lt(c, 122918), c)

def gb.n1989(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1986(U32.is_lt(c, 122914), c)
    case False{}:
      gb.n1988(U32.is_lt(c, 122917), c)

def gb.n1990(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1985(U32.is_lt(c, 122888), c)
    case False{}:
      gb.n1989(U32.is_lt(c, 122915), c)

def gb.n1991(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1982(U32.is_lt(c, 121499), c)
    case False{}:
      gb.n1990(U32.is_lt(c, 122907), c)

def gb.n1992(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1975(U32.is_lt(c, 119180), c)
    case False{}:
      gb.n1991(U32.is_lt(c, 122880), c)

def gb.n1993(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1994(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1995(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1993(U32.is_lt(c, 123023), c)
    case False{}:
      gb.n1994(U32.is_lt(c, 123184), c)

def gb.n1996(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1997(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n1998(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1996(U32.is_lt(c, 123566), c)
    case False{}:
      gb.n1997(U32.is_lt(c, 123628), c)

def gb.n1999(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1995(U32.is_lt(c, 123024), c)
    case False{}:
      gb.n1998(U32.is_lt(c, 123567), c)

def gb.n2000(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n2001(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n2002(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2000(U32.is_lt(c, 124140), c)
    case False{}:
      gb.n2001(U32.is_lt(c, 124398), c)

def gb.n2003(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      68

def gb.n2004(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n2005(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n2004(U32.is_lt(c, 124647), c)

def gb.n2006(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2003(U32.is_lt(c, 124643), c)
    case False{}:
      gb.n2005(U32.is_lt(c, 124646), c)

def gb.n2007(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2002(U32.is_lt(c, 124144), c)
    case False{}:
      gb.n2006(U32.is_lt(c, 124644), c)

def gb.n2008(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1999(U32.is_lt(c, 123191), c)
    case False{}:
      gb.n2007(U32.is_lt(c, 124400), c)

def gb.n2009(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n2010(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n2011(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2009(U32.is_lt(c, 124656), c)
    case False{}:
      gb.n2010(U32.is_lt(c, 124662), c)

def gb.n2012(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n2013(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      0

def gb.n2014(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2012(U32.is_lt(c, 125143), c)
    case False{}:
      gb.n2013(U32.is_lt(c, 125259), c)

def gb.n2015(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2011(U32.is_lt(c, 124661), c)
    case False{}:
      gb.n2014(U32.is_lt(c, 125252), c)

def gb.n2016(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2017(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2018(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2016(U32.is_lt(c, 126981), c)
    case False{}:
      gb.n2017(U32.is_lt(c, 127024), c)

def gb.n2019(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2020(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2021(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n2020(U32.is_lt(c, 127168), c)

def gb.n2022(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2019(U32.is_lt(c, 127136), c)
    case False{}:
      gb.n2021(U32.is_lt(c, 127153), c)

def gb.n2023(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2018(U32.is_lt(c, 127020), c)
    case False{}:
      gb.n2022(U32.is_lt(c, 127151), c)

def gb.n2024(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2015(U32.is_lt(c, 125136), c)
    case False{}:
      gb.n2023(U32.is_lt(c, 127124), c)

def gb.n2025(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2008(U32.is_lt(c, 123632), c)
    case False{}:
      gb.n2024(U32.is_lt(c, 126980), c)

def gb.n2026(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1992(U32.is_lt(c, 121461), c)
    case False{}:
      gb.n2025(U32.is_lt(c, 124654), c)

def gb.n2027(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1959(U32.is_lt(c, 78896), c)
    case False{}:
      gb.n2026(U32.is_lt(c, 122923), c)

def gb.n2028(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2029(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2030(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2028(U32.is_lt(c, 127183), c)
    case False{}:
      gb.n2029(U32.is_lt(c, 127222), c)

def gb.n2031(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2032(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2033(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2031(U32.is_lt(c, 127344), c)
    case False{}:
      gb.n2032(U32.is_lt(c, 127358), c)

def gb.n2034(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2030(U32.is_lt(c, 127185), c)
    case False{}:
      gb.n2033(U32.is_lt(c, 127346), c)

def gb.n2035(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2036(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2037(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2035(U32.is_lt(c, 127374), c)
    case False{}:
      gb.n2036(U32.is_lt(c, 127377), c)

def gb.n2038(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2039(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2040(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      6
    case False{}:
      gb.n2039(U32.is_lt(c, 127489), c)

def gb.n2041(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2038(U32.is_lt(c, 127406), c)
    case False{}:
      gb.n2040(U32.is_lt(c, 127488), c)

def gb.n2042(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2037(U32.is_lt(c, 127375), c)
    case False{}:
      gb.n2041(U32.is_lt(c, 127462), c)

def gb.n2043(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2034(U32.is_lt(c, 127232), c)
    case False{}:
      gb.n2042(U32.is_lt(c, 127387), c)

def gb.n2044(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2045(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2046(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2044(U32.is_lt(c, 127514), c)
    case False{}:
      gb.n2045(U32.is_lt(c, 127535), c)

def gb.n2047(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2048(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2049(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2047(U32.is_lt(c, 127538), c)
    case False{}:
      gb.n2048(U32.is_lt(c, 127548), c)

def gb.n2050(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2046(U32.is_lt(c, 127515), c)
    case False{}:
      gb.n2049(U32.is_lt(c, 127547), c)

def gb.n2051(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2052(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2053(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2051(U32.is_lt(c, 127561), c)
    case False{}:
      gb.n2052(U32.is_lt(c, 127590), c)

def gb.n2054(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2055(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2056(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n2055(U32.is_lt(c, 127896), c)

def gb.n2057(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2054(U32.is_lt(c, 127780), c)
    case False{}:
      gb.n2056(U32.is_lt(c, 127894), c)

def gb.n2058(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2053(U32.is_lt(c, 127584), c)
    case False{}:
      gb.n2057(U32.is_lt(c, 127892), c)

def gb.n2059(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2050(U32.is_lt(c, 127536), c)
    case False{}:
      gb.n2058(U32.is_lt(c, 127778), c)

def gb.n2060(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2043(U32.is_lt(c, 127360), c)
    case False{}:
      gb.n2059(U32.is_lt(c, 127552), c)

def gb.n2061(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2062(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2063(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2061(U32.is_lt(c, 127900), c)
    case False{}:
      gb.n2062(U32.is_lt(c, 127985), c)

def gb.n2064(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2065(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      68

def gb.n2066(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2064(U32.is_lt(c, 127990), c)
    case False{}:
      gb.n2065(U32.is_lt(c, 127995), c)

def gb.n2067(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2063(U32.is_lt(c, 127902), c)
    case False{}:
      gb.n2066(U32.is_lt(c, 127991), c)

def gb.n2068(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2069(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2070(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2068(U32.is_lt(c, 128254), c)
    case False{}:
      gb.n2069(U32.is_lt(c, 128318), c)

def gb.n2071(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2072(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2073(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n2072(U32.is_lt(c, 128367), c)

def gb.n2074(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2071(U32.is_lt(c, 128335), c)
    case False{}:
      gb.n2073(U32.is_lt(c, 128360), c)

def gb.n2075(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2070(U32.is_lt(c, 128255), c)
    case False{}:
      gb.n2074(U32.is_lt(c, 128336), c)

def gb.n2076(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2067(U32.is_lt(c, 127987), c)
    case False{}:
      gb.n2075(U32.is_lt(c, 128329), c)

def gb.n2077(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2078(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2079(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2077(U32.is_lt(c, 128371), c)
    case False{}:
      gb.n2078(U32.is_lt(c, 128391), c)

def gb.n2080(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2081(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2082(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2080(U32.is_lt(c, 128394), c)
    case False{}:
      gb.n2081(U32.is_lt(c, 128400), c)

def gb.n2083(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2079(U32.is_lt(c, 128379), c)
    case False{}:
      gb.n2082(U32.is_lt(c, 128398), c)

def gb.n2084(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2085(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2086(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2084(U32.is_lt(c, 128405), c)
    case False{}:
      gb.n2085(U32.is_lt(c, 128420), c)

def gb.n2087(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2088(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2089(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n2088(U32.is_lt(c, 128435), c)

def gb.n2090(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2087(U32.is_lt(c, 128424), c)
    case False{}:
      gb.n2089(U32.is_lt(c, 128433), c)

def gb.n2091(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2086(U32.is_lt(c, 128407), c)
    case False{}:
      gb.n2090(U32.is_lt(c, 128425), c)

def gb.n2092(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2083(U32.is_lt(c, 128392), c)
    case False{}:
      gb.n2091(U32.is_lt(c, 128422), c)

def gb.n2093(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2076(U32.is_lt(c, 128000), c)
    case False{}:
      gb.n2092(U32.is_lt(c, 128401), c)

def gb.n2094(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2060(U32.is_lt(c, 127504), c)
    case False{}:
      gb.n2093(U32.is_lt(c, 128369), c)

def gb.n2095(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2096(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2097(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2095(U32.is_lt(c, 128445), c)
    case False{}:
      gb.n2096(U32.is_lt(c, 128453), c)

def gb.n2098(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2099(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2100(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2098(U32.is_lt(c, 128468), c)
    case False{}:
      gb.n2099(U32.is_lt(c, 128479), c)

def gb.n2101(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2097(U32.is_lt(c, 128450), c)
    case False{}:
      gb.n2100(U32.is_lt(c, 128476), c)

def gb.n2102(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2103(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2104(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2102(U32.is_lt(c, 128482), c)
    case False{}:
      gb.n2103(U32.is_lt(c, 128484), c)

def gb.n2105(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2106(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2107(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n2106(U32.is_lt(c, 128499), c)

def gb.n2108(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2105(U32.is_lt(c, 128489), c)
    case False{}:
      gb.n2107(U32.is_lt(c, 128496), c)

def gb.n2109(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2104(U32.is_lt(c, 128483), c)
    case False{}:
      gb.n2108(U32.is_lt(c, 128495), c)

def gb.n2110(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2101(U32.is_lt(c, 128465), c)
    case False{}:
      gb.n2109(U32.is_lt(c, 128488), c)

def gb.n2111(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2112(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2113(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2111(U32.is_lt(c, 128506), c)
    case False{}:
      gb.n2112(U32.is_lt(c, 128640), c)

def gb.n2114(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2115(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2116(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2114(U32.is_lt(c, 128715), c)
    case False{}:
      gb.n2115(U32.is_lt(c, 128725), c)

def gb.n2117(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2113(U32.is_lt(c, 128592), c)
    case False{}:
      gb.n2116(U32.is_lt(c, 128723), c)

def gb.n2118(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2119(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2120(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2118(U32.is_lt(c, 128745), c)
    case False{}:
      gb.n2119(U32.is_lt(c, 128747), c)

def gb.n2121(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2122(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2123(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      gb.n2122(U32.is_lt(c, 129024), c)

def gb.n2124(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2121(U32.is_lt(c, 128755), c)
    case False{}:
      gb.n2123(U32.is_lt(c, 128986), c)

def gb.n2125(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2120(U32.is_lt(c, 128746), c)
    case False{}:
      gb.n2124(U32.is_lt(c, 128768), c)

def gb.n2126(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2117(U32.is_lt(c, 128710), c)
    case False{}:
      gb.n2125(U32.is_lt(c, 128753), c)

def gb.n2127(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2110(U32.is_lt(c, 128481), c)
    case False{}:
      gb.n2126(U32.is_lt(c, 128742), c)

def gb.n2128(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2129(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2130(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2128(U32.is_lt(c, 129040), c)
    case False{}:
      gb.n2129(U32.is_lt(c, 129104), c)

def gb.n2131(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2132(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2133(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2131(U32.is_lt(c, 129120), c)
    case False{}:
      gb.n2132(U32.is_lt(c, 129168), c)

def gb.n2134(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2130(U32.is_lt(c, 129096), c)
    case False{}:
      gb.n2133(U32.is_lt(c, 129160), c)

def gb.n2135(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2136(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2137(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2135(U32.is_lt(c, 129200), c)
    case False{}:
      gb.n2136(U32.is_lt(c, 129216), c)

def gb.n2138(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      0

def gb.n2139(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2140(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      16
    case False{}:
      gb.n2139(U32.is_lt(c, 129292), c)

def gb.n2141(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2138(U32.is_lt(c, 129232), c)
    case False{}:
      gb.n2140(U32.is_lt(c, 129280), c)

def gb.n2142(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2137(U32.is_lt(c, 129212), c)
    case False{}:
      gb.n2141(U32.is_lt(c, 129241), c)

def gb.n2143(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2134(U32.is_lt(c, 129114), c)
    case False{}:
      gb.n2142(U32.is_lt(c, 129218), c)

def gb.n2144(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2145(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2146(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2144(U32.is_lt(c, 129340), c)
    case False{}:
      gb.n2145(U32.is_lt(c, 129351), c)

def gb.n2147(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2148(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2149(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2147(U32.is_lt(c, 129624), c)
    case False{}:
      gb.n2148(U32.is_lt(c, 129646), c)

def gb.n2150(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2146(U32.is_lt(c, 129350), c)
    case False{}:
      gb.n2149(U32.is_lt(c, 129632), c)

def gb.n2151(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      16

def gb.n2152(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      0
    case False{}:
      3

def gb.n2153(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2151(U32.is_lt(c, 130048), c)
    case False{}:
      gb.n2152(U32.is_lt(c, 917504), c)

def gb.n2154(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      3

def gb.n2155(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      3
    case False{}:
      0

def gb.n2156(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      68
    case False{}:
      gb.n2155(U32.is_lt(c, 921600), c)

def gb.n2157(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2154(U32.is_lt(c, 917632), c)
    case False{}:
      gb.n2156(U32.is_lt(c, 918000), c)

def gb.n2158(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2153(U32.is_lt(c, 131070), c)
    case False{}:
      gb.n2157(U32.is_lt(c, 917760), c)

def gb.n2159(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2150(U32.is_lt(c, 129536), c)
    case False{}:
      gb.n2158(U32.is_lt(c, 917536), c)

def gb.n2160(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2143(U32.is_lt(c, 129198), c)
    case False{}:
      gb.n2159(U32.is_lt(c, 129792), c)

def gb.n2161(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2127(U32.is_lt(c, 128500), c)
    case False{}:
      gb.n2160(U32.is_lt(c, 129339), c)

def gb.n2162(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2094(U32.is_lt(c, 127897), c)
    case False{}:
      gb.n2161(U32.is_lt(c, 129036), c)

def gb.n2163(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n2027(U32.is_lt(c, 118599), c)
    case False{}:
      gb.n2162(U32.is_lt(c, 128444), c)

def gb.n2164(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1893(U32.is_lt(c, 70712), c)
    case False{}:
      gb.n2163(U32.is_lt(c, 127169), c)

def gb.n2165(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1623(U32.is_lt(c, 51900), c)
    case False{}:
      gb.n2164(U32.is_lt(c, 73020), c)

def gb.n2166(lt: Bool, +c: U32) -> U32:
  match lt:
    case True{}:
      gb.n1082(U32.is_lt(c, 9745), c)
    case False{}:
      gb.n2165(U32.is_lt(c, 68152), c)

def gb(+c: U32) -> U32:
  gb.n2166(U32.is_lt(c, 48093), c)