@danielsimonjr/mathts-wasm 0.1.1 → 0.1.3

package/build/mathts-debug.wasm.map

@@ -1 +1 @@
-{"version":3,"sources":["~lib/rt/common.ts","src/types/complex.ts","~lib/rt/stub.ts","~lib/util/error.ts","src/ops/scalar.ts","~lib/util/math.ts","~lib/util/number.ts","~lib/util/string.ts","~lib/math.ts","~lib/builtins.ts","src/ops/array.ts","~lib/util/sort.ts","~lib/shared/runtime.ts","~lib/typedarray.ts","~lib/arraybuffer.ts","src/ops/matrix.ts","src/ops/complex-ops.ts","src/ops/complex-array.ts"],"names":[],"mappings":"qvIEYoB,EAAlB,EACkB,EAAsB,EAAtB,CAA4B,EAA7B,CAAyC,E,EAAD,CAAzC,CAAhB,EACI,EAAY,EAAZ,CAAJ,EAC4B,EAAY,EAAZ,CAAwB,IAAxB,CAAmC,I,EAAD,CAAnC,CAAgD,EAAvD,CAAlB,EACsB,E,EAAa,E,OAAjB,CAAlB,EACgB,EAAZ,EAA2B,EAA3B,CAAJ,EACkB,EAAZ,EAA2B,EAA3B,CAAJ,EAAkC,IAG7B,EAAT,K,YAWI,EAAO,MAAP,CAAJ,EAA0C,E,WAC9B,EAAZ,EACU,EAAS,EAAT,CAAV,EACkB,EAAY,E,EATrB,EAAO,EAAP,CAAwB,EAAxB,CAAoC,E,EAAD,CAApC,CAAgD,EAAjD,CAAP,GASA,EACgB,EAAM,EAAN,CAAhB,EACA,EAAe,EAAf,EACO,EAAP,I,0CA+CI,EAAO,MAAP,CAAJ,EAA2C,E,YACzB,EAAkB,EAAlB,CAAR,EAAV,EACgC,EAAM,EAAzB,CAAb,EACA,EAAgB,EAAhB,EACA,EAAiB,EAAjB,EACA,EAAc,EAAd,EACA,EAAgB,EAAhB,EACO,EAAM,EAAN,CAAP,I,wCDtEE,EAAU,EAAV,EACA,EAAU,EAAV,E,8BAga6C,SAAK,SAAjB,E,IAGW,SAAK,SAAjB,E,IAGU,SAAK,SAAjB,E,IAGkB,SAAM,SAAlB,E,YAtCnB,EAAI,EAAhB,EAAP,WOnRgB,EAAI,WAAJ,CAAhB,EACc,EAAa,EAAb,CAAmB,GAApB,CAAb,EACa,EAAS,EAAT,CAAb,EACa,GAAoB,EAAU,E,CAAhB,CAAsB,EAAtB,CAAd,CAAb,EAGmB,EAAV,GAAT,EACmB,EAAV,GAAT,EACmB,EAAV,GAAT,EAGI,E,GAAJ,EACe,G,CAAK,EAAL,CAAb,EACmB,EAAV,GAAT,EACK,EAAM,EAAN,CAAe,EAAM,EAAN,CAAf,CAAL,EACK,EAAM,EAAN,CAAe,EAAM,EAAN,CAAf,CAAL,EACK,EAAM,EAAN,CAAe,EAAM,EAAN,CAAf,CAAL,GAEK,EAAL,EACK,EAAL,EACK,EAAL,GAGiB,EAAI,SAAJ,CAA0B,SAA3B,CAAlB,EAGU,EAAO,E,EAAI,E,EA5ChB,EAAI,MAAJ,CAAL,EACK,EAAI,MAAJ,CAAL,EAEA,EAAM,E,CAAN,EACA,EAAM,E,CAAN,EAEK,EAAK,EAAL,CAAL,EACK,EAAI,MAAJ,CAAL,EACK,EAAI,EAAJ,CAAU,EAAK,EAAL,CAAV,CAAL,EACK,EAAK,EAAL,CAAL,EACK,EAAK,EAAL,CAAU,EAAI,MAAJ,CAAV,CAAL,EAEY,EAAI,EAAJ,CAAQ,EAAR,CAAc,EAAK,EAAL,CAAd,CAAZ,EACQ,EAAK,EAAL,CAAW,EAAZ,CAAP,GA+BA,EACU,EAAV,EAEU,EAAK,EAAL,CAAV,EACW,EAAM,EAAN,CAAa,EAAe,EAAf,CAAd,CAAV,EACU,EAAM,EAAN,CAAV,EACU,EAAM,EAAN,CAAgB,EAAM,E,CAAV,CAAZ,CAAV,EAGU,EAAO,EAAP,CAAV,EACU,EAAO,EAAP,CAAW,EAAO,EAAP,CAAX,CAAV,EAGU,EAAY,EAAZ,CAAV,EACU,EAAO,EAAP,CAAV,EACW,EAAY,EAAZ,CAAkB,EAAnB,CAAV,EAEc,UAAsB,EAAW,EAAM,EAAN,C,EAAW,EAAM,EAAN,C,EArF1C,EAAJ,CAAZ,EAEK,EAAM,EAAN,CAAc,EAAO,GAAK,EAAL,CAAP,CAAd,CAAL,EACA,EAAO,E,CAAP,EAES,EAAO,U,EAAI,E,EAmBf,EAAI,MAAJ,CAAL,EACK,EAAI,MAAJ,CAAL,EAEA,EAAM,E,CAAN,EACA,EAAM,E,CAAN,EAEK,EAAK,EAAL,CAAL,EACK,EAAI,MAAJ,CAAL,EACK,EAAI,EAAJ,CAAU,EAAK,EAAL,CAAV,CAAL,EACK,EAAK,EAAL,CAAL,EACK,EAAK,EAAL,CAAU,EAAI,MAAJ,CAAV,CAAL,EAEY,EAAI,EAAJ,CAAQ,EAAR,CAAc,EAAK,EAAL,CAAd,CAAZ,EACQ,EAAK,EAAL,CAAW,EAAZ,CAAP,GAhCA,EACS,EAAT,EAEU,EAAM,EAAN,CAAV,EACU,EAAM,EAAN,CAAW,EAAM,EAAN,CAAX,CAAV,EACgB,S,UAAU,CAAV,C,EAAoB,CAApB,CAA8B,S,UAAU,CAAV,C,EAAoB,CAApB,C,CAApC,EAAV,EAEmB,EAAU,EAAK,E,CAAT,C,CAAZ,CAAb,EACa,SAAgB,EAAM,E,CAAZ,CAAV,CAAb,EAEO,EAAP,GAsEwE,EAApC,CAAtB,CAAd,EACe,EAAI,EAAJ,CAAW,WAAZ,CAAd,EAC+B,EAAU,EAAV,CAAjB,CAAd,EAEA,EAAc,E,CAAd,EACA,EAAc,E,CAAd,E,EAEO,CAAP,WAoiB4B,EAAjB,CAAT,EACa,EAAK,E,CAAT,CAAT,EACW,EAAM,EAAN,CAAX,EAEA,EAAM,M,CAAN,EAGI,EAAM,MAAN,CAAJ,EACM,EAAK,MAAL,CAAJ,EACS,SAAP,EAEK,EAAS,E,EAAG,S,EAxbf,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,EAAK,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAL,CAA+B,EAAI,EAAJ,CAAS,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAT,CAA/B,CAAR,EACS,SAAM,EAAN,CAAT,EACI,SAAM,EAAN,CAAJ,EACO,EAAO,SAAM,EAAN,CAAW,EAAZ,CAAmB,EAAI,EAAJ,CAAQ,EAAI,EAAJ,CAAR,CAApB,CAAL,CAAP,GAmbI,EAIE,EAAM,MAAN,CAAJ,EAA6B,EAAI,EAAJ,CAAP,EAGb,EAAQ,E,EAAG,E,EAAG,E,EAtiBV,EAAK,E,CAAX,CAAiB,MAAjB,CAAT,EAEI,EAAmB,EAAnB,C,CACE,EAAK,MAAL,CADoB,EAEd,EAAR,EACK,EAAD,CAAJ,EACM,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,IAGE,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEE,EAAJ,GAEW,EAAb,EACa,EAAb,EACO,EAAP,GAIA,EAAK,MAAL,CAAJ,EAEmB,EAAI,SAAJ,CAAR,CAAT,EACS,EAAI,EAAI,SAAJ,CAAJ,CAAT,EACS,EAAI,SAAJ,CAAT,EACS,EAAM,EAAN,CAAT,EACS,EAAI,EAAJ,CAAT,EACgC,EAAjB,CAAwB,E,CAA9B,CAAT,EACS,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAT,EAEI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,EAC4B,EAAjB,CAAwB,E,CAA9B,CAAL,EACI,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,IAGM,EAAI,EAAJ,CAAU,EAAX,CAAT,EACa,EAAb,EACa,EAAb,E,EACO,EAAP,GAEsB,EAAG,EAAnB,EAAR,E,EACe,EAAD,CAAI,EAAG,EAAd,CAAP,GAqeE,EACS,EAAT,EACS,EAAT,EAEI,EAAI,EAAJ,GAAQ,EAAS,E,EAAI,E,EAAI,E,EA1dvB,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAyB,EAAI,EAAJ,CAAS,SAAK,EAAI,SAAJ,CAAL,CAAT,CAAzB,CAAR,EACQ,EAAI,EAAJ,CAAR,EACK,EAAD,CAAJ,EACS,EAAI,EAAK,SAAK,EAAI,EAAJ,CAAL,CAAL,CAAJ,CAAP,GAEO,EAAM,EAAK,SAAM,EAAN,CAAU,EAAI,EAAJ,CAAV,CAAL,CAAwB,EAAxB,CAA6B,EAAI,SAAJ,CAA9B,CAAL,CAAP,MAmdkC,EAAS,E,EAAI,E,EAnczC,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,EAAK,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAL,CAA+B,EAAI,EAAJ,CAAS,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAT,CAA/B,CAAR,EACS,SAAM,EAAN,CAAT,EACI,SAAM,EAAN,CAAJ,EACO,EAAO,SAAM,EAAN,CAAW,EAAZ,CAAmB,EAAI,EAAJ,CAAQ,EAAI,EAAJ,CAAR,CAApB,CAAL,CAAP,IA8bE,EACQ,EAAI,EAAJ,CAAS,EAAV,GAAe,EAAD,EAAK,GAA1B,WAusB0B,EAAjB,CAAT,EACa,EAAK,E,CAAT,CAAT,EACW,EAAM,EAAN,CAAX,EAEA,EAAM,M,CAAN,EAGI,EAAM,MAAN,CAAJ,EACM,EAAK,MAAL,CAAJ,EACS,EAAP,EAEK,EAAS,E,EAAG,S,EAAK,E,EA7qCpB,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAyB,EAAI,EAAJ,CAAS,SAAK,EAAI,SAAJ,CAAL,CAAT,CAAzB,CAAR,EACQ,EAAI,EAAJ,CAAR,EACK,EAAD,CAAJ,EACS,EAAI,EAAK,SAAK,EAAI,EAAJ,CAAL,CAAL,CAAJ,CAAP,GAEO,EAAM,EAAK,SAAM,EAAN,CAAU,EAAI,EAAJ,CAAV,CAAL,CAAwB,EAAxB,CAA6B,EAAI,SAAJ,CAA9B,CAAL,CAAP,KAsqCE,EAIE,EAAM,MAAN,CAAJ,EAA6B,EAAI,EAAJ,CAAP,EAGb,EAAQ,E,EAAG,E,EAAG,E,EApwCV,EAAK,E,CAAX,CAAiB,MAAjB,CAAT,EAEI,EAAmB,EAAnB,C,CACE,EAAK,MAAL,CADoB,EAEd,EAAR,EACK,EAAD,CAAJ,EACM,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,IAGE,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEE,EAAJ,GAEW,EAAb,EACa,EAAb,EACO,EAAP,GAIA,EAAK,MAAL,CAAJ,EAEmB,EAAI,SAAJ,CAAR,CAAT,EACS,EAAI,EAAI,SAAJ,CAAJ,CAAT,EACS,EAAI,SAAJ,CAAT,EACS,EAAM,EAAN,CAAT,EACS,EAAI,EAAJ,CAAT,EACgC,EAAjB,CAAwB,E,CAA9B,CAAT,EACS,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAT,EAEI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,EAC4B,EAAjB,CAAwB,E,CAA9B,CAAL,EACI,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,IAGM,EAAI,EAAJ,CAAU,EAAX,CAAT,EACa,EAAb,EACa,EAAb,E,EACO,EAAP,GAEsB,EAAG,EAAnB,EAAR,E,EACe,EAAD,CAAI,EAAG,EAAd,CAAP,GAmsCE,EACS,EAAT,EACS,EAAT,EAEI,EAAI,EAAJ,GAAQ,EAAS,E,EAAI,E,EAjqCnB,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,EAAK,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAL,CAA+B,EAAI,EAAJ,CAAS,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAT,CAA/B,CAAR,EACS,SAAM,EAAN,CAAT,EACI,SAAM,EAAN,CAAJ,EACO,EAAO,SAAM,EAAN,CAAW,EAAZ,CAAmB,EAAI,EAAJ,CAAQ,EAAI,EAAJ,CAAR,CAApB,CAAL,CAAP,IA4pCiC,EAAS,E,EAAI,E,EAAI,E,EAxrC1C,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAyB,EAAI,EAAJ,CAAS,SAAK,EAAI,SAAJ,CAAL,CAAT,CAAzB,CAAR,EACQ,EAAI,EAAJ,CAAR,EACK,EAAD,CAAJ,EACS,EAAI,EAAK,SAAK,EAAI,EAAJ,CAAL,CAAL,CAAJ,CAAP,GAEO,EAAM,EAAK,SAAM,EAAN,CAAU,EAAI,EAAJ,CAAV,CAAL,CAAwB,EAAxB,CAA6B,EAAI,SAAJ,CAA9B,CAAL,CAAP,MAirCA,EACO,EAAI,EAAJ,GAAS,EAAD,EAAK,GAApB,I,EPjjCiB,EAAa,EAAT,EAAJ,CAAqB,EAAa,EAAT,EAAJ,CAAjC,EAAP,IGjZO,EAAI,EAAJ,CAAP,IAOO,EAAI,EAAJ,CAAP,IAOO,EAAI,EAAJ,CAAP,IAOO,EAAI,EAAJ,CAAP,SIqhDuB,EAAjB,CAAuB,SAAvB,CAAJ,EAI+B,EAAuB,EAAnB,CAAJ,CAA2B,EAAjD,CAAP,EAEwB,EAAjB,CAAT,EAC0B,EAAjB,CAAT,EACa,EAAM,EAAN,CAAW,GAAf,CAAT,EACa,EAAM,EAAN,CAAW,GAAf,CAAT,EACS,EAAM,EAAN,CAAT,EACU,EAAM,EAAN,CAAV,EACI,EAAO,EAAP,G,GAAY,EAAM,GAAN,EAAZ,E,GAAsC,E,EAAX,EAA/B,EACU,EAAI,EAAJ,CAAR,EACO,EAAI,EAAJ,CAAP,EAEQ,EAAM,EAAN,CAAV,EACI,EAAO,EAAP,CAAJ,EACS,EAAQ,EAAO,E,CAAX,CAAJ,CAAP,EAEG,E,GAAD,CAAJ,EACE,EAAuB,EAAM,EAAN,CAAjB,C,CAAN,EACA,EAAO,EAAI,EAAJ,C,CAAP,GAEA,EAAM,EAAW,EAAX,C,CAAN,EACA,EAAM,EAAK,EAAL,C,CAAN,GAEG,E,GAAD,CAAJ,EACE,EAAuB,EAAM,EAAN,CAAjB,C,CAAN,EACA,EAAO,EAAI,EAAJ,C,CAAP,GAEA,EAAM,EAAW,EAAX,C,CAAN,EACA,EAAM,EAAK,EAAL,C,CAAN,GAEF,E,EAAO,EAAK,EAAL,C,EACD,EAAM,EAAN,CAAJ,EACM,EAAM,EAAN,CAAJ,EAAqB,SAAI,EAAJ,CAAP,EACd,EAAM,E,CAAN,GAEF,EAAO,E,CAAP,EACE,E,GAAF,E,KAEE,EAAM,EAAN,CAAJ,EACM,EAAM,EAAN,CAAJ,EAAqB,SAAI,EAAJ,CAAP,EACd,EAAM,E,CAAN,GAG2B,EAAM,EAAN,CAAjB,CAAZ,EACA,EAAM,E,CAAN,EACA,EAAO,E,CAAP,EACI,EAAK,EAAL,CAAJ,EACE,EAAM,EAAK,EAAL,C,CAAN,EACA,EAAM,EAAM,EAAN,C,CAAN,GAEA,E,EAAQ,EAAD,CAAM,EAAN,C,CAAP,GAEsB,EAAM,EAAM,EAAN,CAAN,CAAjB,CAAP,IJtkDK,EAAI,EAAJ,EAAP,IAOQ,EAAD,CAAP,IAWY,EAAL,CAAP,WIknCuB,EAAjB,CAAuB,SAAvB,CAAJ,EACM,EAAK,SAAL,CAAJ,EAAqB,EAAI,EAAJ,CAAP,EACV,EAAK,SAAL,CAAJ,EAEuC,EAAlB,CAAjB,CACA,SACA,EAAM,SAAD,CAAL,CAHK,CAAP,EAME,EAAK,SAAL,CAAJ,EAAsB,SAAI,EAAJ,CAAP,EACX,EAAK,SAAL,CAAJ,EAAqB,EAAP,EACV,EAAK,SAAL,CAAJ,EAAqB,SAAP,GAEZ,EAAmB,EAAnB,C,CACK,EAAQ,E,EAAG,E,EHqoBD,EAArB,EAC0B,EAAjB,CAAT,EAC0B,EAAjB,CAAT,EACW,EAAM,EAAN,CAAX,EACW,EAAM,EAAN,CAAX,EAEI,EAAO,EAAP,CAAgB,GAAQ,EAAR,CAAhB,G,GAAkC,EAAO,GAAP,CAAgB,GAAjB,CAA0B,GAAQ,GAAR,CAA1B,EAArC,EAKM,EAAW,E,EAtLT,EAAK,EAAL,CAAU,EAAX,CAAgB,SAAqB,EAArB,CAAhB,CAAP,GAsLE,EACO,EAAM,EAAN,CAAY,EAAb,CAAJ,EAA2B,SAAP,GAChB,EAAM,UAAN,CAAJ,EAAqC,SAAP,GACzB,EAAM,EAAN,CAAW,SAAZ,G,GAAmC,EAAM,EAAN,CAAW,SAAZ,EAAtC,EAA6E,EAAI,EAAJ,CAAP,GACjE,EAAM,EAAN,CAAY,WAAb,CAAJ,EAA4C,SAAP,GAC/B,EAAM,EAAN,CAAW,WAAZ,CAAqC,EAAM,EAAN,C,GAAF,CAApC,CAAJ,EAA4D,SAAP,GAC9C,EAAI,EAAJ,CAAP,GAEE,EAAW,E,EA9LT,EAAK,EAAL,CAAU,EAAX,CAAgB,SAAqB,EAArB,CAAhB,CAAP,GA8LE,EACW,EAAI,EAAJ,CAAT,EACQ,EAAM,E,CAAV,GAAiB,EAAS,E,EA/N1B,EAAM,EAAN,CAAW,GAAX,CAAR,EACI,EAAI,GAAJ,CAAJ,EAA2B,EAAP,GAChB,EAAI,GAAQ,EAAR,CAAJ,CAAJ,EAA2B,EAAP,GAChB,EAAW,GAAQ,EAAR,CAAa,EAAb,CAAX,CAAJ,EACI,EAAM,EAAI,EAAJ,CAAN,C,GAAJ,EAAyB,EAAP,GACd,EAAM,EAAN,C,GAAJ,EAAyB,EAAP,GACX,EAAP,GAyNyC,EAAhB,E,GAArB,EAA8C,EAAD,CAAL,GACjC,EAAU,EAAV,GAAc,SAAI,EAAJ,EAAS,GAA9B,GAGE,EAAU,EAAV,CAAJ,EAEa,EAAS,E,EArOhB,EAAM,EAAN,CAAW,GAAX,CAAR,EACI,EAAI,GAAJ,CAAJ,EAA2B,EAAP,GAChB,EAAI,GAAQ,EAAR,CAAJ,CAAJ,EAA2B,EAAP,GAChB,EAAW,GAAQ,EAAR,CAAa,EAAb,CAAX,CAAJ,EACI,EAAM,EAAI,EAAJ,CAAN,C,GAAJ,EAAyB,EAAP,GACd,EAAM,EAAN,C,GAAJ,EAAyB,EAAP,GACX,EAAP,GA+NI,EACI,EAAQ,EAAR,CAAJ,EAAuB,EAAI,EAAJ,CAAU,EAAI,EAAJ,CAAX,CAAP,GACX,EAAQ,EAAR,CAAJ,EAA2B,IAAZ,GACf,EAAQ,W,CAAR,EACA,EAAQ,G,CAAR,GAEG,EAAO,GAAP,CAAgB,GAAjB,CAA0B,GAAQ,GAAR,CAA1B,CAAJ,EAEM,EAAM,UAAN,CAAJ,EAAqC,SAAP,GACzB,EAAO,GAAP,CAAgB,GAAjB,CAAJ,EAAqC,SAAP,GACtB,EAAK,UAAL,CAA6B,EAAO,GAAP,CAA9B,GAA8C,UAAW,UAAhE,GAEE,EAAQ,EAAR,CAAJ,EAEwB,EAAI,SAAJ,CAAjB,CAAL,EACA,EAAM,W,CAAN,EACA,EAAM,EAAW,EAAX,C,CAAN,IAIK,EAAW,E,EA3LV,EAAK,UAAL,CAAV,EACiB,EAAQ,EAAK,E,CAAL,CAAR,CAAoC,G,EAA3C,CAAV,EACU,EAAY,EAAZ,CAAV,EACU,EAAM,EAAM,GAAc,EAAd,CAAN,CAAN,CAAV,EAC2B,EAAjB,CAAV,E,EACU,CAAV,EAGyB,GAAoB,EAAM,EAAI,EAAJ,CAAN,CAApB,CAAV,GAAf,EACyB,GAAoB,EAAM,EAAI,EAAJ,CAAN,CAApB,CAAV,GAAf,EACyB,GAAoB,EAAM,EAAI,EAAJ,CAAN,CAApB,CAAV,GAAf,EAK4B,EAAK,MAAL,CAAwB,MAAzB,CAAjB,CAAV,EACU,EAAI,EAAJ,CAAV,EACU,EAAM,EAAN,CAAa,SAAb,CAAV,EACU,EAAM,EAAN,CAAV,EACU,EAAM,EAAN,CAAV,EAGU,EAAK,SAAL,CAAa,EAAb,CAAV,EACU,EAAK,EAAL,CAAV,EACU,EAAK,SAAL,CAAa,EAAb,CAAV,EACU,EAAK,EAAL,CAAU,EAAV,CAAV,EAGU,SAAK,EAAL,CAAV,EACU,EAAI,EAAJ,CAAV,EACU,EAAI,EAAJ,CAAV,EAEY,SAAM,EAAN,CAAZ,EACY,EAAM,EAAN,CAAZ,EACY,EAAM,EAAN,CAAZ,EACY,EAAO,EAAK,EAAL,CAAP,CAAZ,EACY,EAAK,EAAL,CAAU,EAAV,CAAZ,EAGS,EAAO,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAO,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAO,SAAK,EAAI,SAAJ,CAAL,CAAP,CAAd,CAAP,CAAd,CAAP,CAAT,EACS,EAAM,EAAN,CAAY,EAAZ,CAAkB,EAAlB,CAAwB,EAAxB,CAAT,EACS,EAAK,EAAL,CAAT,EACW,EAAK,EAAL,CAAS,EAAT,CAAX,EAEO,EAAP,GA+IA,EACS,EAAT,EAM2B,EAAK,KAAL,CAAjB,CAAV,EACU,EAAI,EAAJ,CAAV,EAC4C,EAAjB,CAAuB,KAAvB,CAAjB,CAAV,EACU,EAAK,EAAL,CAAW,EAAX,CAAV,EACM,EAAM,EAAN,CAAN,EACM,EAAM,EAAN,CAAY,EAAI,EAAJ,CAAZ,CAAN,EAEO,EAAW,E,EAAK,E,EAAK,E,EA7HF,EAAjB,CAAT,EACa,EAAM,E,CAAV,CAAgB,GAAhB,CAAT,EACI,EAAS,GAAT,CAAkB,EAAlB,CAAJ,EACM,EAAS,GAAT,CAAkB,MAAlB,CAAJ,EAGgB,SAAM,SAAK,EAAlB,CAAP,GAEE,EAAU,GAAV,CAAJ,EAES,EAAU,EAAV,GACH,EAAM,E,EAnIP,EAAM,E,EAAuB,UAAjB,C,EANJ,EAAD,CAAI,EAAG,EAAd,CAAsB,EAAtB,CAAP,GAMA,IAoIQ,EAAM,E,EA9HP,EAAM,E,EAAuB,WAAjB,C,EAZJ,EAAD,CAAI,EAAG,EAAd,CAAsB,EAAtB,CAAP,GAYA,IA4HI,GAKO,EAAT,GAKE,SAAU,EAAV,CAAJ,EAYM,EAAI,SAAJ,CAAN,EACuB,EAAjB,CAAN,EACA,EAAM,S,CAAN,EAEI,EAAI,EAAK,SAAL,CAAJ,CAAqB,EAAK,SAAL,CAArB,CAAJ,EAEA,EAAK,E,CAAL,EAEa,EAAK,G,CAAL,CAAgB,E,CAAvB,CAAN,EACO,EAAK,E,CAAL,CAAoB,EAAK,E,CAAL,CAArB,CAAN,EAEkC,GAAgB,EAAO,EAAP,CAAhB,CAAV,GAAjB,CAAP,EAEkB,GAAgB,EAAO,EAAP,CAAhB,CAAV,GAAyE,EAAzE,CAAR,EAGK,EAAI,EAAJ,CAAL,EAGM,EAAO,EAAP,CAAW,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAX,CAAgC,EAAK,EAAL,CAAW,SAAK,EAAI,SAAJ,CAAL,CAAX,CAAhC,CAAN,EACI,EAAU,EAAV,CAAJ,EAAwB,EAAY,E,EAAK,E,EAAO,E,EAztC1C,EAAK,MAAL,C,GAAF,CAAJ,EAEE,EAAS,GAAa,EAAb,C,CAAT,EACyB,EAAjB,CAAR,EACO,SAAY,EAAQ,EAAQ,EAAR,CAAR,CAAZ,CAAP,GAGF,EAAS,GAAa,EAAb,C,CAAT,EAEyB,EAAjB,CAAR,EACQ,EAAQ,EAAQ,EAAR,CAAR,CAAR,EACQ,EAAJ,CAAS,SAAT,CAAJ,EAKqB,SAAK,EAAd,CAAV,EACS,EAAQ,EAAR,CAAY,EAAQ,EAAR,CAAZ,CAAT,EACS,EAAM,EAAN,CAAT,EACK,EAAM,EAAN,CAAW,EAAX,CAAe,EAAf,CAAL,EACM,EAAK,EAAL,CAAW,EAAZ,CAAL,EAEI,EAAK,SAAL,CAAJ,EAAmC,EAAQ,WAAR,CAAjB,CAAJ,IAET,EAAI,SAAJ,CAAP,GAisCiB,GACQ,EAAjB,CAAR,EAGO,EAAQ,EAAQ,EAAR,CAAR,CAAP,GAqEA,GGnsB4B,IJxnCZ,EAAG,EAAZ,EAAP,IAOO,EAAI,EAAJ,CAAP,IAOO,EAAI,EAAJ,CAAQ,EAAR,CAAP,IAOI,EAAK,SAAL,CAAJ,EACkB,EAAG,SAAM,SAAN,CAAZ,EAAP,EAEgB,EAAD,CAAI,SAAM,SAAN,CAAb,EAAD,CAAP,MAOI,EAAK,SAAL,CAAJ,EAAqB,EAAP,EACV,EAAK,SAAL,CAAJ,EACkB,EAAG,SAAM,EAAN,CAAZ,EAAP,E,EAGW,EAAb,E,EACI,CAAa,EAAb,GAAmB,EAAO,EAAP,CAAa,EAAd,E,GAAtB,EACoB,EAAD,CAAI,SAAM,EAAN,CAAb,EAAD,CAAP,EAEK,EAAP,WI+pBM,EAAmB,EAAnB,C,CACK,EAAQ,E,EHjIO,EAAjB,CAAT,EACiB,EAAM,E,CAAV,CAAgB,GAAhB,CAAb,EACI,EAAS,GAAT,CAAkB,EAAlB,CAAJ,EACM,EAAS,GAAT,CAAkB,MAAlB,CAAJ,EAAyC,SAAP,GAC9B,EAAU,GAAV,CAAJ,EACM,EAAM,SAAN,CAAJ,EAAqC,SAAP,GAC1B,EAAU,GAAV,CAAJ,EACS,SAAM,EAAN,CAAP,GAEmB,SAAG,SAAU,EAAU,EAAV,CAAzB,CAAP,KAIK,EAAT,GAKM,SAAU,EAAV,CAAR,EAWS,EAAI,SAAJ,CAAT,EAC0B,EAAjB,CAAT,EACA,EAAM,S,CAAN,EAEQ,EAAI,EAAK,SAAL,CAAJ,CAAqB,EAAK,SAAL,CAArB,CAAR,EAEiB,EAAK,G,CAAL,CAAgB,E,CAAvB,CAAV,EACU,EAAO,EAAK,E,CAAL,CAAP,CAAV,EAEsC,GAAgB,EAAO,EAAP,CAAhB,CAAV,GAAjB,CAAX,EAEsB,GAAgB,EAAO,EAAP,CAAhB,CAAV,GAAyE,EAAzE,CAAZ,EAGS,EAAI,EAAJ,CAAT,EAGU,EAAO,EAAP,CAAW,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAX,CAAgC,EAAK,EAAL,CAAW,SAAK,EAAI,SAAJ,CAAL,CAAX,CAAhC,CAAV,EACI,EAAU,EAAV,CAAJ,EAAwB,EAAY,E,EAAK,E,EAAO,E,EA7F1C,EAAK,MAAL,C,GAAF,CAAJ,EAEE,EAAS,GAAa,EAAb,C,CAAT,EACyB,EAAjB,CAAR,EACO,SAAY,EAAQ,EAAQ,EAAR,CAAR,CAAZ,CAAP,GAGF,EAAS,GAAa,EAAb,C,CAAT,EAEyB,EAAjB,CAAR,EACQ,EAAQ,EAAQ,EAAR,CAAR,CAAR,EACQ,EAAJ,CAAS,SAAT,CAAJ,EAKqB,SAAK,EAAd,CAAV,EACS,EAAQ,EAAR,CAAY,EAAQ,EAAR,CAAZ,CAAT,EACS,EAAM,EAAN,CAAT,EACK,EAAM,EAAN,CAAW,EAAX,CAAe,EAAf,CAAL,EACM,EAAK,EAAL,CAAW,EAAZ,CAAL,EAEI,EAAK,SAAL,CAAJ,EAAmC,EAAQ,WAAR,CAAjB,CAAJ,IAET,EAAI,SAAJ,CAAP,GAqEiB,GACY,EAAjB,CAAZ,EAGO,EAAQ,EAAQ,EAAR,CAAR,CAAP,GG6E4B,IJppBZ,EAAT,EAAP,WIotB2B,EAAjB,CAAR,EACa,EAAK,E,CAAT,CAAe,MAAf,CAAT,EACe,EAAK,E,CAAT,CAAX,EACQ,EAAR,EACI,EAAM,MAAN,CAAJ,EACY,E,EAAN,CAAJ,EAAqB,EAAP,EACV,EAAJ,EAAiB,SAAP,EACN,EAAI,SAAJ,CAAJ,EAA4B,EAAI,SAAJ,CAAP,GAEf,SAAR,EACI,EAAK,MAAL,CAAJ,EAEI,EAAK,EAAQ,EAAR,CAAL,CACI,SAAS,EAAT,CAAmC,SAAK,EAA3B,C,CAAjB,EACA,EAAK,MAAL,CAHE,CAAJ,E,EAKI,CAAJ,EACS,EAAI,EAAI,SAAJ,CAAJ,CAAT,EACS,EAAI,SAAJ,CAAT,EACI,EAAK,EAAL,CAAJ,EACK,EAAK,EAAL,CAAU,EAAX,CAAJ,GACS,EAAK,MAAL,CAAJ,EAA4B,EAAP,GAClB,SAAM,EAAN,CAAV,EACU,EAAI,EAAJ,CAAV,EAEU,EAAM,EAAN,CAAV,EACU,SAAM,EAAM,SAAN,CAAN,CAAkB,EAAQ,SAAK,EAAM,SAAN,CAAL,CAAiB,EAAO,SAAK,EAAM,SAAN,CAAL,CAAP,CAAlB,CAAP,CAAnB,CAAT,EACI,SAAM,EAAK,EAAL,CAAN,CAAJ,EACQ,EAAQ,EAAK,EAAL,CAAW,SAAM,EAAI,EAAJ,CAAN,CAAZ,CAAP,CAAR,EACI,EAAK,EAAL,CAAJ,EAAmB,EAAK,EAAI,EAAJ,CAAQ,EAAR,CAAL,CAAP,EACR,EAAK,EAAI,EAAJ,CAAL,CAAc,EAAd,CAAJ,EACA,EAAK,E,CAAL,EACI,EAAK,EAAL,CAAJ,EAAoB,SAAO,EAAI,EAAJ,CAAP,CAAgB,SAAhB,CAAP,EACT,EAAK,EAAL,CAAJ,EACM,EAAI,SAAJ,CAAJ,EAAsB,SAAQ,EAAK,EAAI,SAAJ,CAAL,CAAR,CAAP,EACR,SAAM,SAAO,EAAI,EAAJ,CAAP,CAAN,CAAP,EAEG,GAAQ,E,CAAR,CAAc,EAAf,CAAJ,EAC6B,EAAjB,CAAZ,EAEI,EAAI,EAAJ,G,GAAS,EAAI,EAAJ,EAAb,EACM,EAAI,EAAJ,CAAQ,SAAR,CAAJ,EACI,EAAK,GAAL,CAAJ,EAAmB,EAAI,SAAJ,CAAU,SAAV,CAAJ,GACN,EAAI,EAAJ,CAAJ,GACE,EAAI,SAAJ,CAAP,EAEG,GAAQ,E,CAAR,CAAc,EAAf,CAAJ,EACqB,EAAjB,CAAJ,EACI,EAAI,EAAJ,CAAJ,EAAiB,SAAI,EAAJ,CAAS,EAAV,CAAJ,GACH,SAAK,EAAI,EAAJ,CAAL,CAAJ,GACG,EAAI,EAAJ,CAAS,EAAV,CAAP,IJ/vBgB,EAAX,EAAP,WIu0BM,EAAmB,EAAnB,C,CACK,EAAQ,E,EHqcO,EAAjB,CAAT,EACI,EAAK,UAAL,CAAU,UAAK,UAAL,CAAV,CAAJ,EACW,EAAI,SAAJ,CAAT,EACS,EAAI,EAAJ,CAAT,EACS,EAAK,EAAL,CAAT,EAEE,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAK,SAAL,CAAd,CACN,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAK,SAAL,CAAd,CACN,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAK,SAAL,CAAd,CAAwB,EAAK,SAAL,CAAxB,CAAN,CADM,CAAN,CADM,CAAN,CADF,EAKU,EAAI,SAAJ,CAAV,EACU,EAAI,EAAJ,CAAQ,EAAR,CAAV,EACU,EAAI,EAAJ,CAAV,EACI,EAAM,EAAN,CAAY,SAAZ,CAAJ,EACS,EAAI,EAAJ,CAAT,EACS,EAAI,EAAJ,CAAS,EAAT,CAAT,EACA,EAAM,SAAK,EAAL,CAAY,EAAM,EAAN,CAAZ,C,CAAN,EACO,EAAI,EAAJ,CAAS,EAAT,CAAP,GAEY,EAAM,E,CAAV,CAAV,EACI,EAAM,EAAN,CAAgB,IAAS,EAAT,CAAhB,CAAJ,EAEO,EAAM,EAAN,CAAY,EAAb,CAAJ,EAA2B,SAAQ,EAAI,EAAJ,CAAR,CAAP,GAChB,EAAuB,SAAjB,CAAN,CAAJ,EAA6C,EAAP,GACjC,EAAM,IAAN,CAAD,E,GAAmB,EAAM,IAAN,CAAiB,IAAlB,EAAtB,EAAwD,EAAI,EAAJ,CAAU,EAAI,EAAJ,CAAX,CAAP,GAE1B,EAAI,SAAJ,CAAjB,CAAL,EACA,EAAM,EAAW,EAAX,C,CAAN,GAMS,EAAK,UAAL,CAAX,EACoB,EAAQ,EAAK,E,CAAL,CAAR,CAAgC,G,EAAzC,CAAX,EACW,EAAY,EAAZ,CAAX,EACW,EAAM,EAAO,GAAc,EAAd,CAAP,CAAN,CAAX,EAEqB,GAAiB,EAAM,EAAI,EAAJ,CAAN,CAAjB,CAAV,GAAX,EACqB,GAAiB,EAAM,EAAI,EAAJ,CAAN,CAAjB,CAAV,GAAX,EAC4B,EAAjB,CAAX,EASsB,IAAiB,EAAM,EAAI,EAAJ,CAAN,CAAjB,CAAV,GAAZ,EACsB,IAAiB,EAAM,EAAI,EAAJ,CAAN,CAAjB,CAAV,GAAZ,EACS,EAAI,EAAJ,CAAU,EAAV,CAAiB,EAAlB,CAAR,E,EAES,CAAT,EAGS,EAAK,SAAL,CAAa,EAAb,CAAT,EACS,EAAI,EAAJ,CAAT,EACS,EAAI,EAAJ,CAAS,EAAT,CAAa,EAAK,SAAL,CAAb,CAAT,EAGS,EAAI,EAAJ,CAAT,EAKO,EAAK,EAAK,SAAL,CAAL,CAAe,EAAI,EAAJ,CAAU,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAd,CAAV,CAAf,CAA6D,EAA7D,CAAP,GGxgB4B,IJh0BZ,EAAT,EAAP,WIu7B2B,EAAjB,CAAR,EACa,EAAK,E,CAAT,CAAT,EACQ,EAAR,EACQ,S,EAAS,S,EACb,EAAK,MAAL,G,GAAwB,EAAM,EAAX,EAAvB,EACM,EAAM,MAAN,CAAJ,EACM,EAAK,SAAL,CAAJ,EAAoB,EAAI,SAAJ,CAAP,EACL,EAAI,EAAJ,CAAS,SAAV,CAAP,EAEE,EAAM,EAAN,CAAU,MAAc,EAAd,CAAV,CAAJ,EAAsC,EAAP,EAC3B,EAAM,MAAN,CAAJ,EACM,EAAJ,EACI,SAAJ,EACI,EAAJ,IAEO,EAAM,MAAN,CAAJ,EAA6B,EAAP,GACzB,EAAJ,EACuB,SAAI,EAAJ,CAAjB,CAAJ,EACa,EAAK,E,CAAT,CAAT,EACA,EAAM,MAAa,MAAb,C,CAAN,EACQ,EAAM,EAAV,CAAgB,GAAhB,CAAJ,EACI,EAAI,EAAJ,CAAJ,EAC4B,EAAjB,CAAT,EACI,EAAK,EAAL,GAAS,SAAK,EAAK,EAAL,CAAL,EAAe,EAAK,EAAK,SAAL,CAAL,EAA5B,EACA,EAAK,E,CAAL,GACS,SAAJ,GACD,EAAK,IAAL,CAAmB,MAApB,CAAL,E,EACI,CAAW,EAAX,CAAiB,EAAI,MAAJ,CAAjB,CAAJ,EACqB,EAAjB,CAAsB,SAAtB,CAAJ,GAES,SAAM,EAAN,CAAU,EAAV,CAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACS,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAT,EACS,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAT,EACQ,EAAK,EAAL,CAAR,E,EACS,CAAT,EACO,EAAK,EAAO,EAAP,CAAL,CAAkB,EAAK,SAAL,CAAc,EAAd,CAAlB,CAAqC,EAArC,CAA4C,EAA5C,CAAgD,EAAK,SAAL,CAAhD,CAAP,IJt9BgB,EAAX,EAAP,WIy3B2B,EAAjB,CAAR,EACa,EAAK,E,CAAT,CAAT,EACQ,EAAR,EACW,EAAM,EAAN,CAAX,EACI,I,GAAQ,EAAK,KAAL,EAAZ,EACM,EAAK,EAAL,CAAU,EAAV,CAAJ,EAAwB,SAAM,EAAI,EAAJ,CAAN,CAAP,EACb,EAAJ,EAAkB,EAAI,EAAJ,CAAS,SAAV,CAAP,EACV,EAAK,E,CAAL,EACA,EAAK,S,CAAL,EACqB,EAAjB,CAAJ,EACS,EAAK,E,CAAT,CAAL,GACS,EAAM,MAAN,CAAJ,EACE,EAAP,EACS,EAAM,MAAN,GAAoB,EAAK,EAAL,CAAW,EAAX,E,GAAxB,EACE,SAAP,IAEF,EAAM,MAAa,MAAb,C,CAAN,EACA,EAAS,EAAM,EAAV,CAAgB,GAAhB,C,CAAL,EACM,EAAK,IAAL,CAAmB,MAApB,CAAL,E,EACI,CAAW,EAAX,CAAiB,EAAI,MAAJ,CAAjB,CAAJ,EACqB,EAAjB,CAAJ,EACQ,EAAI,SAAJ,CAAR,EACW,SAAM,EAAN,CAAU,EAAV,CAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAR,EACQ,EAAI,EAAJ,CAAR,EACQ,EAAI,EAAJ,CAAR,EACS,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAT,EACS,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAT,EACQ,EAAK,EAAL,CAAR,EACS,EAAI,EAAJ,CAAT,EACqB,EAAjB,CAAJ,EACA,EAAK,M,CAAL,EACsB,EAAjB,CAAL,EACS,EAAI,EAAJ,CAAS,EAAT,CAAgB,EAAK,EAAO,EAAP,CAAL,CAAhB,CAAT,EACa,EAAK,SAAL,CAAb,E,EACS,CAAT,EACQ,EAAK,SAAL,CAAR,EACa,EAAK,SAAL,CAAkB,EAAK,EAAL,CAAW,SAAZ,CAAjB,CAAwC,EAAK,SAAL,CAAxC,CAAb,EACI,EAAI,EAAJ,CAAJ,EACA,EAAW,EAAI,EAAJ,CAAS,EAAV,C,CAAV,EACO,EAAS,EAAT,CAAP,IJ15BgB,EAAX,EAAP,WIm9BM,EAAmB,EAAnB,C,CACK,EAAS,E,EH1HM,EAAjB,CAAT,EACI,EAAK,UAAL,CAAU,UAAK,UAAL,CAAV,CAAJ,EACU,EAAI,SAAJ,CAAR,EAK4C,EAAjB,CAAsB,MAAtB,CAAjB,CAAV,EACU,EAAI,EAAJ,CAAV,EACU,EAAM,SAAN,CAAV,EACU,EAAM,SAAN,CAAiB,EAAI,SAAJ,CAAjB,CAAV,EAES,EAAI,EAAJ,CAAT,EACS,EAAK,EAAL,CAAT,EAEQ,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAR,EACQ,EAAK,EAAL,CAAR,EACA,EAAM,EAAK,EAAL,CAAS,EAAT,C,CAAN,EACA,EAAM,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAd,CACN,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAd,CAAN,CADM,CAAN,C,CAAN,EAEO,EAAI,EAAJ,CAAP,GAEY,EAAM,E,CAAV,CAAV,EACI,EAAM,EAAN,CAAgB,IAAS,EAAT,CAAhB,CAAJ,EAEO,EAAM,EAAN,CAAY,EAAb,CAAJ,EAA2B,SAAQ,EAAI,EAAJ,CAAR,CAAP,GAChB,EAAM,WAAN,CAAJ,EAAqC,EAAP,GACzB,EAAM,IAAN,CAAD,E,GAAmB,EAAM,IAAN,CAAiB,IAAlB,EAAtB,EAAwD,EAAI,EAAJ,CAAU,EAAI,EAAJ,CAAX,CAAP,GAE1B,EAAI,SAAJ,CAAjB,CAAL,EACA,EAAM,EAAW,EAAX,C,CAAN,GAMS,EAAK,UAAL,CAAX,EACoB,EAAQ,EAAK,E,CAAL,CAAR,CAAiC,E,EAA1C,CAAX,EACW,EAAY,EAAZ,CAAX,EACW,EAAM,EAAM,SAAN,CAAN,CAAX,EAEqB,IAAmB,EAAM,EAAI,EAAJ,CAAN,CAAnB,CAAV,GAAX,EACqB,IAAmB,EAAM,EAAI,EAAJ,CAAN,CAAnB,CAAV,GAAX,EAC4B,EAAjB,CAAX,E,EACW,CAAX,EAWoB,IAAkB,EAAM,EAAI,EAAJ,CAAN,CAAlB,CAAV,GAAV,EACoB,IAAkB,EAAM,EAAI,EAAJ,CAAN,CAAlB,CAAV,GAAV,EAEW,EAAI,EAAJ,CAAU,EAAV,CAAiB,EAAlB,CAAV,EAC4C,EAAjB,CAAsB,MAAtB,CAAjB,CAAV,EACU,EAAI,EAAJ,CAAV,EACU,EAAM,SAAN,CAAV,EACU,EAAM,SAAN,CAAiB,EAAI,SAAJ,CAAjB,CAAV,EAIS,EAAK,EAAL,CAAT,EACS,EAAK,EAAL,CAAT,EACS,EAAK,EAAL,CAAU,EAAV,CAAe,EAAf,CAAT,EAIS,EAAI,EAAJ,CAAT,EAGQ,SAAK,EAAI,SAAJ,CAAL,CAAc,EAAM,SAAK,EAAI,SAAJ,CAAL,CAAN,CAAd,CAAoC,EAAK,EAAL,CAAY,SAAK,EAAI,SAAJ,CAAL,CAAb,CAAnC,CAAR,EACO,EAAK,EAAK,EAAL,CAAL,CAAc,EAAd,CAAP,GG6C4B,IJ58BX,EAAV,EAAP,IAWgB,EAAT,EAAP,IAOgB,EAAT,EAAP,SIkKgC,EAAjB,CAAuB,E,CAA7B,CAAT,EACS,EAAK,MAAL,CAAT,EACU,EAAM,MAAN,CAAV,EACI,EAAJ,EACM,EAAK,EAAL,CAAJ,EAAmB,EAAD,CAAJ,EAAa,EAAD,CAAJ,GAClB,SAAO,EAAP,CAAJ,EACI,SAAS,EAAT,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACI,SAAJ,GAEE,EAAI,EAAJ,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACI,SAAK,EAAK,SAAK,EAAK,SAAK,EAAK,SAAK,EAAK,SAAK,EAAI,SAAJ,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAJ,EACI,EAAK,SAAK,EAAK,SAAK,EAAK,SAAK,EAAK,SAAK,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAL,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACI,EAAI,EAAK,EAAK,EAAI,EAAJ,CAAL,CAAc,EAAd,CAAL,CAAJ,CAAJ,EACA,EAAK,SAAK,EAAL,C,CAAL,EACI,EAAI,EAAJ,CAAJ,EACI,EAAJ,EACM,E,CAAJ,EACQ,SAAM,EAAM,EAAN,CAAY,EAAb,C,CAAL,CAAyB,EAAI,SAAO,EAAK,EAAI,EAAJ,CAAS,EAAI,EAAJ,CAAT,CAAkB,EAAlB,CAAL,CAAP,CAAJ,CAA1B,CAAP,EAEE,EAAM,EAAN,CAAJ,EAAoB,EAAP,EAET,EAAJ,EACsC,EAAjB,CAAsB,MAAtB,CAAjB,CAAJ,EACI,EAAK,EAAI,EAAJ,CAAL,CAAJ,EACS,SAAD,CAAO,EAAP,CAAJ,EAAJ,EACsC,EAAjB,CAAsB,MAAtB,CAAjB,CAAJ,EACI,SAAM,EAAI,EAAJ,CAAN,CAAJ,EACO,EAAI,EAAK,EAAI,EAAI,EAAJ,CAAJ,CAAL,CAAJ,CAAP,WA+nC2B,EAAjB,CAAR,EACa,EAAK,E,CAAT,CAAT,EACW,EAAO,EAAP,CAAX,EAEA,EAAM,M,CAAN,EAGI,EAAM,MAAN,CAAJ,EACM,EAAK,MAAL,CAAJ,EACS,EAAP,EAEc,EAAG,SAAK,EAAjB,EAAP,EAIE,EAAM,MAAN,CAAJ,EAA6B,EAAI,EAAJ,CAAP,EAEd,EAAQ,E,EAAG,E,EAAG,E,EApzCT,EAAK,E,CAAX,CAAiB,MAAjB,CAAT,EAEI,EAAmB,EAAnB,C,CACE,EAAK,MAAL,CADoB,EAEd,EAAR,EACK,EAAD,CAAJ,EACM,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,IAGE,EAAI,SAAJ,CAAJ,EACI,EAAM,MAAN,CAAJ,EACO,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEA,EAAK,S,CAAL,EACK,EAAI,SAAJ,CAAL,EACM,EAAI,EAAJ,CAAU,SAAX,CAAL,GAEE,EAAJ,GAEW,EAAb,EACa,EAAb,EACO,EAAP,GAIA,EAAK,MAAL,CAAJ,EAEmB,EAAI,SAAJ,CAAR,CAAT,EACS,EAAI,EAAI,SAAJ,CAAJ,CAAT,EACS,EAAI,SAAJ,CAAT,EACS,EAAM,EAAN,CAAT,EACS,EAAI,EAAJ,CAAT,EACgC,EAAjB,CAAwB,E,CAA9B,CAAT,EACS,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAT,EAEI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,EAC4B,EAAjB,CAAwB,E,CAA9B,CAAL,EACI,EAAM,EAAM,EAAN,CAAY,GAAb,CAAL,CAAJ,EACI,EAAI,EAAJ,CAAJ,EACU,EAAR,EACK,EAAI,SAAJ,CAAL,EACK,EAAI,EAAJ,CAAL,EACK,EAAI,SAAJ,CAAgB,EAAI,EAAJ,CAAS,EAAV,CAAf,CAAL,EACK,EAAI,EAAJ,CAAL,IAGM,EAAI,EAAJ,CAAU,EAAX,CAAT,EACa,EAAb,EACa,EAAb,E,EACO,EAAP,GAEsB,EAAG,EAAnB,EAAR,E,EACe,EAAD,CAAI,EAAG,EAAd,CAAP,GAmvCE,EACgB,EAAY,EAAY,EAAM,EAAI,EAAJ,CAAU,EAAX,CAAL,CAAjC,EAAP,IJ10Cc,EAAT,EAAP,OI1HQ,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAR,EACQ,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAR,EACO,EAAI,EAAJ,CAAP,SAwckC,EAAjB,CAAuB,E,CAA7B,CAAT,EACS,EAAK,MAAL,CAAT,EACI,EAAM,MAAN,CAAJ,EACiC,E,CAAtB,CAAT,EACK,EAAK,MAAL,CAAkB,EAAlB,CAAyB,EAA1B,CAAJ,EAAwC,EAAI,SAAJ,CAAc,K,CAAd,CAAP,EAC1B,SAAK,EAAI,EAAJ,CAAL,CAAP,EAEE,EAAK,MAAL,CAAJ,EACM,EAAK,MAAL,GAAmB,EAAM,KAAN,E,GAAvB,EAAgD,EAAP,EAClC,EAAI,EAAM,EAAI,EAAJ,CAAF,EAAJ,CAAJ,CAAP,EAGM,SAAuB,EAAjB,CAAsB,SAAtB,CAAN,CAAR,EAC0B,EAAlB,CAAR,EACU,EAAF,EAAR,EACI,EAAM,MAAN,CAAJ,EAA0B,SAAW,SAAK,EAAI,EAAI,EAAJ,CAAJ,CAAL,CAAkB,SAAlB,CAAX,CAAJ,GAEsB,EAAjB,CAAsB,MAAtB,CAAjB,CAAR,EACS,EAAI,EAAI,EAAJ,CAAJ,CAAc,EAAI,EAAJ,CAAf,CAAR,EACI,SAAM,SAAN,CAAiB,SAAI,EAAJ,CAAQ,EAAR,CAAa,SAAU,SAAI,EAAJ,CAAV,CAAb,CAAiC,SAAM,SAAN,CAAgB,SAAI,EAAJ,CAAhB,CAAjC,CAAjB,CAAJ,GAEa,EAAD,CAAI,EAAG,EAAU,EAAV,CAAd,CAAP,IJ9Ve,EAAV,EAAP,SIwRkC,EAAjB,CAAuB,E,CAA7B,CAAT,EACS,EAAK,MAAL,CAAT,EACI,EAAM,MAAN,CAAJ,EACiC,E,CAAtB,CAAT,EACK,EAAK,MAAL,CAAkB,EAAlB,CAAyB,EAA1B,CAAJ,EACM,EAAU,EAAV,CAAJ,EAAwB,SAAI,SAAJ,CAAc,K,CAAd,CAAP,EACV,SAAP,EAEK,SAAK,EAAI,EAAJ,CAAL,CAAP,EAEE,EAAK,MAAL,CAAJ,EACM,EAAM,MAAN,CAAJ,EAA6B,SAAU,K,CAAV,CAAP,EACf,SAAW,EAAK,SAAU,EAAM,EAAI,EAAJ,CAAF,EAAJ,CAAV,CAAL,CAAX,CAAP,EAGE,EAAU,EAAV,CAAJ,EAEM,SAAM,EAAI,SAAJ,CAAN,CAAJ,EACsB,EAAlB,CAAJ,EACM,EAAF,EAAO,EAAP,CAAW,SAAX,CAAJ,EACO,SAAK,SAAW,EAAI,EAAJ,CAAX,CAAL,CAAP,EAGE,SAAM,EAAI,SAAJ,CAAN,CAAJ,EACsB,EAAlB,CAAJ,EAC2C,EAAjB,CAAsB,MAAtB,CAAjB,CAAT,EACS,EAAI,EAAK,EAAL,CAAJ,CAAgB,EAAI,EAAJ,CAAjB,CAAR,EACM,EAAF,EAAO,EAAP,CAAW,EAAX,CAAJ,EACO,SAAK,EAAK,EAAL,CAAL,CAAP,IJ7Se,EAAV,EAAP,SI4XkC,EAAjB,CAAuB,E,CAA7B,CAAT,EACS,EAAT,EACA,EAAM,M,CAAN,EAEI,EAAM,MAAN,CAAJ,EACY,E,EAAN,CAAJ,EAAqB,EAAP,EACV,SAAU,K,CAAV,CAAJ,EAC6B,EAAG,EAAzB,CAAP,EAGE,EAAK,MAAL,CAAJ,EACM,EAAK,MAAL,CAAJ,EAA4B,EAAP,EAChB,EAAL,GAEqB,EAAjB,CAAJ,EACI,EAAK,MAAL,CAAJ,EACM,EAAK,MAAL,CAAJ,EACO,EAAL,EACK,SAAM,EAAN,CAAU,SAAV,CAAkB,SAAM,EAAN,CAAnB,CAAJ,GAEK,EAAL,EACK,EAAI,SAAJ,CAAY,EAAI,SAAJ,CAAb,CAAJ,IAGE,EAAK,MAAL,CAAJ,EACO,EAAL,EACK,EAAI,SAAJ,CAAY,SAAM,SAAM,EAAN,CAAN,CAAb,CAAJ,GAEK,EAAL,EACI,SAAO,EAAP,CAAJ,KAIF,EAAI,EAAJ,CAAJ,EACQ,EAAI,EAAJ,CAAR,EACS,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAT,EACS,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAK,SAAM,EAAI,SAAJ,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAN,CAAL,CAAT,EACS,EAAK,EAAK,EAAL,CAAL,CAAT,EACI,EAAK,EAAL,CAAJ,EAAmB,EAAI,EAAJ,CAAP,EACZ,YAAQ,E,IACD,E,KACA,E,KACA,E,KACA,E,MAHG,AAAM,SAAY,EAAK,SAAL,CAAgB,EAAjB,CAAX,CAAJ,EAAoC,GACtC,AAAM,SAAY,EAAK,SAAL,CAAgB,EAAjB,CAAX,CAAJ,EAAoC,GACtC,AAAM,SAAY,EAAK,SAAL,CAAgB,EAAjB,CAAX,CAAJ,EAAoC,GACtC,AAAM,SAAY,EAAK,SAAL,CAAgB,EAAjB,CAAX,CAAJ,EAAoC,GACrC,EAEkB,EAAG,EAAzB,CAAP,IJnae,EAAV,EAAP,WIobY,E,EAAN,G,GAAkB,E,EAAN,EAAhB,EAAiC,EAAI,EAAJ,CAAP,EACD,EAAjB,CAAR,EACe,EAAK,E,CAAX,CAAT,E,EACS,CAAT,EACqB,EAAjB,CAAJ,EACe,EAAK,E,CAAX,CAAT,E,EACS,CAAT,EACK,EAAK,MAAL,CAAkB,EAAlB,CAAyB,EAA1B,CAAJ,EAA6C,EAAL,EAAP,EACvB,EAAM,EAAN,CAAY,EAAb,CAAoB,EAAM,EAAN,CAAY,EAAb,CAApB,CAAR,EACK,EAAK,MAAL,CAAL,EACK,EAAK,MAAL,CAAL,EACK,EAAK,EAAL,CAAY,EAAb,CAAJ,EACE,UAAQ,E,IACD,E,KACA,E,KACA,E,KACA,E,OAFW,EAAR,EACQ,EAAR,EACQ,EAAD,CAAP,GAGP,EAAK,EAAL,CAAY,EAAb,CAAJ,EAA2B,EAAI,EAAJ,GAAS,EAAD,CAAM,SAAN,EAAU,EAAK,SAAL,EAAzB,EAChB,EAAM,MAAN,CAAJ,EACM,EAAM,MAAN,CAAJ,EACU,EAAI,EAAJ,GAAQ,E,CAAI,EAAJ,CAAS,SAAT,EAAa,EAAK,SAAL,EAA7B,EACO,EAAI,EAAJ,GAAS,EAAD,EAAK,GAApB,EAEQ,EAAI,EAAJ,GAAQ,GAAK,UAArB,EACO,EAAI,EAAJ,GAAS,EAAD,EAAK,GAApB,IAIA,EAAM,GAAM,EAAN,CAAN,CAAkB,EAAlB,G,GAAwB,EAAM,MAAN,EAA5B,EAAqD,EAAI,EAAJ,GAAS,EAAD,CAAM,SAAN,EAAU,EAAK,SAAL,EAAzB,EACzC,EAAI,EAAJ,CAAD,EAAW,EAAM,GAAM,EAAN,CAAN,CAAkB,EAAlB,E,GAAf,EAAyC,SAAJ,GACN,EAAI,EAAJ,CAAjB,CAAL,EAAJ,GACL,UAAQ,E,IACD,E,KACA,E,KACA,E,KACA,E,MAHW,EAAR,EACQ,EAAD,CAAP,EACO,EAAM,EAAI,SAAJ,CAAN,CAAP,EACQ,EAAI,SAAJ,CAAa,EAAd,CAAP,EAEV,IJpdgB,EAAG,EAAd,EAAP,MAWoB,EAAT,EAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAiB,SAAlB,CAAP,MAOoB,EAAT,EAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAiB,SAAlB,CAAP,MAOoB,SAAM,EAAN,CAAT,EAAX,EACQ,EAAK,SAAL,CAAa,EAAK,SAAL,CAAd,CAAP,IAOgB,EAAS,EAAI,EAAJ,CAAQ,SAAR,CAAL,CAAJ,CAAT,EAAP,IAOgB,EAAS,EAAI,EAAJ,CAAQ,SAAR,CAAL,CAAJ,CAAT,EAAP,IAOO,SAAgB,SAAM,EAAN,CAAY,SAAM,EAAN,CAAb,CAAT,EAAN,CAAP,IAWW,EAAJ,CAAP,IAOa,EAAN,CAAP,IAOY,EAAL,CAAP,IAOe,EAAR,CAAP,IAOa,EAAN,CAAP,IAOI,EAAI,SAAJ,CAAJ,EAAoB,SAAP,EACT,EAAI,SAAJ,CAAJ,EAAoB,SAAP,EACN,SAAP,IAOW,EAAG,EAAP,CAAP,IAOW,EAAG,EAAP,CAAP,IAOW,EAAQ,EAAI,EAAR,CAAR,CAAP,IAWa,E,EAAN,CAAP,IAOgB,E,YAAT,CAAP,I,QSwkCS,IAAoB,EAApB,CAAP,I,QAWiB,IAAkB,EAAgB,EAAhB,CAAlB,CAAV,GAAP,QH55Ce,SAAjB,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAmB,EAAK,EAAf,E,CAAT,EADuB,E,GAAA,E,IAGlB,EAAP,QAOmB,SAAnB,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAqB,EAAK,EAAf,E,CAAX,EADuB,E,GAAA,E,IAGlB,EAAP,MAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EACG,EAAV,E,EAAkB,CAAlB,CAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAEU,EAAX,EAAb,EACqB,SAArB,EAEa,EAAR,E,EAAW,EAAI,EAAJ,C,EACS,EAAK,EAAf,EAAqB,EAArB,CAAb,EACA,EAAa,EAAO,EAAP,C,CAAb,EAFuB,E,GAAA,E,IAKlB,E,EAAY,CAAZ,CAAP,IAO2B,EAAf,EAAL,CAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAES,EAAK,EAAf,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EAA2B,EAAT,GAFK,E,GAAA,E,IAIlB,EAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAES,EAAK,EAAf,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EAA2B,EAAT,GAFK,E,GAAA,E,IAIlB,EAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAEI,EAAlB,EACuB,EAAK,EAAf,EAAb,EAEkB,EAAb,E,EAAgB,EAAI,EAAJ,C,EACG,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EACW,EAAT,EACS,EAAT,GAJ0B,E,GAAA,E,IAOvB,EAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAEI,EAAlB,EACuB,EAAK,EAAf,EAAb,EAEkB,EAAb,E,EAAgB,EAAI,EAAJ,C,EACG,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EACW,EAAT,EACS,EAAT,GAJ0B,E,GAAA,E,IAOvB,EAAP,QAOiB,SAAjB,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACA,EAAS,EAAM,EAAN,C,CAAT,EAFuB,E,GAAA,E,IAIb,EAAL,CAAP,QAOe,SAAf,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAqB,EAAK,EAAf,EAAJ,C,CAAP,EADuB,E,GAAA,E,IAGlB,EAAP,QAOkB,SAAlB,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACe,EAAK,EAAf,EAAJ,CAAf,EACI,EAAS,EAAT,CAAJ,EAA8B,EAAT,GAFE,E,GAAA,E,IAIlB,EAAP,QAWgB,I,EAAU,I,OAAd,CAAZ,EACkB,SAAlB,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAoB,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,C,CAAV,EADuB,E,GAAA,E,IAGlB,EAAP,IGwvCa,IAAkB,EAAgB,EAAhB,CAAlB,CAAmD,EAA9D,QHjvCkB,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SASL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SASL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SASL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAgB,EAAE,EAAZ,EAAD,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAmB,EAAE,EAAZ,EAAJ,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAoB,EAAE,EAAZ,EAAL,CAAtB,EADuB,E,GAAA,E,WAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAE,EAAZ,EAAZ,EACU,EAAO,EAAK,EAAM,EAAN,CAAtB,EAFuB,E,GAAA,E,SAUT,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAwB,EAAE,EAAZ,EAAT,EAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAwB,EAAE,EAAZ,EAAT,EAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAwB,EAAE,EAAZ,EAAT,EAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAwB,EAAE,EAAZ,EAAT,EAAtB,EADuB,E,GAAA,E,SAiBL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAK,EAAkB,EAAE,EAAZ,EAAR,CAA0B,EAAiB,EAAE,EAAZ,EAAP,CAA1B,CAAtB,EADuB,E,GAAA,E,WAST,I,EAAU,I,OAAd,CAAZ,EACiB,SAAjB,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACS,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAb,EACA,EAAS,EAAO,EAAP,C,CAAT,EAFuB,E,GAAA,E,IAIb,EAAL,CAAP,MAOsB,EAAG,EAAb,EAAZ,EACyB,EAAX,EAAd,EACyB,EAAX,EAAd,EACI,EAAS,SAAT,G,GAAgB,EAAS,SAAT,EAApB,EAAyC,SAAP,EAC3B,EAAO,EAAQ,EAAR,CAAP,CAAP,MAWY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAjB,EADuB,E,GAAA,E,SASb,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAjB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAjB,EADuB,E,GAAA,E,WASb,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAE,EAAZ,EAAZ,EACU,EAAE,EAAS,EAAQ,EAAI,EAAR,CAAR,CAAjB,EAFuB,E,GAAA,E,SAUb,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAK,EAAjB,EADuB,E,GAAA,E,SAST,I,EAAY,I,OAAhB,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAI,EAAe,EAAI,EAAd,EAAnB,EADuB,E,GAAA,E,mFIlanB,EAAc,MAAuB,EAAvB,CAAd,CAAJ,EAAyE,I,YACrB,EAAU,EAAV,CAAT,EAA8B,EAA5D,EAAb,EACI,EAAe,EAAf,C,CACU,EAA2B,EAAG,EADJ,GAGxC,EAAc,EAAd,EACA,EAAiB,EAAjB,EACA,EAAkB,EAAlB,E,qBDm4CM,EAAQ,E,EAAd,E,OE14CsB,EAAO,EAAP,CAAjB,EAAP,M,EAO8B,EAAO,EAAP,CAAjB,EAAb,EACY,EAAO,EAAP,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAK,SAApB,EADuB,E,GAAA,E,IAGlB,EAAP,M,EAO8B,EAAO,EAAP,CAAjB,EAAb,EACY,EAAO,EAAP,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAK,EAApB,EADuB,E,GAAA,E,IAGlB,EAAP,M,EAO8B,EAAI,EAAJ,CAAjB,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAI,EAAJ,CAAQ,EAAR,CAAa,SAA5B,EADqB,E,GAAA,E,IAGhB,EAAP,MAOU,IAAV,E,EAC8B,EAAI,EAAJ,CAAjB,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAI,EAAJ,CAAQ,EAAR,CAAuB,EAAO,EAAjB,EAA5B,EADqB,E,GAAA,E,IAGhB,EAAP,IAWiB,EAAK,EAAM,EAAN,CAAa,EAAb,CAAf,EAAP,IAOU,EAAK,EAAM,EAAN,CAAa,EAAb,CAAoB,EAAnC,O,EAOgC,EAAjB,EAAf,EACe,EAAM,EAAN,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAK,EAAS,EAAT,CAAf,EAAtB,EADwB,E,GAAA,E,IAGnB,EAAP,M,EAOgC,EAAjB,EAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAtB,EADwB,E,GAAA,E,IAGnB,EAAP,MAOc,E,EAAM,E,OAAV,CAAV,E,EACgC,EAAjB,EAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAtB,EADqB,E,GAAA,E,IAGhB,EAAP,MAaoB,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWT,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWT,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAtB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAgB,EAAE,EAAZ,EAAD,CAAtB,EADuB,E,GAAA,E,YAqBP,EAAQ,EAAR,CAAlB,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAK,SAAtB,EAD6B,E,GAAA,E,IAKlB,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAE,EAAI,EAAJ,CAAY,EAAZ,CAAZ,EAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAI,EAAJ,CAAY,EAAZ,CAAP,EAAO,EAAI,EAAJ,CAAY,EAAZ,CAAP,EAAyB,EAAgB,EAAE,EAAI,EAAJ,CAAY,EAAZ,CAAZ,EAAN,C,CAAnC,EADyB,E,GAAA,E,IAFF,E,GAAA,E,IADF,E,GAAA,E,WAmBd,EAAR,E,EAAW,EAAI,EAAJ,C,EACC,SAAf,EACe,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAiB,EAAE,EAAS,EAAT,CAAZ,EAAqC,EAAE,EAAZ,EAA3B,C,CAAP,EADwB,E,GAAA,E,IAGhB,EAAO,EAAK,EAAtB,EANwB,E,GAAA,E,YAoBb,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAK,SAAtB,EADwB,E,GAAA,E,IAIb,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAZ,EAAX,EACe,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAP,EAAO,EAAP,EAAa,EAAe,EAAE,EAAS,EAAT,CAAZ,EAAL,C,CAAvB,EADwB,E,GAAA,E,IAHF,E,GAAA,E,WAgBhB,IAAV,EACU,IAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAZ,EAAX,EACe,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAS,EAAT,CAAc,EAAe,EAAE,EAAZ,EAAL,CAA/B,EADqB,E,GAAA,E,IAHF,E,GAAA,E,SAoBV,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAI,EAAJ,CAAW,EAAX,CAA0B,EAAE,EAAI,EAAJ,CAAW,EAAX,CAAZ,EAAjC,EADwB,E,GAAA,E,IADF,E,GAAA,E,WAeX,SAAf,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAiB,EAAK,EAAf,E,CAAP,EADuB,E,GAAA,E,IAGlB,EAAP,MAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EACI,EAAX,G,EAAmB,CAAnB,CAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAES,EAAK,EAAf,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EAA2B,EAAT,GAFK,E,GAAA,E,IAIlB,EAAP,QAOY,IAAZ,EACI,EAAO,EAAP,CAAJ,EAAqB,EAAP,EAES,EAAK,EAAf,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACI,EAAM,EAAN,CAAJ,EAA2B,EAAT,GAFK,E,GAAA,E,IAIlB,EAAP,QAOiB,SAAjB,EACY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAf,EAAZ,EACA,EAAS,EAAM,EAAN,C,CAAT,EAFuB,E,GAAA,E,IAIb,EAAL,CAAP,QAOc,E,EAAM,E,OAAV,CAAV,EACe,SAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAiB,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,E,CAAP,EADqB,E,GAAA,E,IAGhB,EAAP,QASa,EAAR,E,EAAW,EAAI,EAAJ,C,EACC,SAAf,EACe,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAiB,EAAK,EAAS,EAAT,CAAf,E,CAAP,EADwB,E,GAAA,E,IAGhB,EAAO,EAAK,EAAtB,EANwB,E,GAAA,E,SAiBb,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAK,SAAtB,EADwB,E,GAAA,E,IAIb,EAAR,E,EAAW,EAAI,EAAJ,C,EACC,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAP,EAAO,EAAP,EAAuB,EAAK,EAAS,EAAT,CAAf,E,CAAvB,EADwB,E,GAAA,E,IAFF,E,GAAA,E,OAgBnB,EAAQ,EAAR,CAAP,QASI,EAAQ,EAAR,CAAJ,EAAyB,EAAP,EAEL,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAI,EAAJ,CAAR,E,EAAe,EAAI,EAAJ,C,EACI,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAZ,EACsB,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAZ,EACQ,EAAM,EAAN,CAAJ,CAAiB,EAAjB,CAAJ,EAAuC,EAAP,EAHJ,E,GAAA,E,IADN,E,GAAA,E,IAOnB,EAAP,MASa,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAR,E,EAAW,EAAI,EAAJ,C,EACV,EAAK,EAAL,CAAJ,EACoB,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAJ,CAAqC,EAArC,CAAJ,EAA2D,EAAP,GAF9B,E,GAAA,E,IADF,E,GAAA,E,IAOnB,EAAP,QASI,EAAQ,EAAR,CAAJ,EAAyB,EAAP,EAEL,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAR,E,EAAW,EAAI,EAAJ,C,EACQ,EAAK,EAAL,GAAS,UAAM,UAArC,EACkB,EAAK,EAAI,EAAJ,CAAW,EAAX,CAAf,EAAgC,EAAhC,CAAJ,CAAgD,EAAhD,CAAJ,EAAsE,EAAP,EAFvC,E,GAAA,E,IADF,E,GAAA,E,IAMnB,EAAP,MAWY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAe,EAAK,EAAf,EAAqB,EAArB,CAApB,EADuB,E,GAAA,E,SASb,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAe,EAAK,EAAf,EAAqB,EAArB,CAApB,EADuB,E,GAAA,E,SAST,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAjB,EADuB,E,GAAA,E,SAST,I,EAAY,I,OAAhB,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAI,EAAe,EAAI,EAAd,EAAnB,EADuB,E,GAAA,E,SAeT,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAK,EAAkB,EAAE,EAAZ,EAAR,CAAoC,EAAE,EAAZ,EAA1B,CAAjB,EADuB,E,GAAA,E,YAeZ,EAAI,EAAJ,CAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAK,EAAiB,EAAE,EAAZ,EAAP,CAAjB,EADwB,E,GAAA,E,IAKb,EAAR,E,EAAW,EAAI,EAAJ,C,EACD,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAkB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAR,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAF,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAF,EAAgB,EAAgB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAN,C,CAA1B,EADqB,E,GAAA,E,IAFF,E,GAAA,E,IADF,E,GAAA,E,WAmBV,EAAR,E,EAAW,EAAI,EAAJ,C,EACC,SAAf,EACe,EAAI,EAAJ,CAAf,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAiB,EAAE,EAAS,EAAT,CAAZ,EAAqC,EAAE,EAAZ,EAA3B,C,CAAP,EADqB,E,GAAA,E,IAGb,EAAE,EAAK,EAAQ,EAAR,CAAc,EAAiB,EAAE,EAAZ,EAAP,CAAd,CAAjB,EANqB,E,GAAA,E,yBdphBF,KAAU,KAAV,CAAoB,KAAU,KAAV,CAAhC,EAAP,IevCK,EAAM,EAAN,GAAP,I,EfqDqB,KAAU,KAAV,CAAoB,KAAU,KAAV,CAAhC,EAAP,Ie9CK,EAAM,EAAN,GAAP,I,Ef8DI,KAAU,KAAV,CAAqB,KAAU,KAAV,CAArB,CACA,KAAU,KAAV,CAAqB,KAAU,KAAV,CAArB,CAFK,EAAP,IetDK,EAAM,EAAN,GAAP,MfwEgB,KAAW,KAAX,CAAsB,KAAW,KAAX,CAAtB,CAAd,EACI,EAAS,SAAT,CAAJ,E,EACqB,EAAS,EAArB,EAAP,E,EAGC,KAAU,KAAV,CAAqB,KAAU,KAAV,CAArB,CAA2C,EAA5C,CACC,KAAU,KAAV,CAAqB,KAAU,KAAV,CAArB,CAA2C,EAA5C,CAFK,EAAP,IerEK,EAAM,EAAN,GAAP,I,EfyFsB,KAAD,CAAW,KAAD,CAAtB,EAAP,IelFK,KAAP,I,EfyFqB,KAAU,KAAD,CAArB,EAAP,IelFK,KAAP,MfyFgB,KAAU,KAAV,CAAoB,KAAU,KAAV,CAApB,CAAd,EACI,EAAS,SAAT,CAAJ,E,EACqB,EAAS,EAArB,EAAP,E,EAEiB,KAAU,EAAV,CAAkB,KAAD,CAAW,EAAX,CAA7B,EAAP,IetFK,KAAP,IfkGc,KAAU,KAAV,CAAoB,KAAU,KAAV,CAApB,CAAL,CAAP,IevFK,KAAP,IfsGoB,KAAS,KAApB,EAAP,Ie/FK,KAAP,IAOO,KAAO,KAAP,CAAc,KAAO,KAAP,CAAd,CAAP,MfoHY,KAAV,EACgB,KAAa,SAAb,CAAhB,EACmB,EAAL,CAAd,E,EACmB,EAAiB,EAAT,EAAR,CAA2B,EAAiB,EAAT,EAAR,CAAvC,EAAP,Ie5GK,KAAP,MfmHM,EAAK,SAAL,CAAJ,E,EACqB,SAAK,SAAjB,EAAP,EAEQ,KAAV,EACc,KAAd,EACoB,EAAG,EAAZ,EAAX,EACe,EAAI,EAAJ,CAAf,E,EACmB,EAAc,EAAT,EAAL,CAAuB,EAAc,EAAT,EAAL,CAAnC,EAAP,IenHK,EAAU,EAAV,GAAP,I,Ef2F8B,KAAT,EAAsB,KAAlC,EAAP,MATuB,KAAT,EAAd,E,EACmB,EAAiB,KAAT,EAAR,CAA2B,EAAiB,KAAT,EAAR,CAAvC,EAAP,Me3EW,KAAb,E,EAEE,KAAO,KAAP,CAAiB,KAAO,KAAP,CAAjB,CACA,KAAO,KAAP,CAAiB,KAAO,KAAP,CAAjB,CAFc,EAAhB,EAIO,KAAP,I,EAQE,KAAO,KAAP,CAAc,KAAO,KAAP,CAAd,CACA,SAAM,KAAN,CAAa,KAAb,CAFK,EAAP,MAUY,KAAO,KAAP,CAAZ,EACY,KAAO,KAAP,CAAZ,E,EAEE,KAAQ,EAAM,SAAM,EAAN,CAAN,CAAR,CACA,KAAQ,SAAM,EAAN,CAAY,EAAZ,CAAR,CAFK,EAAP,IAcO,KAAP,IAOO,KAAP,MAOW,KAAX,E,EAEmB,KAAQ,SAAR,CAAc,KAAQ,SAAR,CAA1B,EAAP,MAOW,KAAX,E,EAEmB,KAAQ,SAAR,CAAa,KAAQ,SAAR,CAAzB,EAAP,Mf8RoB,EAAT,EAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAiB,SAAlB,CAAP,MANoB,EAAT,EAAX,EACQ,EAAK,SAAM,EAAN,CAAL,CAAiB,SAAlB,CAAP,I,EAnNa,KAAT,EAAyB,KAAL,GAApB,CACS,KAAT,EAAyB,KAAL,GAApB,CAFK,EAAP,Ie3DK,KAAP,I,EfuEa,KAAT,EAAyB,KAAL,GAApB,CACU,KAAT,EAAD,CAA0B,KAAL,GAArB,CAFK,EAAP,Ie/DK,KAAP,If0ES,KAAe,KAAf,GAAP,IenEK,KAAP,M,EfyG0B,KAAD,CAAU,KAAtB,EAAX,EACW,EAAS,EAAT,GAAX,E,EAC0B,SAAM,KAAN,CAAc,KAAD,CAAzB,KAAd,EACe,EAAO,EAAP,GAAf,EACW,KAAX,E,EACmB,KAAQ,KAAD,CAAnB,EAAP,IevGK,KAAP,Mf8Ga,EAAS,EAAT,GAAX,E,EAC0B,KAAQ,SAAR,CAAa,KAAzB,KAAd,EACe,EAAS,EAAT,GAAf,EACW,KAAX,E,EACmB,KAAQ,KAAD,CAAnB,EAAP,Ie3GK,KAAP,M,EfkH6B,KAAS,KAAU,SAAV,CAArB,EAAf,E,EAC6B,KAAD,CAAU,SAAM,KAAN,CAAtB,EAAhB,EACc,EAAW,EAAX,GAAd,EACW,KAAX,E,EACoB,KAAD,CAAS,SAAT,CAAc,KAAQ,SAAR,CAA1B,EAAP,Ie/GK,KAAP,I,Ef0DS,KAAL,GAAyB,KAAT,EAAhB,CACK,KAAL,GAAyB,KAAT,EAAhB,CAFK,EAAP,Ie9CK,KAAP,I,EfyDS,KAAL,GAAyB,KAAT,EAAhB,CACK,KAAL,GAAyB,KAAT,EAAhB,CAFK,EAAP,IejDK,KAAP,If2DS,KAAgB,KAAhB,GAAP,IepDK,KAAP,Mf6Fa,EAAS,EAAT,GAAX,E,EAC0B,KAAQ,SAAR,CAAa,KAAzB,KAAd,EACO,EAAS,EAAT,MAAP,IexFK,KAAP,Mf+Fa,EAAS,EAAT,GAAX,E,EAC0B,KAAQ,SAAR,CAAa,KAAzB,KAAd,EACO,EAAS,EAAT,MAAP,Ie1FK,KAAP,M,EfiG+B,SAAM,KAAN,CAAe,KAA3B,EAAjB,E,EAC8B,SAAM,KAAN,CAAgB,KAAD,CAA3B,EAAlB,EACW,EAAa,EAAb,MAAX,E,EACmB,KAAQ,SAAR,CAAa,KAAQ,SAAR,CAAzB,EAAP,Ie7FK,KAAP,IfrOS,KAAW,KAAX,GAAuB,KAAW,KAAX,E,GAA9B,IegPK,EAAS,EAAT,GAAP,MfzOiB,KAAU,KAAV,CAAf,EACe,KAAU,KAAV,CAAf,EACW,EAAJ,CAAc,EAAd,GAA6B,EAAJ,CAAc,EAAd,E,GAAhC,Ie8OK,EAAe,EAAG,EAAlB,GAAP,IfoGS,KAAW,SAAX,GAAkB,KAAW,SAAX,E,GAAzB,Ie7FK,KAAP,If+ES,KAAW,SAAX,CAAP,IexEK,KAAP,If+ES,KAAW,SAAX,CAAP,IexEK,KAAP,MAOa,K,IAAN,G,GAAqB,K,IAAN,EAAtB,MAOgB,K,cAAT,GAA2B,K,cAAT,E,GAAzB,I,EAWmB,EAAI,SAAhB,EAAP,I,EAOmB,SAAK,EAAjB,EAAP,IAOwB,EAAG,EAApB,EAAP,M,EAOgC,EAAjB,EAAf,EACU,EAAO,EAAK,KAAtB,EACU,EAAO,EAAK,KAAtB,EACO,EAAP,IAcO,EAAU,EAAV,GAAiB,EAAS,EAAT,GAAjB,GAAP,MAOa,EAAM,EAAN,GAAb,EACO,KAAP,I,ECrWwB,EAAI,EAAJ,CAAjB,EAAP,M,EAO8B,EAAI,EAAJ,CAAjB,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAI,EAAJ,CAAS,SAAxB,EADqB,E,GAAA,E,IAIhB,EAAP,M,EAO8B,EAAI,EAAJ,CAAjB,EAAb,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAK,EAAI,EAAJ,CAAS,EAAxB,EACU,EAAK,EAAI,EAAJ,CAAQ,EAAR,CAAa,EAA5B,EAFqB,E,GAAA,E,IAIhB,EAAP,MAWqB,EAAK,EAAQ,EAAR,CAAf,EAAX,EACqB,EAAK,EAAQ,EAAR,CAAY,EAAZ,CAAf,EAAX,E,EACmB,EAAI,EAAhB,EAAP,IAOU,EAAK,EAAQ,EAAR,CAAa,KAA5B,EACU,EAAK,EAAQ,EAAR,CAAY,EAAZ,CAAiB,KAAhC,KAOU,EAAK,EAAQ,EAAR,CAAa,EAA5B,EACU,EAAK,EAAQ,EAAR,CAAY,EAAZ,CAAiB,EAAhC,KAOiB,EAAK,EAAQ,EAAR,CAAf,EAAP,IAOiB,EAAK,EAAQ,EAAR,CAAY,EAAZ,CAAf,EAAP,IAOO,IAAc,EAAd,CAAP,MAaoB,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,SAWL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAtB,EADuB,E,GAAA,E,YAYP,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAA8C,EAA9C,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EAEU,EAAO,EAAO,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,CAAxB,EACU,EAAO,EAAM,EAAN,CAAW,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,CAA5B,EARqB,E,GAAA,E,YAkBL,I,EAAU,I,OAAd,C,EAAyB,I,OAA7B,CAA8C,EAA9C,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EAEc,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,CAAd,EACU,EAAO,EAAQ,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,CAAyB,EAA1B,CAAxB,EACU,EAAO,EAAM,EAAN,CAAY,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,CAAyB,EAA1B,CAA5B,EATqB,E,GAAA,E,SAmBP,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAtB,EADuB,E,GAAA,E,WAWX,I,EAAU,I,OAAd,CAA+B,EAA/B,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EAEU,EAAO,EAAO,EAAM,EAAN,CAAW,EAAM,EAAN,CAAX,CAAxB,EACU,EAAO,EAAM,EAAN,CAAW,EAAM,EAAN,CAAW,EAAM,EAAN,CAAX,CAA5B,EANqB,E,GAAA,E,SAcP,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAgB,EAAE,EAAZ,EAAD,CAAtB,EADuB,E,GAAA,E,SASX,I,EAAU,I,OAAd,CAA+B,EAA/B,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACU,EAAO,EAAiB,EAAE,EAAZ,EAAxB,EACU,EAAO,EAAM,EAAN,CAAsB,EAAE,EAAM,EAAN,CAAZ,EAAD,CAA5B,EAHqB,E,GAAA,E,WAeb,IAAW,EAAX,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAI,EAAJ,CAAZ,EAAX,EACqB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAX,EACU,EAAO,EAAU,EAAK,EAAL,CAAU,EAAK,EAAL,CAAV,CAAL,CAAtB,EAHqB,E,GAAA,E,WAWb,IAAW,EAAX,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAI,EAAJ,CAAZ,EAAX,EACqB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAX,EACU,EAAO,EAAgB,EAAI,EAAf,EAAtB,EAHqB,E,GAAA,E,WAWb,IAAW,EAAX,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAI,EAAJ,CAAZ,EAAX,EACqB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAX,EACU,EAAO,EAAK,EAAK,EAAL,CAAU,EAAK,EAAL,CAAV,CAAtB,EAHqB,E,GAAA,E,SAWT,IAAW,EAAX,C,EAAc,I,OAAlB,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAI,EAAJ,CAAZ,EAAtB,EADqB,E,GAAA,E,SAST,IAAW,EAAX,C,EAAc,I,OAAlB,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAO,EAAe,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAtB,EADqB,E,GAAA,E,WAST,I,EAAU,I,OAAd,CAA+B,EAA/B,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACqB,EAAE,EAAZ,EAAX,EACqB,EAAE,EAAM,EAAN,CAAZ,EAAX,EAEuB,EAAT,EAAd,EACU,EAAO,EAAO,EAAiB,EAAT,EAAR,CAAxB,EACU,EAAO,EAAM,EAAN,CAAW,EAAiB,EAAT,EAAR,CAA5B,EAPqB,E,GAAA,E,WAeT,I,EAAU,I,OAAd,CAA+B,EAA/B,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACqB,EAAE,EAAZ,EAAX,EACqB,EAAE,EAAM,EAAN,CAAZ,EAAX,EAEU,EAAO,EAAqB,EAAK,EAAL,CAAU,EAAK,EAAL,CAAV,CAAL,CAAT,EAAxB,EACU,EAAO,EAAM,EAAN,CAAsB,EAAI,EAAf,EAA5B,EANqB,E,GAAA,E,YAcT,I,EAAU,I,OAAd,CAA+B,EAA/B,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACqB,EAAE,EAAZ,EAAX,EACqB,EAAE,EAAM,EAAN,CAAZ,EAAX,EAEe,EAAK,EAAL,CAAU,EAAK,EAAL,CAAV,CAAL,CAAV,EACmB,EAAL,CAAd,EAC6B,EAAI,EAAf,EAAqB,SAArB,CAAlB,EAEU,EAAO,EAAO,EAAiB,EAAT,EAAR,CAAxB,EACU,EAAO,EAAM,EAAN,CAAW,EAAiB,EAAT,EAAR,CAA5B,EAVqB,E,GAAA,E,WAsBN,SAAjB,EACiB,SAAjB,EACU,IAAW,EAAX,CAAV,EAEa,EAAR,E,EAAW,EAAI,EAAJ,C,EACd,EAAmB,EAAE,EAAI,EAAJ,CAAZ,E,CAAT,EACA,EAAmB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,E,CAAT,EAFqB,E,GAAA,E,MAKJ,EAAO,EAAnB,EAAP,MAOU,IAAW,EAAX,CAAV,EACI,EAAK,EAAL,CAAJ,E,EAA+B,EAAS,EAArB,EAAP,EAEkB,EAAlB,GAAZ,E,EACmB,K,EAAS,CAAT,CAAiB,K,EAAS,CAAT,CAA7B,EAAP,SAOiB,SAAjB,EACiB,SAAjB,EACc,I,EAAU,I,OAAd,CAA0B,EAA1B,CAAV,EAEa,EAAR,E,EAAW,EAAI,EAAJ,C,EACF,EAAI,EAAJ,CAAZ,EACsB,EAAE,EAAZ,EAAZ,EACsB,EAAE,EAAM,EAAN,CAAZ,EAAZ,EACsB,EAAE,EAAZ,EAAZ,EACuB,EAAE,EAAM,EAAN,CAAZ,EAAD,CAAZ,EAEA,EAAS,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,C,CAAT,EACA,EAAS,EAAM,EAAN,CAAY,EAAM,EAAN,CAAZ,C,CAAT,EARqB,E,GAAA,E,MAWJ,EAAO,EAAnB,EAAP,QAOiB,SAAjB,EACU,IAAW,EAAX,CAAV,EAEa,EAAR,E,EAAW,EAAI,EAAJ,C,EACO,EAAE,EAAI,EAAJ,CAAZ,EAAX,EACqB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAX,EACA,EAAS,EAAK,EAAL,CAAU,EAAK,EAAL,CAAV,C,CAAT,EAHqB,E,GAAA,E,IAMX,EAAL,CAAP,MAWY,IAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAAkB,EAAlB,CAAjB,EADuB,E,GAAA,E,SASf,IAAW,EAAX,CAAV,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAwB,EAAE,EAAI,EAAJ,CAAQ,EAAR,CAAZ,EAAD,CAAzB,EADqB,E,GAAA,E,SASP,I,EAAU,I,OAAd,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAE,EAAe,EAAE,EAAZ,EAA4B,EAAE,EAAZ,EAAlB,CAAjB,EADuB,E,GAAA,E,SAST,I,EAAY,I,OAAhB,CAAZ,EACa,EAAR,E,EAAW,EAAI,EAAJ,C,EACJ,EAAI,EAAe,EAAI,EAAd,EAAnB,EADuB,E,GAAA,E,OfhUlB,EAAP,I","sourceRoot":"./mathts-debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                           MM info                             │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class BLOCK {\n  /** Memory manager info. */\n  mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                     Memory manager block                      │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │                            GC info                            │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │                            GC info                            │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT id                              │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT size                            │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class OBJECT extends BLOCK {\n  /** Garbage collector info. */\n  gcInfo: u32;\n  /** Garbage collector info. */\n  gcInfo2: u32;\n  /** Runtime class id. */\n  rtId: u32;\n  /** Runtime object size. */\n  rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","/**\r\n * AssemblyScript-compatible Complex Number Implementation\r\n *\r\n * This is a simplified Complex number class designed for AssemblyScript\r\n * compilation. It avoids:\r\n * - Optional parameters (use overloaded functions instead)\r\n * - Regex parsing (use factory functions)\r\n * - Closures\r\n * - Dynamic types\r\n */\r\n\r\n/**\r\n * Complex number represented as (re + im*i)\r\n */\r\n@final\r\nexport class Complex {\r\n  /** Real part */\r\n  re: f64;\r\n  /** Imaginary part */\r\n  im: f64;\r\n\r\n  constructor(re: f64, im: f64) {\r\n    this.re = re;\r\n    this.im = im;\r\n  }\r\n\r\n  /**\r\n   * Create a copy of this complex number\r\n   */\r\n  clone(): Complex {\r\n    return new Complex(this.re, this.im);\r\n  }\r\n\r\n  /**\r\n   * Check equality with another complex number\r\n   */\r\n  equals(other: Complex): bool {\r\n    return this.re == other.re && this.im == other.im;\r\n  }\r\n\r\n  /**\r\n   * Check approximate equality (within epsilon)\r\n   */\r\n  approxEquals(other: Complex, epsilon: f64 = 1e-12): bool {\r\n    const diffRe = this.re - other.re;\r\n    const diffIm = this.im - other.im;\r\n    return abs(diffRe) < epsilon && abs(diffIm) < epsilon;\r\n  }\r\n\r\n  // =========================================================================\r\n  // Arithmetic Operations\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Add another complex number\r\n   */\r\n  add(other: Complex): Complex {\r\n    return new Complex(this.re + other.re, this.im + other.im);\r\n  }\r\n\r\n  /**\r\n   * Add a real number\r\n   */\r\n  addReal(value: f64): Complex {\r\n    return new Complex(this.re + value, this.im);\r\n  }\r\n\r\n  /**\r\n   * Subtract another complex number\r\n   */\r\n  sub(other: Complex): Complex {\r\n    return new Complex(this.re - other.re, this.im - other.im);\r\n  }\r\n\r\n  /**\r\n   * Subtract a real number\r\n   */\r\n  subReal(value: f64): Complex {\r\n    return new Complex(this.re - value, this.im);\r\n  }\r\n\r\n  /**\r\n   * Multiply by another complex number\r\n   * (a + bi)(c + di) = (ac - bd) + (ad + bc)i\r\n   */\r\n  mul(other: Complex): Complex {\r\n    return new Complex(\r\n      this.re * other.re - this.im * other.im,\r\n      this.re * other.im + this.im * other.re\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Multiply by a real number\r\n   */\r\n  mulReal(value: f64): Complex {\r\n    return new Complex(this.re * value, this.im * value);\r\n  }\r\n\r\n  /**\r\n   * Divide by another complex number\r\n   * (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)\r\n   */\r\n  div(other: Complex): Complex {\r\n    const denom = other.re * other.re + other.im * other.im;\r\n    if (denom == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(\r\n      (this.re * other.re + this.im * other.im) / denom,\r\n      (this.im * other.re - this.re * other.im) / denom\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Divide by a real number\r\n   */\r\n  divReal(value: f64): Complex {\r\n    if (value == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(this.re / value, this.im / value);\r\n  }\r\n\r\n  /**\r\n   * Negate the complex number\r\n   */\r\n  neg(): Complex {\r\n    return new Complex(-this.re, -this.im);\r\n  }\r\n\r\n  /**\r\n   * Complex conjugate\r\n   */\r\n  conj(): Complex {\r\n    return new Complex(this.re, -this.im);\r\n  }\r\n\r\n  /**\r\n   * Reciprocal (1/z)\r\n   */\r\n  reciprocal(): Complex {\r\n    const denom = this.re * this.re + this.im * this.im;\r\n    if (denom == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(this.re / denom, -this.im / denom);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Magnitude and Phase\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Absolute value (magnitude)\r\n   * |z| = sqrt(re² + im²)\r\n   */\r\n  abs(): f64 {\r\n    return sqrt(this.re * this.re + this.im * this.im);\r\n  }\r\n\r\n  /**\r\n   * Squared magnitude (avoids sqrt for comparisons)\r\n   */\r\n  abs2(): f64 {\r\n    return this.re * this.re + this.im * this.im;\r\n  }\r\n\r\n  /**\r\n   * Argument (phase angle in radians)\r\n   * arg(z) = Math.atan2(im, re)\r\n   */\r\n  arg(): f64 {\r\n    return Math.atan2(this.im, this.re);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Exponential and Logarithmic\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex exponential\r\n   * Math.exp(a + bi) = Math.exp(a) * (Math.cos(b) + i*Math.sin(b))\r\n   */\r\n  exp(): Complex {\r\n    const expRe = Math.exp(this.re);\r\n    return new Complex(expRe * Math.cos(this.im), expRe * Math.sin(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex natural logarithm (principal value)\r\n   * Math.log(z) = log|z| + i*arg(z)\r\n   */\r\n  log(): Complex {\r\n    return new Complex(Math.log(this.abs()), this.arg());\r\n  }\r\n\r\n  /**\r\n   * Complex square root (principal value)\r\n   */\r\n  sqrt(): Complex {\r\n    const r = this.abs();\r\n    const halfArg = this.arg() / 2.0;\r\n    const sqrtR = sqrt(r);\r\n    return new Complex(sqrtR * Math.cos(halfArg), sqrtR * Math.sin(halfArg));\r\n  }\r\n\r\n  /**\r\n   * Complex power (z^n where n is real)\r\n   */\r\n  powReal(n: f64): Complex {\r\n    if (n == 0.0) {\r\n      return new Complex(1.0, 0.0);\r\n    }\r\n    const r = this.abs();\r\n    const theta = this.arg();\r\n    const rn = Math.pow(r, n);\r\n    const nTheta = n * theta;\r\n    return new Complex(rn * Math.cos(nTheta), rn * Math.sin(nTheta));\r\n  }\r\n\r\n  /**\r\n   * Complex power (z^w where w is complex)\r\n   * z^w = Math.exp(w * Math.log(z))\r\n   */\r\n  pow(w: Complex): Complex {\r\n    if (this.re == 0.0 && this.im == 0.0) {\r\n      if (w.re > 0.0) {\r\n        return new Complex(0.0, 0.0);\r\n      }\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return w.mul(this.log()).exp();\r\n  }\r\n\r\n  // =========================================================================\r\n  // Trigonometric Functions\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex sine\r\n   * Math.sin(z) = (Math.exp(iz) - Math.exp(-iz)) / 2i\r\n   */\r\n  sin(): Complex {\r\n    return new Complex(\r\n      Math.sin(this.re) * cosh(this.im),\r\n      Math.cos(this.re) * sinh(this.im)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Complex cosine\r\n   * Math.cos(z) = (Math.exp(iz) + Math.exp(-iz)) / 2\r\n   */\r\n  cos(): Complex {\r\n    return new Complex(\r\n      Math.cos(this.re) * cosh(this.im),\r\n      -Math.sin(this.re) * sinh(this.im)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Complex tangent\r\n   * Math.tan(z) = Math.sin(z) / Math.cos(z)\r\n   */\r\n  tan(): Complex {\r\n    return this.sin().div(this.cos());\r\n  }\r\n\r\n  // =========================================================================\r\n  // Hyperbolic Functions\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex hyperbolic sine\r\n   */\r\n  sinh(): Complex {\r\n    return new Complex(\r\n      sinh(this.re) * Math.cos(this.im),\r\n      cosh(this.re) * Math.sin(this.im)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Complex hyperbolic cosine\r\n   */\r\n  cosh(): Complex {\r\n    return new Complex(\r\n      cosh(this.re) * Math.cos(this.im),\r\n      sinh(this.re) * Math.sin(this.im)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Complex hyperbolic tangent\r\n   */\r\n  tanh(): Complex {\r\n    return this.sinh().div(this.cosh());\r\n  }\r\n\r\n  /**\r\n   * Complex inverse sine: asin(z) = -i * ln(iz + sqrt(1 - z²))\r\n   */\r\n  asin(): Complex {\r\n    const iz = new Complex(-this.im, this.re);\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(1.0 - z2.re, -z2.im).sqrt();\r\n    const logArg = iz.add(inner);\r\n    const ln = logArg.log();\r\n    return new Complex(ln.im, -ln.re);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse cosine: acos(z) = -i * ln(z + sqrt(z² - 1))\r\n   */\r\n  acos(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re - 1.0, z2.im).sqrt();\r\n    const logArg = this.add(inner);\r\n    const ln = logArg.log();\r\n    return new Complex(ln.im, -ln.re);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse tangent: atan(z) = (i/2) * ln((i+z)/(i-z))\r\n   */\r\n  atan(): Complex {\r\n    const iPlusZ = new Complex(this.re, this.im + 1.0);\r\n    const iMinusZ = new Complex(-this.re, 1.0 - this.im);\r\n    const ratio = iPlusZ.div(iMinusZ);\r\n    const ln = ratio.log();\r\n    return new Complex(-ln.im * 0.5, ln.re * 0.5);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic sine: asinh(z) = ln(z + sqrt(z² + 1))\r\n   */\r\n  asinh(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re + 1.0, z2.im).sqrt();\r\n    return this.add(inner).log();\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic cosine: acosh(z) = ln(z + sqrt(z² - 1))\r\n   */\r\n  acosh(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re - 1.0, z2.im).sqrt();\r\n    return this.add(inner).log();\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic tangent: atanh(z) = 0.5 * ln((1+z)/(1-z))\r\n   */\r\n  atanh(): Complex {\r\n    const onePlusZ = new Complex(1.0 + this.re, this.im);\r\n    const oneMinusZ = new Complex(1.0 - this.re, -this.im);\r\n    const ln = onePlusZ.div(oneMinusZ).log();\r\n    return new Complex(ln.re * 0.5, ln.im * 0.5);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Query Methods\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Check if this is a real number (imaginary part is zero)\r\n   */\r\n  isReal(): bool {\r\n    return this.im == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is purely imaginary (real part is zero)\r\n   */\r\n  isImaginary(): bool {\r\n    return this.re == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is zero\r\n   */\r\n  isZero(): bool {\r\n    return this.re == 0.0 && this.im == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is NaN\r\n   */\r\n  isNaN(): bool {\r\n    return isNaN(this.re) || isNaN(this.im);\r\n  }\r\n\r\n  /**\r\n   * Check if this is finite\r\n   */\r\n  isFinite(): bool {\r\n    return isFinite(this.re) && isFinite(this.im);\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Factory Functions (avoid constructor overloading)\r\n// =============================================================================\r\n\r\n/**\r\n * Create a complex number from real and imaginary parts\r\n */\r\nexport function complex(re: f64, im: f64): Complex {\r\n  return new Complex(re, im);\r\n}\r\n\r\n/**\r\n * Create a complex number from polar coordinates (r, theta)\r\n */\r\nexport function complexFromPolar(r: f64, theta: f64): Complex {\r\n  return new Complex(r * Math.cos(theta), r * Math.sin(theta));\r\n}\r\n\r\n/**\r\n * Create a complex number from a real value (im = 0)\r\n */\r\nexport function complexFromReal(value: f64): Complex {\r\n  return new Complex(value, 0.0);\r\n}\r\n\r\n/**\r\n * Create a complex number from an imaginary value (re = 0)\r\n */\r\nexport function complexFromImaginary(value: f64): Complex {\r\n  return new Complex(0.0, value);\r\n}\r\n\r\n// =============================================================================\r\n// Constants\r\n// =============================================================================\r\n\r\n/** Complex zero */\r\nexport const COMPLEX_ZERO: Complex = new Complex(0.0, 0.0);\r\n\r\n/** Complex one */\r\nexport const COMPLEX_ONE: Complex = new Complex(1.0, 0.0);\r\n\r\n/** Complex imaginary unit i */\r\nexport const COMPLEX_I: Complex = new Complex(0.0, 1.0);\r\n\r\n/** Complex negative one */\r\nexport const COMPLEX_NEG_ONE: Complex = new Complex(-1.0, 0.0);\r\n\r\n// =============================================================================\r\n// Math helpers (AS doesn't have Math.sinh, Math.cosh by default in older versions)\r\n// =============================================================================\r\n\r\nfunction sinh(x: f64): f64 {\r\n  const ex = Math.exp(x);\r\n  return (ex - 1.0 / ex) / 2.0;\r\n}\r\n\r\nfunction cosh(x: f64): f64 {\r\n  const ex = Math.exp(x);\r\n  return (ex + 1.0 / ex) / 2.0;\r\n}\r\n","import { AL_MASK, OBJECT, OBJECT_OVERHEAD, BLOCK_MAXSIZE, BLOCK_OVERHEAD, BLOCK, OBJECT_MAXSIZE } from \"./common\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === A minimal runtime stub ===\n\n// @ts-ignore: decorator\n@lazy let startOffset: usize = ((__heap_base + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n// @ts-ignore: decorator\n@lazy let offset: usize = startOffset;\n\nfunction maybeGrowMemory(newOffset: usize): void {\n  // assumes newOffset is aligned\n  let pagesBefore = memory.size();\n  let maxOffset = ((<usize>pagesBefore << 16) + AL_MASK) & ~AL_MASK;\n  if (newOffset > maxOffset) {\n    let pagesNeeded = <i32>(((newOffset - maxOffset + 0xffff) & ~0xffff) >>> 16);\n    let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n    if (memory.grow(pagesWanted) < 0) {\n      if (memory.grow(pagesNeeded) < 0) unreachable(); // out of memory\n    }\n  }\n  offset = newOffset;\n}\n\n// @ts-ignore: decorator\n@inline function computeSize(size: usize): usize {\n  return ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __alloc(size: usize): usize {\n  if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let block = changetype<BLOCK>(offset);\n  let ptr = offset + BLOCK_OVERHEAD;\n  let payloadSize = computeSize(size);\n  maybeGrowMemory(ptr + payloadSize);\n  block.mmInfo = payloadSize;\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __realloc(ptr: usize, size: usize): usize {\n  assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n  let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n  let actualSize = block.mmInfo;\n  let isLast = ptr + actualSize == offset;\n  let payloadSize = computeSize(size);\n  if (size > actualSize) {\n    if (isLast) { // last block: grow\n      if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n      maybeGrowMemory(ptr + payloadSize);\n      block.mmInfo = payloadSize;\n    } else { // copy to new block at least double the size\n      let newPtr = __alloc(max<usize>(payloadSize, actualSize << 1));\n      memory.copy(newPtr, ptr, actualSize);\n      block = changetype<BLOCK>((ptr = newPtr) - BLOCK_OVERHEAD);\n    }\n  } else if (isLast) { // last block: shrink\n    offset = ptr + payloadSize;\n    block.mmInfo = payloadSize;\n  }\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __free(ptr: usize): void {\n  assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n  let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n  if (ptr + block.mmInfo == offset) { // last block: discard\n    offset = changetype<usize>(block);\n  }\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __reset(): void { // special\n  offset = startOffset;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __new(size: usize, id: u32): usize {\n  if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let ptr = __alloc(OBJECT_OVERHEAD + size);\n  let object = changetype<OBJECT>(ptr - BLOCK_OVERHEAD);\n  object.gcInfo = 0;\n  object.gcInfo2 = 0;\n  object.rtId = id;\n  object.rtSize = <u32>size;\n  return ptr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __renew(oldPtr: usize, size: usize): usize {\n  if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let newPtr = __realloc(oldPtr - OBJECT_OVERHEAD, OBJECT_OVERHEAD + size);\n  changetype<OBJECT>(newPtr - BLOCK_OVERHEAD).rtSize = <u32>size;\n  return newPtr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __visit(ptr: usize, cookie: u32): void { // eslint-disable-line @typescript-eslint/no-unused-vars\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n  // nop\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","/**\r\n * Scalar Operations for AssemblyScript\r\n *\r\n * Basic numeric operations exported for WASM.\r\n * These wrap the built-in AssemblyScript math functions with\r\n * consistent naming and behavior.\r\n */\r\n\r\n// =============================================================================\r\n// Basic Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Add two f64 values\r\n */\r\nexport function add_f64(a: f64, b: f64): f64 {\r\n  return a + b;\r\n}\r\n\r\n/**\r\n * Subtract two f64 values\r\n */\r\nexport function sub_f64(a: f64, b: f64): f64 {\r\n  return a - b;\r\n}\r\n\r\n/**\r\n * Multiply two f64 values\r\n */\r\nexport function mul_f64(a: f64, b: f64): f64 {\r\n  return a * b;\r\n}\r\n\r\n/**\r\n * Divide two f64 values\r\n */\r\nexport function div_f64(a: f64, b: f64): f64 {\r\n  return a / b;\r\n}\r\n\r\n/**\r\n * Modulo operation\r\n */\r\nexport function mod_f64(a: f64, b: f64): f64 {\r\n  return a % b;\r\n}\r\n\r\n/**\r\n * Negation\r\n */\r\nexport function neg_f64(a: f64): f64 {\r\n  return -a;\r\n}\r\n\r\n// =============================================================================\r\n// Power and Roots\r\n// =============================================================================\r\n\r\n/**\r\n * Square root\r\n */\r\nexport function sqrt_f64(a: f64): f64 {\r\n  return sqrt(a);\r\n}\r\n\r\n/**\r\n * Power (a^b)\r\n */\r\nexport function pow_f64(a: f64, b: f64): f64 {\r\n  return Math.pow(a, b);\r\n}\r\n\r\n/**\r\n * Square\r\n */\r\nexport function square_f64(a: f64): f64 {\r\n  return a * a;\r\n}\r\n\r\n/**\r\n * Cube\r\n */\r\nexport function cube_f64(a: f64): f64 {\r\n  return a * a * a;\r\n}\r\n\r\n/**\r\n * Cube root\r\n */\r\nexport function cbrt_f64(a: f64): f64 {\r\n  if (a >= 0) {\r\n    return Math.pow(a, 1.0 / 3.0);\r\n  }\r\n  return -Math.pow(-a, 1.0 / 3.0);\r\n}\r\n\r\n/**\r\n * N-th root\r\n */\r\nexport function nthRoot_f64(a: f64, n: f64): f64 {\r\n  if (n == 0.0) return f64.NaN;\r\n  if (a >= 0) {\r\n    return Math.pow(a, 1.0 / n);\r\n  }\r\n  // For negative bases, only odd integer roots are real\r\n  const nInt = i64(n);\r\n  if (f64(nInt) == n && (nInt & 1) == 1) {\r\n    return -Math.pow(-a, 1.0 / n);\r\n  }\r\n  return f64.NaN;\r\n}\r\n\r\n// =============================================================================\r\n// Exponential and Logarithmic\r\n// =============================================================================\r\n\r\n/**\r\n * Natural exponential (e^x)\r\n */\r\nexport function exp_f64(a: f64): f64 {\r\n  return Math.exp(a);\r\n}\r\n\r\n/**\r\n * e^x - 1 (more accurate for small x)\r\n */\r\nexport function expm1_f64(a: f64): f64 {\r\n  return Math.expm1(a);\r\n}\r\n\r\n/**\r\n * Natural logarithm\r\n */\r\nexport function log_f64(a: f64): f64 {\r\n  return Math.log(a);\r\n}\r\n\r\n/**\r\n * Math.log(1 + x) (more accurate for small x)\r\n */\r\nexport function log1p_f64(a: f64): f64 {\r\n  return Math.log1p(a);\r\n}\r\n\r\n/**\r\n * Base-10 logarithm\r\n */\r\nexport function log10_f64(a: f64): f64 {\r\n  return Math.log10(a);\r\n}\r\n\r\n/**\r\n * Base-2 logarithm\r\n */\r\nexport function log2_f64(a: f64): f64 {\r\n  return Math.log2(a);\r\n}\r\n\r\n// =============================================================================\r\n// Trigonometric Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Sine\r\n */\r\nexport function sin_f64(a: f64): f64 {\r\n  return Math.sin(a);\r\n}\r\n\r\n/**\r\n * Cosine\r\n */\r\nexport function cos_f64(a: f64): f64 {\r\n  return Math.cos(a);\r\n}\r\n\r\n/**\r\n * Tangent\r\n */\r\nexport function tan_f64(a: f64): f64 {\r\n  return Math.tan(a);\r\n}\r\n\r\n/**\r\n * Arc sine\r\n */\r\nexport function asin_f64(a: f64): f64 {\r\n  return Math.asin(a);\r\n}\r\n\r\n/**\r\n * Arc cosine\r\n */\r\nexport function acos_f64(a: f64): f64 {\r\n  return Math.acos(a);\r\n}\r\n\r\n/**\r\n * Arc tangent\r\n */\r\nexport function atan_f64(a: f64): f64 {\r\n  return Math.atan(a);\r\n}\r\n\r\n/**\r\n * Two-argument arc tangent\r\n */\r\nexport function atan2_f64(y: f64, x: f64): f64 {\r\n  return Math.atan2(y, x);\r\n}\r\n\r\n// =============================================================================\r\n// Hyperbolic Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Hyperbolic sine\r\n */\r\nexport function sinh_f64(a: f64): f64 {\r\n  const ex = Math.exp(a);\r\n  return (ex - 1.0 / ex) / 2.0;\r\n}\r\n\r\n/**\r\n * Hyperbolic cosine\r\n */\r\nexport function cosh_f64(a: f64): f64 {\r\n  const ex = Math.exp(a);\r\n  return (ex + 1.0 / ex) / 2.0;\r\n}\r\n\r\n/**\r\n * Hyperbolic tangent\r\n */\r\nexport function tanh_f64(a: f64): f64 {\r\n  const ex = Math.exp(2.0 * a);\r\n  return (ex - 1.0) / (ex + 1.0);\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic sine\r\n */\r\nexport function asinh_f64(a: f64): f64 {\r\n  return Math.log(a + sqrt(a * a + 1.0));\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic cosine\r\n */\r\nexport function acosh_f64(a: f64): f64 {\r\n  return Math.log(a + sqrt(a * a - 1.0));\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic tangent\r\n */\r\nexport function atanh_f64(a: f64): f64 {\r\n  return 0.5 * Math.log((1.0 + a) / (1.0 - a));\r\n}\r\n\r\n// =============================================================================\r\n// Rounding and Comparison\r\n// =============================================================================\r\n\r\n/**\r\n * Absolute value\r\n */\r\nexport function abs_f64(a: f64): f64 {\r\n  return abs(a);\r\n}\r\n\r\n/**\r\n * Floor\r\n */\r\nexport function floor_f64(a: f64): f64 {\r\n  return floor(a);\r\n}\r\n\r\n/**\r\n * Ceiling\r\n */\r\nexport function ceil_f64(a: f64): f64 {\r\n  return ceil(a);\r\n}\r\n\r\n/**\r\n * Round to nearest\r\n */\r\nexport function round_f64(a: f64): f64 {\r\n  return nearest(a);\r\n}\r\n\r\n/**\r\n * Truncate (round toward zero)\r\n */\r\nexport function trunc_f64(a: f64): f64 {\r\n  return trunc(a);\r\n}\r\n\r\n/**\r\n * Sign function (-1, 0, or 1)\r\n */\r\nexport function sign_f64(a: f64): f64 {\r\n  if (a > 0.0) return 1.0;\r\n  if (a < 0.0) return -1.0;\r\n  return 0.0;\r\n}\r\n\r\n/**\r\n * Minimum of two values\r\n */\r\nexport function min_f64(a: f64, b: f64): f64 {\r\n  return min(a, b);\r\n}\r\n\r\n/**\r\n * Maximum of two values\r\n */\r\nexport function max_f64(a: f64, b: f64): f64 {\r\n  return max(a, b);\r\n}\r\n\r\n/**\r\n * Clamp value to range [lo, hi]\r\n */\r\nexport function clamp_f64(value: f64, lo: f64, hi: f64): f64 {\r\n  return max(lo, min(hi, value));\r\n}\r\n\r\n// =============================================================================\r\n// Special Values\r\n// =============================================================================\r\n\r\n/**\r\n * Check if value is NaN\r\n */\r\nexport function isNaN_f64(a: f64): bool {\r\n  return isNaN(a);\r\n}\r\n\r\n/**\r\n * Check if value is finite\r\n */\r\nexport function isFinite_f64(a: f64): bool {\r\n  return isFinite(a);\r\n}\r\n\r\n// =============================================================================\r\n// Constants\r\n// =============================================================================\r\n\r\n/** Mathematical constant pi */\r\nexport const PI: f64 = 3.141592653589793;\r\n\r\n/** Mathematical constant e */\r\nexport const E: f64 = 2.718281828459045;\r\n\r\n/** Golden ratio phi */\r\nexport const PHI: f64 = 1.618033988749895;\r\n\r\n/** Square root of 2 */\r\nexport const SQRT2: f64 = 1.4142135623730951;\r\n\r\n/** Square root of 1/2 */\r\nexport const SQRT1_2: f64 = 0.7071067811865476;\r\n\r\n/** Natural log of 2 */\r\nexport const LN2: f64 = 0.6931471805599453;\r\n\r\n/** Natural log of 10 */\r\nexport const LN10: f64 = 2.302585092994046;\r\n\r\n/** Log base 2 of e */\r\nexport const LOG2E: f64 = 1.4426950408889634;\r\n\r\n/** Log base 10 of e */\r\nexport const LOG10E: f64 = 0.4342944819032518;\r\n\r\n/** Machine epsilon for f64 */\r\nexport const EPSILON: f64 = 2.220446049250313e-16;\r\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([\n  // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n  // used for computing 2^(k/N) for an int |k| < 150 N as\n  // double(tab[k%N] + (k << 52-BITS))\n  0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n  0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n  0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n  0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n  0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n  0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n  0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n  0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N, // 0x1.8p+52\n    Ox127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  let xd = <f64>x;\n  let ix = reinterpret<u32>(x);\n  let ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x430) {\n    // |x| >= 128 or x is nan.\n    if (ix == 0xFF800000) return 0; // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;  // x == Inf/NaN -> Inf/NaN\n    if (x > 0) return x * Ox127f;   // x >     0    -> HugeVal (Owerflow)\n    if (x <= -150) return 0;        // x <= -150    -> 0 (Underflow)\n  }\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n  let kd = xd + shift;\n  let ki = reinterpret<u64>(kd);\n  let r  = xd - (kd - shift);\n  let t: u64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  y  = C2 * r + 1;\n  y += (C0 * r + C1) * (r  * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n  const\n    N        = 1 << EXP2F_TABLE_BITS,\n    N_MASK   = N - 1,\n    shift    = reinterpret<f64>(0x4338000000000000),        // 0x1.8p+52\n    InvLn2N  = reinterpret<f64>(0x3FF71547652B82FE) * N,    // 0x1.71547652b82fep+0\n    Ox1p127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3) / N / N,     // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6) / N;         // 0x1.62e42ff0c52d6p-1\n\n  let xd = <f64>x;\n  let ix = reinterpret<u32>(x);\n  let ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x42B) {\n    // |x| >= 88 or x is nan.\n    if (ix == 0xFF800000) return 0;                            // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;                             // x == Inf/NaN -> Inf/NaN\n    if (x > reinterpret<f32>(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128)  ~=  88.72 -> HugeVal (Owerflow)\n    if (x < reinterpret<f32>(0xC2CFF1B4)) return 0;            // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n  }\n\n  // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n  let z = InvLn2N * xd;\n\n  // Round and convert z to int, the result is in [-150*N, 128*N] and\n  // ideally ties-to-even rule is used, otherwise the magnitude of r\n  // can be bigger which gives larger approximation error.\n  let kd = <f64>(z + shift);\n  let ki = reinterpret<u64>(kd);\n  let r  = z - (kd - shift);\n  let s: f64, y: f64, t: u64;\n\n  // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data<u64>([\n  0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n  0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n  0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n  0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n  0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n  0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n  0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n  0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n  0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n  0x3FF0000000000000, 0,                  // 0x1p+0,                0x0,\n  0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1,  0x1.338ca9f24f53dp-4,\n  0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 ,  0x1.476a9543891bap-3,\n  0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1,  0x1.e840b4ac4e4d2p-3,\n  0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1,  0x1.40645f0c6651cp-2,\n  0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1,  0x1.88e9c2c1b9ff8p-2,\n  0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC  // 0x1.767dcf5534862p-1,  0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOG2F_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    A0 = reinterpret<f64>(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n    A1 = reinterpret<f64>(0x3FDECABF496832E0), //  0x1.ecabf496832ep-2\n    A2 = reinterpret<f64>(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n    A3 = reinterpret<f64>(0x3FF715475F35C8B8); //  0x1.715475f35c8b8p0\n\n  let ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if (ux * 2 == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log2(inf) == inf.\n    if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ux - 0x3F330000;\n  let i    = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n  let top  = tmp & 0xFF800000;\n  let iz   = ux - top;\n  let k    = <i32>tmp >> 23;\n\n  let invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  let z    = <f64>reinterpret<f32>(iz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  let r  = z * invc - 1;\n  let y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  let y  = A1 * r + A2;\n  let p  = A3 * r + y0;\n  let r2 = r * r;\n  y += A0 * r2;\n  y  = y * r2 + p;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data<u64>([\n  0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n  0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n  0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n  0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n  0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n  0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3  ,\n  0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n  0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n  0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n  0x3FF0000000000000, 0,                  // 0x1p+0,                0,\n  0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1,  0x1.aa5aa5df25984p-5,\n  0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 ,  0x1.c5e53aa362eb4p-4,\n  0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1,  0x1.526e57720db08p-3,\n  0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1,  0x1.bc2860d22477p-3 ,\n  0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1,  0x1.1058bc8a07ee1p-2,\n  0x3FE767DCF5534862, 0x3FD4043057B6EE09  // 0x1.767dcf5534862p-1,  0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOGF_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    Ln2 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n    A0  = reinterpret<f64>(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n    A1  = reinterpret<f64>(0x3FD5575B0BE00B6A), //  0x1.5575b0be00b6ap-2\n    A2  = reinterpret<f64>(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n  let ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if ((ux << 1) == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log(inf) == inf.\n    if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp = ux - 0x3F330000;\n  let i   = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n  let k   = <i32>tmp >> 23;\n  let iz  = ux - (tmp & 0x1FF << 23);\n\n  let invc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n\n  let z = <f64>reinterpret<f32>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n  let r = z * invc - 1;\n  let y0 = logc + <f64>k * Ln2;\n\n  // Pipelined polynomial evaluation to approximate log1p(r).\n  let r2 = r * r;\n  let y  = A1 * r + A2;\n  y += A0 * r2;\n  y = y * r2 + (y0 + r);\n\n  return <f32>y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n  return (ux << 1) - 1 >= (<u32>0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n  let e = iy >> 23 & 0xFF;\n  if (e < 0x7F     ) return 0;\n  if (e > 0x7F + 23) return 2;\n  e = 1 << (0x7F + 23 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n  const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n  const\n    A0 = reinterpret<f64>(0x3FD27616C9496E0B), //  0x1.27616c9496e0bp-2\n    A1 = reinterpret<f64>(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n    A2 = reinterpret<f64>(0x3FDEC70A6CA7BADD), //  0x1.ec70a6ca7baddp-2\n    A3 = reinterpret<f64>(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n    A4 = reinterpret<f64>(0x3FF71547652AB82B); //  0x1.71547652ab82bp+0\n\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ux - 0x3F330000;\n  let i    = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n  let top  = tmp & 0xFF800000;\n  let uz   = ux - top;\n  let k    = <i32>top >> 23;\n\n  let invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  let z    = <f64>reinterpret<f32>(uz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  let r  = z * invc - 1;\n  let y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  let y = A0 * r + A1;\n  let p = A2 * r + A3;\n  let q = A4 * r + y0;\n\n  r *= r;\n  q += p * r;\n  y  = y * (r * r) + q;\n\n  return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not.  The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p+52\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)]\n  let kd = <f64>(xd + shift);\n  let ki = reinterpret<u64>(kd);\n  let r  = xd - (kd - shift);\n  let t: u64, z: f64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n  return <f32>y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n  return select<f32>(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n  const\n    Ox1p23f     = reinterpret<f32>(0x4B000000), // 0x1p23f\n    UPPER_LIMIT = reinterpret<f64>(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n    LOWER_LIMIT = -150.0,\n    SIGN_BIAS   = 1 << (EXP2F_TABLE_BITS + 11);\n\n  let signBias: u32 = 0;\n  let ix = reinterpret<u32>(x);\n  let iy = reinterpret<u32>(y);\n  let ny = 0;\n\n  if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n    // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n    if (ny) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3F800000) return NaN; // original: 1.0\n      if ((ix << 1) > (<u32>0x7F800000 << 1) || (iy << 1) > (<u32>0x7F800000 << 1)) return x + y;\n      if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n      if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnanf(ix)) {\n      let x2 = x * x;\n      if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n      return <i32>iy < 0 ? 1 / x2 : x2;\n    }\n    // x and y are non-zero finite.\n    if (<i32>ix < 0) {\n      // Finite x < 0.\n      let yint = checkintf(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) signBias = SIGN_BIAS;\n      ix &= 0x7FFFFFFF;\n    }\n    if (ix < 0x00800000) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u32>(x * Ox1p23f);\n      ix &= 0x7FFFFFFF;\n      ix -= 23 << 23;\n    }\n  }\n  let logx = log2f_inline(ix);\n  let ylogx = y * logx; // cannot overflow, y is single prec.\n  if ((reinterpret<u64>(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret<u64>(126.0) >> 47\n    // |y * log(x)| >= 126\n    if (ylogx  > UPPER_LIMIT) return oflowf(signBias); // overflow\n    if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n  }\n  return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data<u64>([\n  0x0000000000000000, 0x3FF0000000000000,\n  0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n  0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n  0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n  0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n  0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n  0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n  0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n  0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n  0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n  0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n  0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n  0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n  0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n  0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n  0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n  0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n  0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n  0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n  0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n  0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n  0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n  0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n  0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n  0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n  0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n  0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n  0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n  0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n  0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n  0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n  0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n  0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n  0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n  0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n  0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n  0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n  0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n  0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n  0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n  0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n  0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n  0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n  0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n  0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n  0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n  0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n  0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n  0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n  0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n  0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n  0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n  0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n  0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n  0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n  0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n  0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n  0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n  0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n  0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n  0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n  0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n  0xBC93CEDD78565858, 0x3FEEA23882552225,\n  0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n  0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n  0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n  0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n  0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n  0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n  0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n  0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n  0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n  0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n  0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n  0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n  0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n  0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n  0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n  0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n  0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n  0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n  0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n  0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n  0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n  0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n  0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n  0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n  0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n  0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n  0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n  0xBC87C50422622263, 0x3FEECC667B5DE565,\n  0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n  0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n  0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n  0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n  0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n  0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n  0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n  0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n  0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n  0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n  0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n  0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n  0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n  0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n  0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n  0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n  0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n  0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n  0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n  0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n  0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n  0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n  0xBC82919E2040220F, 0x3FEF60E316C98398,\n  0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n  0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n  0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n  0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n  0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n  0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n  0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n  0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n  0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n  0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n  0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n  0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n  0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n  0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n  const\n    Ox1p_1022 = reinterpret<f64>(0x0010000000000000), // 0x1p-1022\n    Ox1p1009  = reinterpret<f64>(0x7F00000000000000); // 0x1p1009\n\n  let scale: f64;\n  if (!(ki & 0x80000000)) {\n    // k > 0, the exponent of scale might have overflowed by <= 460.\n    sbits -= u64(1009) << 52;\n    scale = reinterpret<f64>(sbits);\n    return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n  }\n  // k < 0, need special care in the subnormal range.\n  sbits += u64(1022) << 52;\n  // Note: sbits is signed scale.\n  scale = reinterpret<f64>(sbits);\n  let y = scale + scale * tmp;\n  if (abs(y) < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range.  So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let one = copysign(1.0, y);\n    let lo = scale - y + scale * tmp;\n    let hi = one + y;\n    lo = one - hi + y + lo;\n    y  = (hi + lo) - one;\n    // Fix the sign of 0.\n    if (y == 0.0) y = reinterpret<f64>(sbits & 0x8000000000000000);\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52;\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  let ux = reinterpret<u64>(x);\n  let abstop = u32(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) {\n        return 1.0 + x;\n      } else {\n        return select<f64>(0, Infinity, <i64>ux < 0);\n      }\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n  let z = InvLn2N * x;\n  // #if TOINT_INTRINSICS\n  // \tkd = roundtoint(z);\n  // \tki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  // let kd = z + shift;\n  // let ki = reinterpret<u64>(kd) >> 16;\n  // let kd = <f64><i32>ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes.\n  let kd = z + shift;\n  let ki = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // 2^(k/N) ~= scale * (1 + tail).\n  let idx = usize((ki & N_MASK) << 1);\n  let top = ki << (52 - EXP_TABLE_BITS);\n\n  let tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()))); // T[idx]\n  // This is only a valid scale when -1023*N < k < 1024*N\n  let sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  let r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n  let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  let scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding.  The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n  const Ox1p_1022 = reinterpret<f64>(0x10000000000000); // 0x1p-1022\n  let scale: f64;\n  if ((ki & 0x80000000) == 0) {\n    // k > 0, the exponent of scale might have overflowed by 1\n    sbits -= u64(1) << 52;\n    scale = reinterpret<f64>(sbits);\n    return 2 * (scale * tmp + scale);\n  }\n  // k < 0, need special care in the subnormal range\n  sbits += u64(1022) << 52;\n  scale = reinterpret<f64>(sbits);\n  let y = scale * tmp + scale;\n  if (y < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range. So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let hi: f64, lo: f64;\n    lo = scale - y + scale * tmp;\n    hi = 1.0 + y;\n    lo = 1.0 - hi + y + lo;\n    y = (hi + lo) - 1.0;\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p52\n\n  const\n    C1 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n    C2 = reinterpret<f64>(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n    C3 = reinterpret<f64>(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n    C4 = reinterpret<f64>(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n    C5 = reinterpret<f64>(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n  let ux = reinterpret<u64>(x);\n  let abstop = u32(ux >> 52) & 0x7ff;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      if (<i64>ux >= 0) return Infinity;\n      else if (ux >= 0xC090CC0000000000) return 0;\n    }\n    if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n  }\n\n  // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n  // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n  let kd = x + shift;\n  let ki = reinterpret<u64>(kd);\n  kd -= shift; // k/N for int k\n  let r = x - kd;\n  // 2^(k/N) ~= scale * (1 + tail)\n  let idx = usize((ki & N_MASK) << 1);\n  let top = ki << (52 - EXP_TABLE_BITS);\n\n  let tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 0 << alignof<u64>())); // T[idx])\n  // This is only a valid scale when -1023*N < k < 1024*N\n  let sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution\n  let r2 = r * r;\n  // Without fma the worst case error is 0.5/N ulp larger.\n  // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n  let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase2(tmp, sbits, ki);\n  let scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n  // is no spurious underflow here even without fma.\n  return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n  x = 2^k z\n  log2(x) = k + log2(c) + log2(z/c)\n  log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log2(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p10 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-64 and\n  3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data<u64>([\n  //     invc       ,        logc\n  0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n  0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n  0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n  0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n  0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n  0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n  0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n  0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n  0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n  0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n  0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n  0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n  0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n  0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n  0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n  0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n  0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n  0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n  0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n  0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n  0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n  0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n  0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n  0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n  0x3FF234563D8615B1, 0xBFC7D6023F800000,\n  0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n  0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n  0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n  0x3FF19453847F2200, 0xBFC162595AFDC000,\n  0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n  0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n  0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n  0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n  0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n  0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n  0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n  0x3FF07325CAC53B83, 0xBFA47A954F770000,\n  0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n  0x3FF03091C1208EA2, 0xBF916A2629780000,\n  0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n  0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n  0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n  0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n  0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n  0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n  0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n  0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n  0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n  0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n  0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n  0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n  0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n  0x3FEAC57026295039, 0x3FD0790AB4678000,\n  0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n  0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n  0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n  0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n  0x3FE920FB3982BCF2, 0x3FD651902050D000,\n  0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n  0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n  0x3FE83C97B658B994, 0x3FD9A80155E16000,\n  0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n  0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n  0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data<u64>([\n  //      chi       ,         clo\n  0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n  0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n  0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n  0x3FE6E00038B95A04, 0x3C88FF8856739326,\n  0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n  0x3FE7600015590E10, 0xBC72FD75B4238341,\n  0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n  0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n  0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n  0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n  0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n  0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n  0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n  0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n  0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n  0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n  0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n  0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n  0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n  0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n  0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n  0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n  0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n  0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n  0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n  0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n  0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n  0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n  0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n  0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n  0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n  0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n  0x3FEE200002F64791, 0x3C89802F09EF62E0,\n  0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n  0x3FEEA00027EDC00C, 0xBC8C848309459811,\n  0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n  0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n  0x3FEF6000260C450A, 0xBC4071002727FFDC,\n  0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n  0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n  0x3FF0200004292367, 0x3C9B7FF365324681,\n  0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n  0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n  0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n  0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n  0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n  0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n  0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n  0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n  0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n  0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n  0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n  0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n  0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n  0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n  0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n  0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n  0x3FF460000D387CB1, 0x3C820837856599A6,\n  0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n  0x3FF4E000043543F3, 0xBC781125ED175329,\n  0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n  0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n  0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n  0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n  const\n    LO: u64 = 0x3FEEA4AF00000000, // reinterpret<u64>(1.0 - 0x1.5b51p-5)\n    HI: u64 = 0x3FF0B55900000000; // reinterpret<u64>(1.0 + 0x1.6ab2p-5)\n\n  const\n    InvLn2hi = reinterpret<f64>(0x3FF7154765200000), // 0x1.7154765200000p+0\n    InvLn2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n    Ox1p52   = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  const\n    B0 = reinterpret<f64>(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n    B1 = reinterpret<f64>(0x3FDEC709DC3A03F7), //  0x1.ec709dc3a03f7p-2\n    B2 = reinterpret<f64>(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n    B3 = reinterpret<f64>(0x3FD2776C50F05BE4), //  0x1.2776c50f05be4p-2\n    B4 = reinterpret<f64>(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n    B5 = reinterpret<f64>(0x3FCA61761EC4E736), //  0x1.a61761ec4e736p-3\n    B6 = reinterpret<f64>(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n    B7 = reinterpret<f64>(0x3FC484D154F01B4A), //  0x1.484d154f01b4ap-3\n    B8 = reinterpret<f64>(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n    B9 = reinterpret<f64>(0x3FC0B32F285AEE66); //  0x1.0b32f285aee66p-3\n\n  const\n    A0 = reinterpret<f64>(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n    A1 = reinterpret<f64>(0x3FDEC709DC3A04BE), //  0x1.ec709dc3a04bep-2\n    A2 = reinterpret<f64>(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n    A3 = reinterpret<f64>(0x3FD2776C50034C48), //  0x1.2776c50034c48p-2\n    A4 = reinterpret<f64>(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n    A5 = reinterpret<f64>(0x3FCA6225E117F92E); //  0x1.a6225e117f92ep-3\n\n  let ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r = x - 1.0;\n    // #if __FP_FAST_FMA\n    //     hi = r * InvLn2hi;\n    //     lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n    // #else\n    let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n    let rlo = r - rhi;\n    let hi  = rhi * InvLn2hi;\n    let lo  = rlo * InvLn2hi + r * InvLn2lo;\n    // #endif\n    let r2 = r * r; // rounding error: 0x1p-62\n    let r4 = r2 * r2;\n    // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n    let p = r2 * (B0 + r * B1);\n    let y = hi + p;\n    lo += hi - y + p;\n    lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n          r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n    return y + lo;\n  }\n  let top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan.\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ix - 0x3FE6000000000000;\n  let i    = <usize>((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n  let k    = <i64>tmp >> 52;\n  let iz   = ix - (tmp & 0xFFF0000000000000);\n\n  let invc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  let logc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  let z    = reinterpret<f64>(iz);\n  let kd   = <f64>k;\n\n  // log2(x) = log2(z/c) + log2(c) + k.\n  // r ~= z/c - 1, |r| < 1/(2*N).\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N.\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // \tt1 = r * InvLn2hi;\n  // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-65.\n  let chi = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].chi;\n  let clo = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].clo;\n\n  let r   = (z - chi - clo) * invc;\n  let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n  let rlo = r - rhi;\n  let t1  = rhi * InvLn2hi;\n  let t2  = rlo * InvLn2hi + r * InvLn2lo;\n  // #endif\n\n  // hi + lo = r/ln2 + log2(c) + k\n  let t3 = kd + logc;\n  let hi = t3 + t1;\n  let lo = t3 - hi + t1 + t2;\n\n  // log2(r+1) = r/ln2 + r^2*poly(r)\n  // Evaluation is optimized assuming superscalar pipelined execution\n  let r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n  // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n  let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n  return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p9 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-66 and\n  3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data<u64>([\n  //      invc      ,        logc\n  0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n  0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n  0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n  0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n  0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n  0x3FF69147332F0CBA, 0xBFD602D076180000,\n  0x3FF6719F18224223, 0xBFD5A8CA86909000,\n  0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n  0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n  0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n  0x3FF5F66452C65C4C, 0xBFD445923989A800,\n  0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n  0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n  0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n  0x3FF5805612465687, 0xBFD2E9E2EF468000,\n  0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n  0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n  0x3FF52AFF42064583, 0xBFD1E9E129279000,\n  0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n  0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n  0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n  0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n  0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n  0x3FF4880524D48434, 0xBFCFEB224586F000,\n  0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n  0x3FF453D9D3391854, 0xBFCEA4443D103000,\n  0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n  0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n  0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n  0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n  0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n  0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n  0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n  0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n  0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n  0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n  0x3FF34679984DD440, 0xBFC7D68FB4143000,\n  0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n  0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n  0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n  0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n  0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n  0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n  0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n  0x3FF293726014B530, 0xBFC31B996B490000,\n  0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n  0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n  0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n  0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n  0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n  0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n  0x3FF201201DD2FC9B, 0xBFBE370896404000,\n  0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n  0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n  0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n  0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n  0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n  0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n  0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n  0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n  0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n  0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n  0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n  0x3FF11A3028ECB531, 0xBFB10E4698622000,\n  0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n  0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n  0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n  0x3FF0D244632CA521, 0xBFA9A1894012C000,\n  0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n  0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n  0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n  0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n  0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n  0x3FF06AB58C358F19, 0xBF9A55F152528000,\n  0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n  0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n  0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n  0x3FF02865137932A9, 0xBF8419355DAA0000,\n  0x3FF0182427EA7348, 0xBF781203C2EC0000,\n  0x3FF008040614B195, 0xBF60040979240000,\n  0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n  0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n  0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n  0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n  0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n  0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n  0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n  0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n  0x3FEE01E009609A56, 0x3FB07598E598C000,\n  0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n  0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n  0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n  0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n  0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n  0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n  0x3FEC8B266D37086D, 0x3FBD431332E72000,\n  0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n  0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n  0x3FEBF583EEECE73F, 0x3FC147858292B000,\n  0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n  0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n  0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n  0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n  0x3FEB094B211D304A, 0x3FC5933928D1F000,\n  0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n  0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n  0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n  0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n  0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n  0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n  0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n  0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n  0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n  0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n  0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n  0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n  0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n  0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n  0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n  0x3FE87427AA2317FB, 0x3FD13687334BD000,\n  0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n  0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n  0x3FE8060195F40260, 0x3FD2595FD7636800,\n  0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n  0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n  0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n  0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n  0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data<u64>([\n  //      chi       ,         clo\n  0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n  0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n  0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n  0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n  0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n  0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n  0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n  0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n  0x3FE710000E869780, 0x3C7BFF6671097952,\n  0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n  0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n  0x3FE770000F679C90, 0xBC67FC71CD549C74,\n  0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n  0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n  0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n  0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n  0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n  0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n  0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n  0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n  0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n  0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n  0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n  0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n  0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n  0x3FE9300013467BB9, 0x3C7F804E4B980276,\n  0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n  0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n  0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n  0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n  0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n  0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n  0x3FEA10001145B006, 0x3C74FF489958DA56,\n  0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n  0x3FEA500010971D79, 0x3C88FECADD787930,\n  0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n  0x3FEA90001C593352, 0xBC8EBF0284C27612,\n  0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n  0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n  0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n  0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n  0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n  0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n  0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n  0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n  0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n  0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n  0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n  0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n  0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n  0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n  0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n  0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n  0x3FECB0002125219A, 0xBC68FD8E64180E04,\n  0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n  0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n  0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n  0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n  0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n  0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n  0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n  0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n  0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n  0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n  0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n  0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n  0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n  0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n  0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n  0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n  0x3FEED0001A127FA1, 0xBC5002F860565C92,\n  0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n  0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n  0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n  0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n  0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n  0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n  0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n  0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n  0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n  0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n  0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n  0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n  0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n  0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n  0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n  0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n  0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n  0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n  0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n  0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n  0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n  0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n  0x3FF1B000123D3C59, 0x3C997F7980030188,\n  0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n  0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n  0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n  0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n  0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n  0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n  0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n  0x3FF2B00014556313, 0xBC92808233F21F02,\n  0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n  0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n  0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n  0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n  0x3FF350000CA66756, 0x3C957F82228B82BD,\n  0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n  0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n  0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n  0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n  0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n  0x3FF410001532AFF4, 0x3C67F8375F198524,\n  0x3FF4300017478B29, 0x3C8301E672DC5143,\n  0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n  0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n  0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n  0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n  0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n  0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n  0x3FF5100012DC4BD1, 0x3C6004657166A436,\n  0x3FF530001605277A, 0xBC96BFCECE233209,\n  0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n  0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n  0x3FF5900017E61012, 0x3C887EC581AFEF90,\n  0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n  0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n  0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n  const\n    B0  = reinterpret<f64>(0xBFE0000000000000), // -0x1p-1\n    B1  = reinterpret<f64>(0x3FD5555555555577), //  0x1.5555555555577p-2\n    B2  = reinterpret<f64>(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n    B3  = reinterpret<f64>(0x3FC999999995DD0C), //  0x1.999999995dd0cp-3\n    B4  = reinterpret<f64>(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n    B5  = reinterpret<f64>(0x3FC24924A344DE30), //  0x1.24924a344de3p-3\n    B6  = reinterpret<f64>(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n    B7  = reinterpret<f64>(0x3FBC7184282AD6CA), //  0x1.c7184282ad6cap-4\n    B8  = reinterpret<f64>(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n    B9  = reinterpret<f64>(0x3FB78182F7AFD085), //  0x1.78182f7afd085p-4\n    B10 = reinterpret<f64>(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000001),  // -0x1.0000000000001p-1\n    A1 = reinterpret<f64>(0x3FD555555551305B),  //  0x1.555555551305bp-2\n    A2 = reinterpret<f64>(0xBFCFFFFFFFEB4590),  // -0x1.fffffffeb459p-3\n    A3 = reinterpret<f64>(0x3FC999B324F10111),  //  0x1.999b324f10111p-3\n    A4 = reinterpret<f64>(0xBFC55575E506C89F);  // -0x1.55575e506c89fp-3\n\n  const\n    LO: u64 = 0x3FEE000000000000,\n    HI: u64 = 0x3FF1090000000000;\n\n  const\n    Ln2hi  = reinterpret<f64>(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n    Ln2lo  = reinterpret<f64>(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n    Ox1p27 = reinterpret<f64>(0x41A0000000000000), // 0x1p27\n    Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  let ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r  = x - 1.0;\n    let r2 = r * r;\n    let r3 = r2 * r;\n    let y =\n      r3 * (B1 + r * B2 + r2 * B3 +\n      r3 * (B4 + r * B5 + r2 * B6 +\n      r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n    // Worst-case error is around 0.507 ULP\n    let w   = r * Ox1p27;\n    let rhi = r + w - w;\n    let rlo = r - rhi;\n    w = rhi * rhi * B0; // B[0] == -0.5\n    let hi = r + w;\n    let lo = r - hi + w;\n    lo += B0 * rlo * (rhi + r);\n    return y + lo + hi;\n  }\n  let top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == reinterpret<u64>(Infinity)) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ix - 0x3FE6000000000000;\n  let i    = <usize>((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n  let k    = <i64>tmp >> 52;\n  let iz   = ix - (tmp & (u64(0xFFF) << 52));\n\n  let invc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  let logc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  let z    = reinterpret<f64>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n  // r ~= z/c - 1, |r| < 1/(2*N)\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-66\n  const chi = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T2[i].chi\n  const clo = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T2[i].clo\n  let r = (z - chi - clo) * invc;\n  // #endif\n  let kd = <f64>k;\n\n  // hi + lo = r + log(c) + k*Ln2\n  let w  = kd * Ln2hi + logc;\n  let hi = w + r;\n  let lo = w - hi + r + kd * Ln2lo;\n\n  // log(x) = lo + (log1p(r) - r) + hi\n  let r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst case error if |y| > 0x1p-5:\n  // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n  // Worst case error if |y| > 0x1p-4:\n  // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n  return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = round(0x1p43*log(c))/0x1p43\n  tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n  1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data<u64>([\n  //      invc      ,pad,       logc       ,       logctail\n  0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n  0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n  0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n  0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n  0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n  0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n  0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n  0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n  0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n  0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n  0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n  0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n  0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n  0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n  0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n  0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n  0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n  0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n  0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n  0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n  0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n  0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n  0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n  0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n  0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n  0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n  0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n  0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n  0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n  0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n  0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n  0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n  0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n  0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n  0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n  0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n  0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n  0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n  0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n  0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n  0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n  0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n  0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n  0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n  0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n  0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n  0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n  0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n  0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n  0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n  0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n  0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n  0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n  0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n  0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n  0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n  0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n  0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n  0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n  0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n  0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n  0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n  0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n  0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n  0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n  0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n  0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n  0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n  0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n  0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n  0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n  0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n  0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n  0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n  0x3FF0000000000000, 0, 0, 0,\n  0x3FF0000000000000, 0, 0, 0,\n  0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n  0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n  0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n  0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n  0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n  0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n  0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n  0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n  0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n  0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n  0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n  0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n  0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n  0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n  0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n  0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n  0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n  0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n  0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n  0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n  0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n  0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n  0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n  0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n  0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n  0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n  0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n  0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n  0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n  0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n  0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n  0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n  0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n  0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n  0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n  0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n  0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n  0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n  0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n  0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n  0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n  0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n  0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n  0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n  0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n  0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n  0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n  0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n  0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n  0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n  0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n  0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n  let e = iy >> 52 & 0x7FF;\n  if (e < 0x3FF     ) return 0;\n  if (e > 0x3FF + 52) return 2;\n  e = u64(1) << (0x3FF + 52 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n  return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n  return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n  const N = 1 << POW_LOG_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    Ln2hi = reinterpret<f64>(0x3FE62E42FEFA3800),\n    Ln2lo = reinterpret<f64>(0x3D2EF35793C76730);\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000000),\n    A1 = reinterpret<f64>(0xBFE5555555555560),\n    A2 = reinterpret<f64>(0x3FE0000000000006),\n    A3 = reinterpret<f64>(0x3FE999999959554E),\n    A4 = reinterpret<f64>(0xBFE555555529A47A),\n    A5 = reinterpret<f64>(0xBFF2495B9B4845E9),\n    A6 = reinterpret<f64>(0x3FF0002B8B263FC3);\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp = ix - 0x3fE6955500000000;\n  let i   = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n  let k   = <i64>tmp >> 52;\n  let iz  = ix - (tmp & u64(0xFFF) << 52);\n  let z   = reinterpret<f64>(iz);\n  let kd  = <f64>k;\n\n  // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n  let invc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 0 << alignof<f64>()); // tab[i].invc\n  let logc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 2 << alignof<f64>()); // tab[i].logc\n  let logctail = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 3 << alignof<f64>()); // tab[i].logctail\n\n  // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n  // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n  // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n  let zhi = reinterpret<f64>((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n  let zlo = z - zhi;\n  let rhi = zhi * invc - 1.0;\n  let rlo = zlo * invc;\n  let r   = rhi + rlo;\n\n  // k * Ln2 + log(c) + r.\n  let t1  = kd * Ln2hi + logc;\n  let t2  = t1 + r;\n  let lo1 = kd * Ln2lo + logctail;\n  let lo2 = t1 - t2 + r;\n\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  let ar  = A0 * r; // A[0] = -0.5\n  let ar2 = r * ar;\n  let ar3 = r * ar2;\n  // k * Ln2 + log(c) + r + A[0] * r * r.\n  let arhi  = A0  * rhi;\n  let arhi2 = rhi * arhi;\n  let hi    = t2  + arhi2;\n  let lo3   = rlo * (ar + arhi);\n  let lo4   = t2 - hi + arhi2;\n\n  // p = log1p(r) - r - A[0] * r * r.\n  let p  = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n  let lo = lo1 + lo2 + lo3 + lo4 + p;\n  let y  = hi + lo;\n  log_tail = hi - y + lo;\n\n  return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n  const N      = 1 << EXP_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  let abstop: u32;\n  let ki: u64, top: u64, sbits: u64;\n  let idx: usize;\n  // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n  let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n  let ux = reinterpret<u64>(x);\n  abstop = u32(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) {\n      // Avoid spurious underflow for tiny x.\n      // Note: 0 is common input.\n      return select(-1.0, 1.0, sign_bias);\n    }\n    if (abstop >= 0x409) { // top12(1024.0)\n      // Note: inf and nan are already handled.\n      return <i64>ux < 0\n        ? uflow(sign_bias)\n        : oflow(sign_bias);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n  z = InvLn2N * x;\n\n  // #if TOINT_INTRINSICS\n  //   kd = roundtoint(z);\n  //   ki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  //   // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  //   kd = eval_as_double(z + shift);\n  //   ki = asuint64(kd) >> 16;\n  //   kd = (double_t)(int32_t)ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes\n  kd  = z + shift;\n  ki  = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // The code assumes 2^-200 < |xtail| < 2^-8/N\n  r += xtail;\n  // 2^(k/N) ~= scale * (1 + tail)\n  idx = usize((ki & N_MASK) << 1);\n  top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n  tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>())));\n  // This is only a valid scale when -1023*N < k < 1024*N\n  sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top;\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n  tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n  const Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  let sign_bias: u32 = 0;\n  let ix = reinterpret<u64>(x);\n  let iy = reinterpret<u64>(y);\n  let topx = ix >> 52;\n  let topy = iy >> 52;\n\n  if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n    // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n    // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n    // Special cases: (x < 0x1p-126 or inf or nan) or\n    // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n    if (zeroinfnan(iy)) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n      if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n      if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n      if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnan(ix)) {\n      let x2 = x * x;\n      if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n      return <i64>iy < 0 ? 1 / x2 : x2;\n    }\n    // Here x and y are non-zero finite\n    if (<i64>ix < 0) {\n      // Finite x < 0\n      let yint = checkint(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) sign_bias = SIGN_BIAS;\n      ix   &= 0x7FFFFFFFFFFFFFFF;\n      topx &= 0x7FF;\n    }\n    if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n      // Note: sign_bias == 0 here because y is not odd.\n      if (ix == 0x3FF0000000000000) return 1;\n      if ((topy & 0x7FF) < 0x3BE)   return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n      return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n    }\n    if (topx == 0) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u64>(x * Ox1p52);\n      ix &= 0x7FFFFFFFFFFFFFFF;\n      ix -= u64(52) << 52;\n    }\n  }\n\n  let hi = log_inline(ix);\n  let lo = log_tail;\n  let ehi: f64, elo: f64;\n  // #if __FP_FAST_FMA\n  //   ehi = y * hi;\n  //   elo = y * lo + __builtin_fma(y, hi, -ehi);\n  // #else\n  let yhi = reinterpret<f64>(iy & 0xFFFFFFFFF8000000);\n  let ylo = y - yhi;\n  let lhi = reinterpret<f64>(reinterpret<u64>(hi) & 0xFFFFFFFFF8000000);\n  let llo = hi - lhi + lo;\n  ehi = yhi * lhi;\n  elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n  // #endif\n  return exp_inline(ehi, elo, sign_bias);\n}\n","/// <reference path=\"../rt/index.d.ts\" />\n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<u32>([\n  1,\n  10,\n  100,\n  1000,\n  10000,\n  100000,\n  1000000,\n  10000000,\n  100000000,\n  1000000000\n]);\n\n/*\n  Lookup table for pairwise char codes in range [0-99]\n\n  \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n  \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n  \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n  \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n  \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n  \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n  \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n  \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n  \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n  \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data<u32>([\n  0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n  0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n  0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n  0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n  0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n  0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n  0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n  0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n  0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n  0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n  0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n  0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n  0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n  0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n  0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n  0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n  0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n  0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n  0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n  0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data<i16>([/* eslint-disable indent */\n  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,\n   -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,\n   -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,\n   -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,\n   -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,\n    109,   136,   162,   189,   216,   242,   269,   295,   322,   348,\n    375,   402,   428,   455,   481,   508,   534,   561,   588,   614,\n    641,   667,   694,   720,   747,   774,   800,   827,   853,   880,\n    907,   933,   960,   986,  1013,  1039,  1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data<u64>([\n  0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n  0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n  0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n  0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n  0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n  0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n  0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n  0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n  0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n  0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n  0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n  0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n  0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n  0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n  0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n  0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n  0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n  0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n  0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n  0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n  0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n  0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2<T extends number>(value: T): bool {\n  return popcnt<T>(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n  if (value < 100000) {\n    if (value < 100) {\n      return 1 + u32(value >= 10);\n    } else {\n      return 3 + u32(value >= 10000) + u32(value >= 1000);\n    }\n  } else {\n    if (value < 10000000) {\n      return 6 + u32(value >= 1000000);\n    } else {\n      return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n    }\n  }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n  if (value < 1000000000000000) {\n    if (value < 1000000000000) {\n      return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n    } else {\n      return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n    }\n  } else {\n    if (value < 100000000000000000) {\n      return 16 + u32(value >= 10000000000000000);\n    } else {\n      return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n    }\n  }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n  if (isPowerOf2(base)) {\n    return (63 - <u32>clz(num)) / (31 - <u32>clz(base)) + 1;\n  }\n  let b64 = u64(base), b = b64, e: u32 = 1;\n  while (num >= b) {\n    num /= b;\n    b *= b;\n    e <<= 1;\n  }\n  while (num >= 1) {\n    num /= b64;\n    e++;\n  }\n  return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n  while (num >= 10000) {\n    // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n    let t = num / 10000;\n    let r = num % 10000;\n    num = t;\n\n    let d1 = r / 100;\n    let d2 = r % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>d2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  if (num >= 100) {\n    let t  = num / 100;\n    let d1 = num % 100;\n    num = t;\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  }\n\n  if (num >= 10) {\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>num << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  } else {\n    offset -= 1;\n    let digit = CharCode._0 + num;\n    store<u16>(buffer + (offset << 1), digit);\n  }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n  while (num >= 100000000) {\n    let t = num / 100000000;\n    let r = <usize>(num - t * 100000000);\n    num = t;\n\n    let b = r / 10000;\n    let c = r % 10000;\n\n    let b1 = b / 100;\n    let b2 = b % 100;\n    let c1 = c / 100;\n    let c2 = c % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>c1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>c2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n    digits1 = <u64>load<u32>(DIGITS + (<usize>b1 << alignof<u32>()));\n    digits2 = <u64>load<u32>(DIGITS + (<usize>b2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  utoa32_dec_lut(buffer, <u32>num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n  const lut = changetype<usize>(HEX_DIGITS);\n  while (offset >= 2) {\n    offset -= 2;\n    store<u32>(\n      buffer + (offset << 1),\n      load<u32>(lut + ((<usize>num & 0xFF) << alignof<u32>()))\n    );\n    num >>= 8;\n  }\n  if (offset & 1) {\n    store<u16>(buffer, load<u16>(lut + (<usize>num << 6)));\n  }\n}\n\nfunction utoa_dec_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let t = num / 10;\n    let r = <u32>(num % 10);\n    num = changetype<T>(t);\n    offset--;\n    store<u16>(buffer + (offset << 1), CharCode._0 + r);\n  } while (num);\n}\n\nfunction utoa_hex_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let d = num & 0x0F | CharCode._0;\n    d += select<T>(<T>0x27, <T>0, d > <T>CharCode._9);\n    offset--;\n    store<u16>(buffer + (offset << 1), d);\n    // @ts-ignore: type\n    num >>= 4;\n  } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u32>(buffer, num, offset);\n  } else {\n    utoa32_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u32>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u64>(buffer, num, offset);\n  } else {\n    utoa64_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u64>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n  const lut = changetype<usize>(ANY_DIGITS);\n  let base = u64(radix);\n  if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n    let shift = u64(ctz(radix) & 7);\n    let mask = base - 1;\n    do {\n      offset--;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num & mask) << 1)));\n      num >>= shift;\n    } while (num);\n  } else {\n    do {\n      offset--;\n      let q = num / base;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num - q * base) << 1)));\n      num = q;\n    } while (num);\n  }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  let out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out), value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  let sign = (value >>> 31) << 1;\n  if (sign) value = -value;\n  let out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out) + sign, value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out) + sign, value, decimals);\n  } else {\n    let val32 = u32(value);\n    let decimals = ulog_base(val32, radix);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_any_core(changetype<usize>(out) + sign, val32, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  let out: String;\n\n  if (radix == 10) {\n    if (value <= u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out), val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out), value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  let sign = u32(value >>> 63) << 1;\n  if (sign) value = -value;\n  let out: String;\n\n  if (radix == 10) {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out) + sign, val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out) + sign, value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out) + sign, value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_any_core(changetype<usize>(out) + sign, value, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n  let u0 = u & 0xFFFFFFFF;\n  let v0 = v & 0xFFFFFFFF;\n\n  let u1 = u >> 32;\n  let v1 = v >> 32;\n\n  let l = u0 * v0;\n  let t = u1 * v0 + (l >> 32);\n  let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n  w += 0x7FFFFFFF; // rounding\n\n  t >>= 32;\n  w >>= 32;\n\n  return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n  return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n  let frc = (f << 1) + 1;\n  let exp = e - 1;\n  let off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n  _frc_plus  = frc;\n  _frc_minus = ((f << m) - 1) << e - m - exp;\n  _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n  let lastp = buffer + ((len - 1) << 1);\n  let digit = load<u16>(lastp);\n  while (\n    rest < wp_w &&\n    delta - rest >= ten_kappa && (\n      rest + ten_kappa < wp_w ||\n      wp_w - rest > rest + ten_kappa - wp_w\n    )\n  ) {\n    --digit;\n    rest += ten_kappa;\n  }\n  store<u16>(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n  const c = reinterpret<f64>(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n  let dk = (-61 - minExp) * c + 347;\t            // dk must be positive, so can do ceiling in positive\n  let k = <i32>dk;\n  k += i32(k != dk); // conversion with ceil\n\n  let index = (k >> 3) + 1;\n  _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n  _frc_pow = load<u64>(FRC_POWERS + (<usize>index << alignof<u64>()));\n  _exp_pow = load<i16>(EXP_POWERS + (<usize>index << alignof<i16>()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n  let frc: u64;\n  let exp: i32;\n\n  // frexp routine\n  if (isSingle) {\n    let uv = reinterpret<u32>(<f32>value);\n    exp = (uv & 0x7F800000) >>> 23;\n    let sid = uv & 0x007FFFFF;\n    frc = (u64(exp != 0) << 23) + sid;\n    exp = (exp || 1) - (0x7F + 23);\n  } else {\n    let uv = reinterpret<u64>(value);\n    exp = i32((uv & 0x7FF0000000000000) >>> 52);\n    let sid = uv & 0x000FFFFFFFFFFFFF;\n    frc = (u64(exp != 0) << 52) + sid;\n    exp = (exp || 1) - (0x3FF + 52);\n  }\n\n  normalizedBoundaries(frc, exp, isSingle);\n  getCachedPower(_exp);\n\n  // normalize\n  let off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  let frc_pow = _frc_pow;\n  let exp_pow = _exp_pow;\n\n  let w_frc = umul64f(frc, frc_pow);\n  let w_exp = umul64e(exp, exp_pow);\n\n  let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n  let wp_exp = umul64e(_exp, exp_pow);\n\n  let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n  let delta  = wp_frc - wm_frc;\n\n  return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n  let one_exp = -mp_exp;\n  let one_frc = (<u64>1) << one_exp;\n  let mask    = one_frc - 1;\n\n  let wp_w_frc = mp_frc - w_frc;\n\n  let p1 = u32(mp_frc >> one_exp);\n  let p2 = mp_frc & mask;\n\n  let kappa = <i32>decimalCount32(p1);\n  let len = sign;\n\n  while (kappa > 0) {\n    let d: u32;\n    switch (kappa) {\n      case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n      case  9: { d = p1 /  100000000; p1 %=  100000000; break; }\n      case  8: { d = p1 /   10000000; p1 %=   10000000; break; }\n      case  7: { d = p1 /    1000000; p1 %=    1000000; break; }\n      case  6: { d = p1 /     100000; p1 %=     100000; break; }\n      case  5: { d = p1 /      10000; p1 %=      10000; break; }\n      case  4: { d = p1 /       1000; p1 %=       1000; break; }\n      case  3: { d = p1 /        100; p1 %=        100; break; }\n      case  2: { d = p1 /         10; p1 %=         10; break; }\n      case  1: { d = p1;              p1 =           0; break; }\n      default: { d = 0; break; }\n    }\n\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    --kappa;\n    let tmp = ((<u64>p1) << one_exp) + p2;\n    if (tmp <= delta) {\n      _K += kappa;\n      grisuRound(buffer, len, delta, tmp, <u64>load<u32>(POWERS10 + (<usize>kappa << alignof<u32>())) << one_exp, wp_w_frc);\n      return len;\n    }\n  }\n\n  while (true) {\n    p2    *= 10;\n    delta *= 10;\n\n    let d = p2 >> one_exp;\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    p2 &= mask;\n    --kappa;\n    if (p2 < delta) {\n      _K += kappa;\n      wp_w_frc *= <u64>load<u32>(POWERS10 + (<usize>-kappa << alignof<u32>()));\n      grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n      return len;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n  let sign = k < 0;\n  if (sign) k = -k;\n  let decimals = decimalCount32(k) + 1;\n  utoa32_dec_core(buffer, k, decimals);\n  store<u16>(buffer, <u16>select<u32>(CharCode.MINUS, CharCode.PLUS, sign));\n  return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n  if (!k) {\n    store<u32>(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n    return length + 2;\n  }\n\n  let kk = length + k;\n  if (length <= kk && kk <= 21) {\n    // 1234e7 -> 12340000000\n    for (let i = length; i < kk; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    store<u32>(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n    return kk + 2;\n  } else if (kk > 0 && kk <= 21) {\n    // 1234e-2 -> 12.34\n    let ptr = buffer + (kk << 1);\n    memory.copy(\n      ptr + 2,\n      ptr,\n      -k << 1\n    );\n    store<u16>(buffer + (kk << 1), CharCode.DOT);\n    return length + 1;\n  } else if (-6 < kk && kk <= 0) {\n    // 1234e-6 -> 0.001234\n    let offset = 2 - kk;\n    memory.copy(\n      buffer + (offset << 1),\n      buffer,\n      length << 1\n    );\n    store<u32>(buffer, CharCode._0 | (CharCode.DOT << 16));\n    for (let i = 2; i < offset; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    return length + offset;\n  } else if (length == 1) {\n    // 1e30\n    store<u16>(buffer, CharCode.e, 2);\n    length = genExponent(buffer + 4, kk - 1);\n    return length + 2;\n  } else {\n    let len = length << 1;\n    memory.copy(\n      buffer + 4,\n      buffer + 2,\n      len - 2\n    );\n    store<u16>(buffer,       CharCode.DOT, 2);\n    store<u16>(buffer + len, CharCode.e,   2);\n    length += genExponent(buffer + len + 4, kk - 1);\n    return length + 2;\n  }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n  let sign = i32(value < 0);\n  if (sign) {\n    value = -value;\n    store<u16>(buffer, CharCode.MINUS);\n  }\n  // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n  let len = grisu2(value, buffer, sign, isSingle);\n  len = prettify(buffer + (sign << 1), len - sign, _K);\n  return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa<T extends number>(value: T): String {\n  const isSingle = isFloat<T>() && sizeof<T>() == 4;\n  return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n  if (value == 0) return \"0.0\";\n  if (!isFinite(value)) {\n    if (isNaN(value)) return \"NaN\";\n    return select<String>(\"-Infinity\", \"Infinity\", value < 0);\n  }\n  let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n  let result = changetype<String>(__new(size, idof<String>()));\n  memory.copy(changetype<usize>(result), dtoa_buf, size);\n  return result;\n}\n\nexport function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  let sign: u32 = 0;\n  if (isSigned<T>()) {\n    sign = u32(value < 0);\n    if (sign) {\n      if (sizeof<T>() == 1) {\n        if (value == -0x80) {\n          // -0x80  ->  -128\n          store<u64>(buffer,\n            <u64>CharCode.MINUS |\n            <u64>(CharCode._0 + 1) << 16 |\n            <u64>(CharCode._0 + 2) << 32 |\n            <u64>(CharCode._0 + 8) << 48\n          );\n          return 4;\n        }\n      }\n      if (sizeof<T>() == 2) {\n        if (value == -0x8000) {\n          // -0x8000  ->  -32768\n          store<u64>(buffer,\n            <u64>CharCode.MINUS |\n            <u64>(CharCode._0 + 3) << 16 |\n            <u64>(CharCode._0 + 2) << 32 |\n            <u64>(CharCode._0 + 7) << 48\n          ); // -327\n          store<u32>(buffer + 8,\n            (CharCode._0 + 6) << 0 |\n            (CharCode._0 + 8) << 16\n          ); // 68\n          return 6;\n        }\n      }\n      store<u16>(buffer, CharCode.MINUS);\n      // @ts-ignore\n      value = -value;\n    }\n  }\n  let dest = buffer + (sign << 1);\n  if (ASC_SHRINK_LEVEL <= 1) {\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        if (<u32>value < 10) {\n          store<u16>(dest, value | CharCode._0);\n          return 1 + sign;\n        }\n      } else {\n        if (<u64>value < 10) {\n          store<u16>(dest, value | CharCode._0);\n          return 1 + sign;\n        }\n      }\n    } else {\n      if (value < 10) {\n        store<u16>(buffer, value | CharCode._0);\n        return 1;\n      }\n    }\n  }\n  let decimals: u32 = 0;\n  if (sizeof<T>() <= 4) {\n    let val32 = <u32>value;\n    decimals = decimalCount32(val32);\n    utoa32_dec_core(dest, val32, decimals);\n  } else {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32 = <u32>value;\n      decimals = decimalCount32(val32);\n      utoa32_dec_core(dest, val32, decimals);\n    } else {\n      let val64 = <u64>value;\n      decimals = decimalCount64High(val64);\n      utoa64_dec_core(dest, val64, decimals);\n    }\n  }\n  return sign + decimals;\n}\n\nexport function dtoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  const isSingle = isFloat<T>() && sizeof<T>() == 4;\n  return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n  if (value == 0) {\n    store<u16>(buffer, CharCode._0);\n    store<u16>(buffer, CharCode.DOT, 2);\n    store<u16>(buffer, CharCode._0,  4);\n    return 3;\n  }\n  if (!isFinite(value)) {\n    if (isNaN(value)) {\n      store<u16>(buffer, CharCode.N);\n      store<u16>(buffer, CharCode.a, 2);\n      store<u16>(buffer, CharCode.N, 4);\n      return 3;\n    } else {\n      let sign = value < 0;\n      if (sign) {\n        store<u16>(buffer, CharCode.MINUS); // -\n        buffer += 2;\n      }\n      store<u64>(buffer, 0x690066006E0049, 0); // ifnI\n      store<u64>(buffer, 0x7900740069006E, 8); // ytin\n      return 8 + u32(sign);\n    }\n  }\n  return dtoa_core(buffer, value, isSingle);\n}\n","import {\n  itoa32,\n  utoa32,\n  itoa64,\n  utoa64,\n  dtoa,\n  itoa_buffered,\n  dtoa_buffered,\n  MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n  ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data<u8>([\n  18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n  41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n  68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n  93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n  17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n  119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n  16,16,125,16,16,16,\n  16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n  255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n  251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n  255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n  255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n  31,254,225,255,\n  159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n  255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n  1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n  255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n  197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n  94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n  159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n  255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n  207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n  253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n  251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n  0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n  0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n  31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n  255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n  255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n  127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n  7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n  255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n  255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n  255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n  63,\n  0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n  255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n  127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n  255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n  255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n  128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n  255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n  224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n  0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n  255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n  255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n  255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n  255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,\n  31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n  255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n  0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n  255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n  255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n  255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n  255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n  255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n  126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n  255,\n  15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n  252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n  254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n  252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n  0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n  255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n  255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n  127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n  254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n  255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n  0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n  0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n  0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n  255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n  255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n  127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n  253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n  255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n  3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n  7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n  127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n  255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n  255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n  255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n  0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,\n  0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n  255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n  255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n  223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n  255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n  247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n  255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n  128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n  3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n  132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data<u8>([\n  18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n  24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n  29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n  16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n  16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n  16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n  255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n  0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n  255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n  255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n  255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n  132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n  255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n  255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n  255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n  255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n  0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n  254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n  255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n  95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n  253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n  255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n  15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data<u8>([\n  18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n  33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n  43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n  47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n  16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n  66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n  88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n  16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n  0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n  1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n  0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n  0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n  254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n  6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n  190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n  4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n  193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n  3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n  0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n  0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n  0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n  0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n  0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n  0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n  0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n  0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n  15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n  0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n  0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n  255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n  3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n  0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n  0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n  0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n  0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n  255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n  128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n  0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n  2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n  255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n  0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n  0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n  0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n  3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n  3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n  0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n  0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n  0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n  0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n  231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n  0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  91,92,93,94,95,96,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  91,92,93,94,95,96,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<f64>([\n  1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n  1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n  1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n  PERCENT = 0x25,\n  PLUS = 0x2B,\n  MINUS = 0x2D,\n  DOT = 0x2E,\n  _0 = 0x30,\n  _1 = 0x31,\n  _2 = 0x32,\n  _3 = 0x33,\n  _4 = 0x34,\n  _5 = 0x35,\n  _6 = 0x36,\n  _7 = 0x37,\n  _8 = 0x38,\n  _9 = 0x39,\n  A = 0x41,\n  B = 0x42,\n  E = 0x45,\n  I = 0x49,\n  N = 0x4E,\n  O = 0x4F,\n  X = 0x58,\n  Z = 0x5A,\n  a = 0x61,\n  b = 0x62,\n  e = 0x65,\n  n = 0x6E,\n  o = 0x6F,\n  u = 0x75,\n  x = 0x78,\n  z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n  return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n  return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n  return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n  if (c < 0x1680) { // < <LS> (1)\n    // <SP>, <TAB>, <LF>, <VT>, <FF>, <CR> and <NBSP>\n    // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n    return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n  }\n  if (c - 0x2000 <= 0x200A - 0x2000) return true;\n  switch (c) {\n    case 0x1680: // <LS> (1)\n    case 0x2028: // <LS> (2)\n    case 0x2029: // <PS>\n    case 0x202F: // <NNS>\n    case 0x205F: // <MMSP>\n    case 0x3000: // <IS>\n    case 0xFEFF: return true; // <ZWNBSP>\n  }\n  return false;\n}\n\nexport function isAlpha(c: u32): bool {\n  if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n  if (c < 0x20000) {\n    // @ts-ignore: cast\n    return stagedBinaryLookup(ALPHA_TABLE, c);\n  }\n  return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n  const lookaheadLimit = 30; // max lookahead limit\n  let found = false;\n  let pos = index;\n  let minPos = max(0, pos - lookaheadLimit);\n  while (pos > minPos) {\n    let c = codePointBefore(buffer, pos);\n    if (!isCaseIgnorable(c)) {\n      if (isCased(c)) {\n        found = true;\n      } else {\n        return false;\n      }\n    }\n    pos -= isize(c >= 0x10000) + 1;\n  }\n  if (!found) return false;\n  pos = index + 1;\n  let maxPos = min(pos + lookaheadLimit, len);\n  while (pos < maxPos) {\n    let c = <u32>load<u16>(buffer + (pos << 1));\n    if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n      let c1 = <u32>load<u16>(buffer + (pos << 1), 2);\n      if ((c1 & 0xFC00) == 0xDC00) {\n        c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n      }\n    }\n    if (!isCaseIgnorable(c)) {\n      return !isCased(c);\n    }\n    pos += isize(c >= 0x10000) + 1;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n  if (index <= 0) return -1;\n  let c = <u32>load<u16>(buffer + (index - 1 << 1));\n  if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n    let c1 = <u32>load<u16>(buffer + (index - 2 << 1));\n    if ((c1 & 0xFC00) == 0xD800) {\n      return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n    }\n  }\n  return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n  return <bool>((load<u8>(table + (<u32>load<u8>(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n  let ptr1 = changetype<usize>(str1) + (index1 << 1);\n  let ptr2 = changetype<usize>(str2) + (index2 << 1);\n  if (ASC_SHRINK_LEVEL < 2) {\n    if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n      do {\n        if (load<u64>(ptr1) != load<u64>(ptr2)) break;\n        ptr1 += 8;\n        ptr2 += 8;\n        len  -= 4;\n      } while (len >= 4);\n    }\n  }\n  while (len--) {\n    let a = <i32>load<u16>(ptr1);\n    let b = <i32>load<u16>(ptr2);\n    if (a != b) return a - b;\n    ptr1 += 2;\n    ptr2 += 2;\n  }\n  return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c | u32(isUpper8(c)) << 5;\n  } else {\n    return <u32>load<u8>(LOWER127 + c);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c & ~(u32(isLower8(c)) << 5);\n  } else {\n    return <u32>load<u8>(UPPER127 + c);\n  }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol<T>(str: string, radix: i32 = 0): T {\n  let len = str.length;\n  if (!len) {\n    if (isFloat<T>()) {\n      // @ts-ignore: cast\n      return <T>NaN;\n    } else {\n      // @ts-ignore: cast\n      return <T>0;\n    }\n  }\n\n  let ptr = changetype<usize>(str) /* + HEAD -> offset */;\n  let code = <u32>load<u16>(ptr);\n\n  // trim white spaces\n  while (isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  // determine sign\n  // @ts-ignore\n  let sign: T = 1;\n  if (code == CharCode.MINUS || code == CharCode.PLUS) {\n    if (!--len) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    if (code == CharCode.MINUS) {\n      // @ts-ignore: type\n      sign = -1;\n    }\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // See https://tc39.es/ecma262/#sec-parseint-string-radix\n  if (radix) {\n    if (radix < 2 || radix > 36) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    // handle case as parseInt(\"0xFF\", 16) by spec\n    if (radix == 16) {\n      if (\n        len > 2 &&\n        code == CharCode._0 &&\n        (<u32>load<u16>(ptr, 2) | 32) == CharCode.x\n      ) {\n        ptr += 4; len -= 2;\n      }\n    }\n  } else {\n    // determine radix by literal prefix\n    if (code == CharCode._0 && len > 2) {\n      switch (<u32>load<u16>(ptr, 2) | 32) {\n        case CharCode.b: {\n          ptr += 4; len -= 2;\n          radix = 2;\n          break;\n        }\n        case CharCode.o: {\n          ptr += 4; len -= 2;\n          radix = 8;\n          break;\n        }\n        case CharCode.x: {\n          ptr += 4; len -= 2;\n          radix = 16;\n          break;\n        }\n      }\n    }\n    if (!radix) radix = 10;\n  }\n\n  // calculate value\n  // @ts-ignore: type\n  let num: T = 0;\n  let initial = len - 1;\n  while (len--) {\n    code = <u32>load<u16>(ptr);\n    if (code - CharCode._0 < 10) {\n      code -= CharCode._0;\n    } else if (code - CharCode.A <= <u32>(CharCode.Z - CharCode.A)) {\n      code -= CharCode.A - 10;\n    } else if (code - CharCode.a <= <u32>(CharCode.z - CharCode.a)) {\n      code -= CharCode.a - 10;\n    }\n    if (code >= <u32>radix) {\n      if (initial == len) {\n        if (isFloat<T>()) {\n          // @ts-ignore: cast\n          return <T>NaN;\n        } else {\n          // @ts-ignore: cast\n          return <T>0;\n        }\n      }\n      break;\n    }\n    // @ts-ignore: type\n    num = num * radix + code;\n    ptr += 2;\n  }\n  // @ts-ignore: type\n  return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n  let len = str.length;\n  if (!len) return NaN;\n\n  let ptr  = changetype<usize>(str);\n  let code = <u32>load<u16>(ptr);\n\n  let sign = 1.0;\n  // skip white spaces\n  while (len && isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (!len) return NaN;\n\n  // try parse '-' or '+'\n  if (code == CharCode.MINUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // try parse Infinity\n  if (len >= 8 && code == CharCode.I) {\n    if (\n      load<u64>(ptr, 0) == 0x690066006E0049 && // ifnI\n      load<u64>(ptr, 8) == 0x7900740069006E    // ytin\n    ) {\n      return Infinity * sign;\n    }\n    return NaN;\n  }\n  // validate next symbol\n  if (code != CharCode.DOT && <u32>(code - CharCode._0) >= 10) {\n    return NaN;\n  }\n  let savedPtr = ptr;\n  // skip zeros\n  while (code == CharCode._0) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (len <= 0) return 0.0 * sign;\n  const capacity = 19; // int(64 * 0.3010)\n  let pointed = false;\n  let consumed = 0;\n  let position = 0;\n  let x: u64 = 0;\n  if (code == CharCode.DOT) {\n    let noDigits = !(savedPtr - ptr);\n    ptr += 2; --len;\n    if (!len && noDigits) return NaN;\n    for (pointed = true; (code = <u32>load<u16>(ptr)) == CharCode._0; --position, ptr += 2) --len;\n    if (len <= 0) return 0.0 * sign;\n    if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n  }\n  for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n    if (digit < 10) {\n      x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n      ++consumed;\n    } else {\n      position = consumed;\n      pointed = true;\n    }\n    if (!--len) break;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  if (!pointed) position = consumed;\n  return copysign<f64>(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n  let size: usize = str.length << 1;\n  let offset: usize = 0;\n  if (size > 8) {\n    // try trim end whitespaces first\n    while (size && isSpace(load<u16>(changetype<usize>(str) + size - 2))) size -= 2;\n    if (size > 8) {\n      // trim start whitespaces\n      while (offset < size && isSpace(load<u16>(changetype<usize>(str) + offset))) offset += 2;\n      size -= offset;\n    }\n  }\n  if (size != 8) return false;\n  // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n  return load<u64>(changetype<usize>(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) return select(\"true\", \"false\", load<bool>(dataStart));\n\n  let sepLen = separator.length;\n  let valueLen = 5; // max possible length of element len(\"false\")\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: bool;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<bool>(dataStart + i);\n    valueLen = 4 + i32(!value);\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(select(\"true\", \"false\", value)),\n      <usize>valueLen << 1\n    );\n    offset += valueLen;\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<bool>(dataStart + <usize>lastIndex);\n  valueLen = 4 + i32(!value);\n  memory.copy(\n    changetype<usize>(result) + (<usize>offset << 1),\n    changetype<usize>(select(\"true\", \"false\", value)),\n    valueLen << 1\n  );\n  offset += valueLen;\n\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinIntegerArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    let value = load<T>(dataStart);\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(itoa32(<i32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(itoa64(<i32>value, 10));\n      }\n    } else {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(utoa32(<u32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(utoa64(<u64>value, 10));\n      }\n    }\n  }\n\n  let sepLen = separator.length;\n  const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + i32(isSigned<T>());\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinFloatArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    return changetype<string>(dtoa(\n      // @ts-ignore: type\n      load<T>(dataStart))\n    );\n  }\n\n  const valueLen = MAX_DOUBLE_LENGTH;\n  let sepLen = separator.length;\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    // @ts-ignore: type\n    return load<string>(dataStart) || \"\";\n  }\n  let estLen = 0;\n  let value: string;\n  for (let i = 0; i < length; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (changetype<usize>(value) != 0) estLen += value.length;\n  }\n  let offset = 0;\n  let sepLen = separator.length;\n  let result = changetype<string>(__new((estLen + sepLen * lastIndex) << 1, idof<string>()));\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (changetype<usize>(value) != 0) {\n      let valueLen = value.length;\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(value),\n        <usize>valueLen << 1\n      );\n      offset += valueLen;\n    }\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<string>(dataStart + (<usize>lastIndex << alignof<string>()));\n  if (changetype<usize>(value) != 0) {\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(value),\n      <usize>value.length << 1\n    );\n  }\n  return result;\n}\n\nexport function joinReferenceArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  let value: T;\n  if (!lastIndex) {\n    value = load<T>(dataStart);\n    // @ts-ignore: type\n    return value != null ? value.toString() : \"\";\n  }\n  let result = \"\";\n  let sepLen = separator.length;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    if (value != null) result += value.toString();\n    if (sepLen) result += separator;\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  if (value != null) result += value.toString();\n  return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n  if (!significand || exp < -342) return 0;\n  if (exp > 308) return Infinity;\n  // Try use fast path\n  // Use fast path for string-to-double conversion if possible\n  // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n  // Simple integer\n  let significandf = <f64>significand;\n  if (!exp) return significandf;\n  if (exp > 22 && exp <= 22 + 15) {\n    significandf *= pow10(exp - 22);\n    exp = 22;\n  }\n  if (significand <= 9007199254740991 && abs(exp) <= 22) {\n    if (exp > 0) return significandf * pow10(exp);\n    return significandf / pow10(-exp);\n  } else if (exp < 0) {\n    return scaledown(significand, exp);\n  } else {\n    return scaleup(significand, exp);\n  }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n  const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n  const scale = reinterpret<f64>(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n  let shift = clz(significand);\n  significand <<= shift;\n  shift = exp - shift;\n\n  for (; exp <= -14; exp += 14) {\n    let q = significand / denom;\n    let r = significand % denom;\n    let s = clz(q);\n    significand = (q << s) + <u64>nearest(scale * <f64>(r << (s - 18)));\n    shift -= s;\n  }\n  let b = <u64>ipow32(5, -exp);\n  let q = significand / b;\n  let r = significand % b;\n  let s = clz(q);\n  significand = (q << s) + <u64>(reinterpret<f64>(reinterpret<u64>(<f64>r) + (s << 52)) / <f64>b);\n  shift -= s;\n\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n  const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n  let shift = ctz(significand);\n  significand >>= shift;\n  shift += exp;\n\n  __fixmulShift = shift;\n  for (; exp >= 13; exp -= 13) {\n    significand = fixmul(significand, coeff);\n  }\n  significand = fixmul(significand, <u32>ipow32(5, exp));\n  shift = __fixmulShift;\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n  let sign = 1, magnitude = 0;\n  let code = <u32>load<u16>(ptr);\n  // check code is 'e' or 'E'\n  if ((code | 32) != CharCode.e) return 0;\n\n  if (!--len) return 0;\n  code = <u32>load<u16>(ptr += 2);\n  if (code == CharCode.MINUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  // skip zeros\n  while (code == CharCode._0) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n    if (magnitude >= 3200) return sign * 3200;\n    magnitude = 10 * magnitude + digit;\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n  let low  = (a & 0xFFFFFFFF) * b;\n  let high = (a >> 32) * b + (low >> 32);\n  let overflow = <u32>(high >> 32);\n  let space = clz(overflow);\n  let revspace: u64 = 32 - space;\n  __fixmulShift += revspace;\n  return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n  // argument `n` should bounds in [0, 22] range\n  return load<f64>(POWERS10 + (n << alignof<f64>()));\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n  pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n  powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n  abs as builtin_abs,\n  ceil as builtin_ceil,\n  clz as builtin_clz,\n  copysign as builtin_copysign,\n  floor as builtin_floor,\n  max as builtin_max,\n  min as builtin_min,\n  sqrt as builtin_sqrt,\n  trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data<u64>([\n  0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n  0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n  0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n  0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n  0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n  0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n  const                   // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f64>(0x3FC5555555555555), //  1.66666666666666657415e-01\n    pS1 = reinterpret<f64>(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n    pS2 = reinterpret<f64>(0x3FC9C1550E884455), //  2.01212532134862925881e-01\n    pS3 = reinterpret<f64>(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n    pS4 = reinterpret<f64>(0x3F49EFE07501B288), //  7.91534994289814532176e-04\n    pS5 = reinterpret<f64>(0x3F023DE10DFDF709), //  3.47933107596021167570e-05\n    qS1 = reinterpret<f64>(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n    qS2 = reinterpret<f64>(0x40002AE59C598AC8), //  2.02094576023350569471e+00\n    qS3 = reinterpret<f64>(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n    qS4 = reinterpret<f64>(0x3FB3B8C5B12E9282); //  7.70381505559019352791e-02\n\n  let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n  let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n  return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                       // see: musl/src/math/__expo2.c\n    k    = <u32>2043,\n    kln2 = reinterpret<f64>(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n  let scale = reinterpret<f64>(<u64>((<u32>0x3FF + k / 2) << 20) << 32);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  // Bits of π/4\n  const p0: u64 = 0xC4C6628B80DC1CD1;\n  const p1: u64 = 0xC90FDAA22168C234;\n\n  const Ox1p_64 = reinterpret<f64>(0x3BF0000000000000); // 0x1p-64\n  const Ox1p_75 = reinterpret<f64>(0x3B40000000000000); // 0x1p-75\n\n  let shift = clz(q1);\n\n  q1 = q1 << shift | q0 >> (64 - shift);\n  q0 <<= shift;\n\n  let lo = umuldi(p1, q1);\n  let hi = res128_hi;\n\n  let ahi = hi >> 11;\n  let alo = lo >> 11 | hi << 53;\n  let blo = <u64>(Ox1p_75 * <f64>p0 * <f64>q1 + Ox1p_75 * <f64>p1 * <f64>q0);\n\n  rempio2_y0 = <f64>(ahi + u64(lo < blo));\n  rempio2_y1 = Ox1p_64 * <f64>(alo + blo);\n\n  return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n  let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n  u1 = u & 0xFFFFFFFF;\n  v1 = v & 0xFFFFFFFF;\n\n  u >>= 32;\n  v >>= 32;\n\n  t  = u1 * v1;\n  w0 = t & 0xFFFFFFFF;\n  t  = u * v1 + (t >> 32);\n  w1 = t >> 32;\n  t  = u1 * v + (t & 0xFFFFFFFF);\n\n  res128_hi = u * v + w1 + (t >> 32);\n  return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n  let offset = (magnitude >> 52) - 1045;\n  let shift  = offset & 63;\n  let tblPtr = PIO2_TABLE + (<i32>(offset >> 6) << 3);\n  let s0: u64, s1: u64, s2: u64;\n\n  let b0 = load<u64>(tblPtr, 0 << 3);\n  let b1 = load<u64>(tblPtr, 1 << 3);\n  let b2 = load<u64>(tblPtr, 2 << 3);\n\n  // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n  if (shift) {\n    let rshift = 64 - shift;\n    let b3 = load<u64>(tblPtr, 3 << 3);\n    s0 = b1 >> rshift | b0 << shift;\n    s1 = b2 >> rshift | b1 << shift;\n    s2 = b3 >> rshift | b2 << shift;\n  } else {\n    s0 = b0;\n    s1 = b1;\n    s2 = b2;\n  }\n\n  let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n  // First 128 bits of fractional part of x/(2π)\n  let blo = umuldi(s1, significand);\n  let bhi = res128_hi;\n\n  let ahi = s0 * significand;\n  let clo = (s2 >> 32) * (significand >> 32);\n  let plo = blo + clo;\n  let phi = ahi + bhi + u64(plo < clo);\n\n  // r: u128 = p << 2\n  let rlo = plo << 2;\n  let rhi = phi << 2 | plo >> 62;\n\n  // s: i128 = r >> 127\n  let slo = <i64>rhi >> 63;\n  let shi = slo >> 1;\n  let q   = (<i64>phi >> 62) - slo;\n\n  let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n  let signbit = (u ^ rhi) & 0x8000000000000000;\n  let coeff   = reinterpret<f64>(shifter | signbit);\n\n  rempio2_y0 *= coeff;\n  rempio2_y1 *= coeff;\n\n  return <i32>q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n  const\n    pio2_1  = reinterpret<f64>(0x3FF921FB54400000), // 1.57079632673412561417e+00\n    pio2_1t = reinterpret<f64>(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n    pio2_2  = reinterpret<f64>(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n    pio2_2t = reinterpret<f64>(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n    pio2_3  = reinterpret<f64>(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n    pio2_3t = reinterpret<f64>(0x397B839A252049C1), // 8.47842766036889956997e-32\n    invpio2 = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  let ix = <u32>(u >> 32) & 0x7FFFFFFF;\n\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n      let q = 1, z: f64, y0: f64, y1: f64;\n      if (!sign) {\n        z = x - pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z - pio2_1t;\n          y1 = (z - y0) - pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z -= pio2_2;\n          y0 = z - pio2_2t;\n          y1 = (z - y0) - pio2_2t;\n        }\n      } else { // negative x\n        z = x + pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z + pio2_1t;\n          y1 = (z - y0) + pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z += pio2_2;\n          y0 = z + pio2_2t;\n          y1 = (z - y0) + pio2_2t;\n        }\n        q = -1;\n      }\n      rempio2_y0 = y0;\n      rempio2_y1 = y1;\n      return q;\n    }\n  }\n\n  if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n    // Use precise Cody Waite scheme\n    let q  = nearest(x * invpio2);\n    let r  = x - q * pio2_1;\n    let w  = q * pio2_1t; // 1st round good to 85 bit\n    let j  = ix >> 20;\n    let y0 = r - w;\n    let hi = <u32>(reinterpret<u64>(y0) >> 32);\n    let i  = j - ((hi >> 20) & 0x7FF);\n\n    if (i > 16) { // 2nd iteration needed, good to 118\n      let t = r;\n      w  = q * pio2_2;\n      r  = t - w;\n      w  = q * pio2_2t - ((t - r) - w);\n      y0 = r - w;\n      hi = <u32>(reinterpret<u64>(y0) >> 32);\n      i = j - ((hi >> 20) & 0x7FF);\n      if (i > 49) { // 3rd iteration need, 151 bits acc\n        let t = r;\n        w  = q * pio2_3;\n        r  = t - w;\n        w  = q * pio2_3t - ((t - r) - w);\n        y0 = r - w;\n      }\n    }\n    let y1 = (r - y0) - w;\n    rempio2_y0 = y0;\n    rempio2_y1 = y1;\n    return <i32>q;\n  }\n  let q = pio2_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555555555549), // -1.66666666666666324348e-01\n    S2 = reinterpret<f64>(0x3F8111111110F8A6), //  8.33333333332248946124e-03\n    S3 = reinterpret<f64>(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n    S4 = reinterpret<f64>(0x3EC71DE357B1FE7D), //  2.75573137070700676789e-06\n    S5 = reinterpret<f64>(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n    S6 = reinterpret<f64>(0x3DE5D93A5ACFD57C); //  1.58969099521155010221e-10\n\n  let z = x * x;\n  let w = z * z;\n  let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n  let v = z * x;\n  if (!iy) {\n    return x + v * (S1 + z * r);\n  } else {\n    return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n  }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n  const\n    C1 = reinterpret<f64>(0x3FA555555555554C), //  4.16666666666666019037e-02\n    C2 = reinterpret<f64>(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n    C3 = reinterpret<f64>(0x3EFA01A019CB1590), //  2.48015872894767294178e-05\n    C4 = reinterpret<f64>(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n    C5 = reinterpret<f64>(0x3E21EE9EBDB4B1C4), //  2.08757232129817482790e-09\n    C6 = reinterpret<f64>(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n  let z = x * x;\n  let w = z * z;\n  let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n  let hz = 0.5 * z;\n  w = 1.0 - hz;\n  return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n  const\n    T0  = reinterpret<f64>(0x3FD5555555555563), //  3.33333333333334091986e-01\n    T1  = reinterpret<f64>(0x3FC111111110FE7A), //  1.33333333333201242699e-01\n    T2  = reinterpret<f64>(0x3FABA1BA1BB341FE), //  5.39682539762260521377e-02\n    T3  = reinterpret<f64>(0x3F9664F48406D637), //  2.18694882948595424599e-02\n    T4  = reinterpret<f64>(0x3F8226E3E96E8493), //  8.86323982359930005737e-03\n    T5  = reinterpret<f64>(0x3F6D6D22C9560328), //  3.59207910759131235356e-03\n    T6  = reinterpret<f64>(0x3F57DBC8FEE08315), //  1.45620945432529025516e-03\n    T7  = reinterpret<f64>(0x3F4344D8F2F26501), //  5.88041240820264096874e-04\n    T8  = reinterpret<f64>(0x3F3026F71A8D1068), //  2.46463134818469906812e-04\n    T9  = reinterpret<f64>(0x3F147E88A03792A6), //  7.81794442939557092300e-05\n    T10 = reinterpret<f64>(0x3F12B80F32F0A7E9), //  7.14072491382608190305e-05\n    T11 = reinterpret<f64>(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n    T12 = reinterpret<f64>(0x3EFB2A7074BF7AD4); //  2.59073051863633712884e-05\n\n  const\n    one    = reinterpret<f64>(0x3FF0000000000000), // 1.00000000000000000000e+00\n    pio4   = reinterpret<f64>(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n    pio4lo = reinterpret<f64>(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n  let z: f64, r: f64, v: f64, w: f64, s: f64;\n  let hx = <i32>(reinterpret<u64>(x) >> 32); // high word of x\n  let ix = hx & 0x7FFFFFFF; // high word of |x|\n  let big = ix >= 0x3FE59428;\n  if (big) { // |x| >= 0.6744\n    if (hx < 0) { x = -x, y = -y; }\n    z = pio4 - x;\n    w = pio4lo - y;\n    x = z + w;\n    y = 0.0;\n  }\n  z = x * x;\n  w = z * z;\n  r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n  v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n  s = z * x;\n  r = y + z * (s * (r + v) + y);\n  r += T0 * s;\n  w = x + r;\n  if (big) {\n    v = iy;\n    return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n  }\n  if (iy == 1) return w;\n  let a: f64, t: f64;\n  z = w;\n  z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF00000000);\n  v = r - (z - x);  // z + v = r + x\n  t = a = -one / w; // a = -1.0 / w\n  t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n  s = one + t * z;\n  return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    const inv32 = 1.0 / 4294967296;\n    return <i32><i64>(x - 4294967296 * floor(x * inv32));\n  } else {\n    let result = 0;\n    let u = reinterpret<u64>(x);\n    let e = (u >> 52) & 0x7FF;\n    if (e <= 1023 + 30) {\n      result = <i32>x;\n    } else if (e <= 1023 + 30 + 53) {\n      let v = (u & ((<u64>1 << 52) - 1)) | (<u64>1 << 52);\n      v = v << e - 1023 - 52 + 32;\n      result = <i32>(v >> 32);\n      result = select<i32>(-result, result, <i64>u < 0);\n    }\n    return result;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n  h ^= h >> 33;                     // see: https://github.com/aappleby/smhasher\n  h *= 0xFF51AFD7ED558CCD;\n  h ^= h >> 33;\n  h *= 0xC4CEB9FE1A85EC53;\n  h ^= h >> 33;\n  return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n  h += 0x6D2B79F5;\n  h  = (h ^ (h >> 15)) * (h | 1);\n  h ^= h + (h ^ (h >> 7)) * (h | 61);\n  return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_sin: f64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_cos: f64 = 0;\n\n  // @ts-ignore: decorator\n  @inline export function abs(x: f64): f64 {\n    return builtin_abs<f64>(x);\n  }\n\n  export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let hx = <u32>(reinterpret<u64>(x) >> 32);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) {\n        if (<i32>hx < 0) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n    }\n    let s: f64, w: f64, z: f64;\n    if (<i32>hx < 0) {\n      // z = (1.0 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f64>(z);\n      w = R(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1.0 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f64>(z);\n    let df = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n    let c = (z - df * df) / (s + df);\n    w = R(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n    const s = reinterpret<f64>(0x3FE62E42FEFA39EF);\n    let u = reinterpret<u64>(x);\n    // Prevent propagation for all input values less than 1.0.\n    // Note musl lib didn't fix this yet.\n    if (<i64>u < 0x3FF0000000000000) return (x - x) / 0.0;\n    let e = u >> 52 & 0x7FF;\n    if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt<f64>((x - 1) * (x - 1) + 2 * (x - 1)));\n    if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt<f64>(x * x - 1)));\n    return log(x) + s;\n  }\n\n  export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let hx = <u32>(reinterpret<u64>(x) >> 32);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n      return x + x * R(x * x);\n    }\n    // let z = (1.0 - builtin_abs<f64>(x)) * 0.5;\n    let z = 0.5 - builtin_abs<f64>(x) * 0.5;\n    let s = builtin_sqrt<f64>(z);\n    let r = R(z);\n    if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n    else {\n      let f = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n      let c = (z - f * f) / (s + f);\n      x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n    }\n    return select(-x, x, <i32>hx < 0);\n  }\n\n  export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n    const c = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n    let u = reinterpret<u64>(x);\n    let e = u >> 52 & 0x7FF;\n    let y = reinterpret<f64>(u & 0x7FFFFFFFFFFFFFFF);\n    if (e >= 0x3FF + 26) y = log(y) + c;\n    else if (e >= 0x3FF + 1)  y =   log(2 * y + 1 / (builtin_sqrt<f64>(y * y + 1) + y));\n    else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt<f64>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f64>(0x3FDDAC670561BB4F), //  4.63647609000806093515e-01\n      atanhi1   = reinterpret<f64>(0x3FE921FB54442D18), //  7.85398163397448278999e-01\n      atanhi2   = reinterpret<f64>(0x3FEF730BD281F69B), //  9.82793723247329054082e-01\n      atanhi3   = reinterpret<f64>(0x3FF921FB54442D18), //  1.57079632679489655800e+00\n      atanlo0   = reinterpret<f64>(0x3C7A2B7F222F65E2), //  2.26987774529616870924e-17\n      atanlo1   = reinterpret<f64>(0x3C81A62633145C07), //  3.06161699786838301793e-17\n      atanlo2   = reinterpret<f64>(0x3C7007887AF0CBBD), //  1.39033110312309984516e-17\n      atanlo3   = reinterpret<f64>(0x3C91A62633145C07), //  6.12323399573676603587e-17\n      aT0       = reinterpret<f64>(0x3FD555555555550D), //  3.33333333333329318027e-01\n      aT1       = reinterpret<f64>(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n      aT2       = reinterpret<f64>(0x3FC24924920083FF), //  1.42857142725034663711e-01\n      aT3       = reinterpret<f64>(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n      aT4       = reinterpret<f64>(0x3FB745CDC54C206E), //  9.09088713343650656196e-02\n      aT5       = reinterpret<f64>(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n      aT6       = reinterpret<f64>(0x3FB10D66A0D03D51), //  6.66107313738753120669e-02\n      aT7       = reinterpret<f64>(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n      aT8       = reinterpret<f64>(0x3FA97B4B24760DEB), //  4.97687799461593236017e-02\n      aT9       = reinterpret<f64>(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n      aT10      = reinterpret<f64>(0x3F90AD3AE322DA11), //  1.62858201153657823623e-02\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let ix = <u32>(reinterpret<u64>(x) >> 32);\n    let sx = x;\n    ix &= 0x7FFFFFFF;\n    let z: f64;\n    if (ix >= 0x44100000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign<f64>(z, sx);\n    }\n    let id: i32;\n    if (ix < 0x3FDC0000) {\n      if (ix < 0x3E400000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f64>(x);\n      if (ix < 0x3FF30000) {\n        if (ix < 0x3FE60000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x40038000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    let w = z * z;\n    let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n    let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n    let s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign<f64>(z, sx);\n  }\n\n  export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n    let u = reinterpret<u64>(x);\n    let e = u >> 52 & 0x7FF;\n    let y = builtin_abs(x);\n    if (e < 0x3FF - 1) {\n      if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n    } else {\n      y = 0.5 * log1p(2 * (y / (1 - y)));\n    }\n    return builtin_copysign<f64>(y, x);\n  }\n\n  export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n    const pi_lo = reinterpret<f64>(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n    if (isNaN(x) || isNaN(y)) return x + y;\n    let u = reinterpret<u64>(x);\n    let ix = <u32>(u >> 32);\n    let lx = <u32>u;\n    u = reinterpret<u64>(y);\n    let iy = <u32>(u >> 32);\n    let ly = <u32>u;\n    if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n    let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n    ix = ix & 0x7FFFFFFF;\n    iy = iy & 0x7FFFFFFF;\n    if ((iy | ly) == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  PI;\n        case 3: return -PI;\n      }\n    }\n    if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n    if (ix == 0x7FF00000) {\n      if (iy == 0x7FF00000) {\n        let t = m & 2 ? 3 * PI / 4 : PI / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t = m & 2 ? PI : 0;\n        return m & 1 ? -t : t;\n      }\n    }\n    let z: f64;\n    if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n    if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n    else z = atan(builtin_abs<f64>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return PI - (z - pi_lo);\n      case 3: return (z - pi_lo) - PI;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n    const\n      B1     = <u32>715094163,\n      B2     = <u32>696219795,\n      P0     = reinterpret<f64>(0x3FFE03E60F61E692), //  1.87595182427177009643\n      P1     = reinterpret<f64>(0xBFFE28E092F02420), // -1.88497979543377169875\n      P2     = reinterpret<f64>(0x3FF9F1604A49D6C2), //  1.621429720105354466140\n      P3     = reinterpret<f64>(0xBFE844CBBEE751D9), // -0.758397934778766047437\n      P4     = reinterpret<f64>(0x3FC2B000D4E4EDD7), //  0.145996192886612446982\n      Ox1p54 = reinterpret<f64>(0x4350000000000000); //  0x1p54\n\n    let u = reinterpret<u64>(x);\n    let hx = <u32>(u >> 32) & 0x7FFFFFFF;\n    if (hx >= 0x7FF00000) return x + x;\n    if (hx < 0x00100000) {\n      u = reinterpret<u64>(x * Ox1p54);\n      hx = <u32>(u >> 32) & 0x7FFFFFFF;\n      if (hx == 0) return x;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 1 << 63;\n    u |= <u64>hx << 32;\n    let t = reinterpret<f64>(u);\n    let r = (t * t) * (t / x);\n    t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n    t = reinterpret<f64>((reinterpret<u64>(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n    let s = t * t;\n    r = x / s;\n    r = (r - t) / (2 * t + r);\n    t = t + t * r;\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f64): f64 {\n    return builtin_ceil<f64>(x);\n  }\n\n  export function clz32(x: f64): f64 {\n    if (!isFinite(x)) return 32;\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    return builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n    let u  = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E46A09E) {  // |x| < 2**-27 * sqrt(2)\n        return 1.0;\n      }\n      return cos_kern(x, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    let n  = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n\n    x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n    return (n + 1) & 2 ? -x : x;\n  }\n\n  export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n    let u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    x = reinterpret<f64>(u);\n    let w = <u32>(u >> 32);\n    let t: f64;\n    if (w < 0x3FE62E42) {\n      if (w < 0x3FF00000 - (26 << 20)) return 1;\n      t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (w < 0x40862E42) {\n      t = exp(x);\n      return 0.5 * (t + 1 / t);\n    }\n    t = expo2(x, 1);\n    return t;\n  }\n\n  export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return exp_lut(x);\n    } else {\n      const\n        ln2hi     = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n        ln2lo     = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n        invln2    = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        P1        = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2        = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3        = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4        = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5        = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        overflow  = reinterpret<f64>(0x40862E42FEFA39EF), //  709.782712893383973096\n        underflow = reinterpret<f64>(0xC0874910D52D3051), // -745.13321910194110842\n        Ox1p1023  = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n      let hx = u32(reinterpret<u64>(x) >> 32);\n      let sign = hx >> 31;\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x4086232B) {\n        if (isNaN(x)) return x;\n        if (x > overflow)  return x * Ox1p1023;\n        if (x < underflow) return 0;\n      }\n      let hi: f64, lo: f64 = 0;\n      let k = 0;\n      if (hx > 0x3FD62E42) {\n        if (hx >= 0x3FF0A2B2) {\n          k = i32(invln2 * x + builtin_copysign<f64>(0.5, x));\n        } else {\n          k = 1 - (sign << 1);\n        }\n        hi = x - k * ln2hi;\n        lo = k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x3E300000) {\n        hi = x;\n      } else return 1.0 + x;\n      let xs = x * x;\n      // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n      let xq = xs * xs;\n      let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n      let y = 1.0 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f64): f64 {\n    return exp2_lut(x);\n  }\n\n  export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n    const\n      o_threshold = reinterpret<f64>(0x40862E42FEFA39EF), //  7.09782712893383973096e+02\n      ln2_hi      = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n      ln2_lo      = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n      invln2      = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n      Q1          = reinterpret<f64>(0xBFA11111111110F4), // -3.33333333333331316428e-02\n      Q2          = reinterpret<f64>(0x3F5A01A019FE5585), //  1.58730158725481460165e-03\n      Q3          = reinterpret<f64>(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n      Q4          = reinterpret<f64>(0x3ED0CFCA86E65239), //  4.00821782732936239552e-06\n      Q5          = reinterpret<f64>(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n      Ox1p1023    = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32) & 0x7FFFFFFF;\n    let sign = u32(u >> 63);\n    let k = 0;\n    if (hx >= 0x4043687A) {\n      if (isNaN(x)) return x;\n      if (sign) return -1;\n      if (x > o_threshold) return x * Ox1p1023;\n    }\n    let c = 0.0, t: f64;\n    if (hx > 0x3FD62E42) {\n      k = select<i32>(\n        1 - (sign << 1),\n        i32(invln2 * x + builtin_copysign<f64>(0.5, x)),\n        hx < 0x3FF0A2B2\n      );\n      t = <f64>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x3C900000) return x;\n    let hfx = 0.5 * x;\n    let hxs = x * hfx;\n    // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n    let hxq = hxs * hxs;\n    let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n    t = 3.0 - r1 * hfx;\n    let e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x3FF + k) << 52;\n    let twopk = reinterpret<f64>(u);\n    let y: f64;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 1024) y = y * 2.0 * Ox1p1023;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x3FF - k) << 52;\n    y = reinterpret<f64>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f64): f64 {\n    return builtin_floor<f64>(x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f64): f64 {\n    return <f32>x;\n  }\n\n  export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n    const\n      SPLIT    = reinterpret<f64>(0x41A0000000000000) + 1, // 0x1p27 + 1\n      Ox1p700  = reinterpret<f64>(0x6BB0000000000000),\n      Ox1p_700 = reinterpret<f64>(0x1430000000000000);\n\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    ux &= 0x7FFFFFFFFFFFFFFF;\n    uy &= 0x7FFFFFFFFFFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    let ex = i32(ux >> 52);\n    let ey = i32(uy >> 52);\n    y = reinterpret<f64>(uy);\n    if (ey == 0x7FF) return y;\n    x = reinterpret<f64>(ux);\n    if (ex == 0x7FF || uy == 0) return x;\n    if (ex - ey > 64) return x + y;\n    let z = 1.0;\n    if (ex > 0x3FF + 510) {\n      z  = Ox1p700;\n      x *= Ox1p_700;\n      y *= Ox1p_700;\n    } else if (ey < 0x3FF - 450) {\n      z  = Ox1p_700;\n      x *= Ox1p700;\n      y *= Ox1p700;\n    }\n    let c = x * SPLIT;\n    let h = x - c + c;\n    let l = x - h;\n    let hx = x * x;\n    let lx = h * h - hx + (2 * h + l) * l;\n    c = y * SPLIT;\n    h = y - c + c;\n    l = y - h;\n    let hy = y * y;\n    let ly = h * h - hy + (2 * h + l) * l;\n    return z * builtin_sqrt(ly + lx + hy + hx);\n  }\n\n  export function imul(x: f64, y: f64): f64 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return dtoi32(x) * dtoi32(y);\n  }\n\n  export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log_lut(x);\n    } else {\n      const\n        ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n        ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n        Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54 = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = u32(u >> 32);\n      let k = 0;\n      let sign = hx >> 31;\n      if (sign || hx < 0x00100000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = u32(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += (<i32>hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let dk = <f64>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f64>(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n      ivln10lo  = reinterpret<f64>(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n      log10_2hi = reinterpret<f64>(0x3FD34413509F6000), // 3.01029995663611771306e-01\n      log10_2lo = reinterpret<f64>(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n      Lg1       = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2       = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3       = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4       = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5       = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6       = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7       = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n      Ox1p54    = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32);\n    let k = 0;\n    let sign = hx >> 31;\n    if (sign || hx < 0x00100000) {\n      if (u << 1 == 0) return -1 / (x * x);\n      if (sign) return (x - x) / 0.0;\n      k -= 54;\n      x *= Ox1p54;\n      u = reinterpret<u64>(x);\n      hx = u32(u >> 32);\n    } else if (hx >= 0x7FF00000) {\n      return x;\n    } else if (hx == 0x3FF00000 && u << 32 == 0) {\n      return 0;\n    }\n    hx += 0x3FF00000 - 0x3FE6A09E;\n    k += i32(hx >> 20) - 0x3FF;\n    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n    u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n    x = reinterpret<f64>(u);\n    let f = x - 1.0;\n    let hfsq = 0.5 * f * f;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    let r = t2 + t1;\n    let hi = f - hfsq;\n    u = reinterpret<u64>(hi);\n    u &= 0xFFFFFFFF00000000;\n    hi = reinterpret<f64>(u);\n    let lo = f - hi - hfsq + s * (hfsq + r);\n    let val_hi = hi * ivln10hi;\n    let dk = <f64>k;\n    let y = dk * log10_2hi;\n    let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    return val_lo + w;\n  }\n\n  export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n      ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n      Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32);\n    let k = 1;\n    let c = 0.0, f = 0.0;\n    if (hx < 0x3FDA827A || bool(hx >> 31)) {\n      if (hx >= 0xBFF00000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (hx << 1 < 0x3CA00000 << 1) return x;\n      if (hx <= 0xBFD2BEC4) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (hx >= 0x7FF00000) return x;\n    if (k) {\n      u = reinterpret<u64>(1 + x);\n      let hu = u32(u >> 32);\n      hu += 0x3FF00000 - 0x3FE6A09E;\n      k = i32(hu >> 20) - 0x3FF;\n      if (k < 54) {\n        let uf = reinterpret<f64>(u);\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hu << 32 | (u & 0xFFFFFFFF);\n      f = reinterpret<f64>(u) - 1;\n    }\n    let hfsq = 0.5 * f * f;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    let r = t2 + t1;\n    let dk = <f64>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f64>(0x3FF7154765200000), // 1.44269504072144627571e+00\n        ivln2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n        Lg1     = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2     = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3     = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4     = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5     = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6     = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7     = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54  = reinterpret<f64>(0x4350000000000000); // 1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = u32(u >> 32);\n      let k = 0;\n      let sign = hx >> 31;\n      if (sign || hx < 0x00100000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = u32(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += i32(hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let hi = f - hfsq;\n      u = reinterpret<u64>(hi);\n      u &= 0xFFFFFFFF00000000;\n      hi = reinterpret<f64>(u);\n      let lo = f - hi - hfsq + s * (hfsq + r);\n      let val_hi = hi * ivln2hi;\n      let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n      let y = <f64>k;\n      w = y + val_hi;\n      val_lo += (y - w) + val_hi;\n      val_hi = w;\n      return val_lo + val_hi;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f64, value2: f64): f64 {\n    return builtin_max<f64>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f64, value2: f64): f64 {\n    return builtin_min<f64>(value1, value2);\n  }\n\n  export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f64>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f64>(\n          builtin_abs<f64>(builtin_sqrt<f64>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      return pow_lut(x, y);\n    } else {\n      const\n        dp_h1   = reinterpret<f64>(0x3FE2B80340000000), //  5.84962487220764160156e-01\n        dp_l1   = reinterpret<f64>(0x3E4CFDEB43CFD006), //  1.35003920212974897128e-08\n        two53   = reinterpret<f64>(0x4340000000000000), //  9007199254740992.0\n        huge    = reinterpret<f64>(0x7E37E43C8800759C), //  1e+300\n        tiny    = reinterpret<f64>(0x01A56E1FC2F8F359), //  1e-300\n        L1      = reinterpret<f64>(0x3FE3333333333303), //  5.99999999999994648725e-01\n        L2      = reinterpret<f64>(0x3FDB6DB6DB6FABFF), //  4.28571428578550184252e-01\n        L3      = reinterpret<f64>(0x3FD55555518F264D), //  3.33333329818377432918e-01\n        L4      = reinterpret<f64>(0x3FD17460A91D4101), //  2.72728123808534006489e-01\n        L5      = reinterpret<f64>(0x3FCD864A93C9DB65), //  2.30660745775561754067e-01\n        L6      = reinterpret<f64>(0x3FCA7E284A454EEF), //  2.06975017800338417784e-01\n        P1      = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2      = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3      = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4      = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5      = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        lg2     = reinterpret<f64>(0x3FE62E42FEFA39EF), //  6.93147180559945286227e-01\n        lg2_h   = reinterpret<f64>(0x3FE62E4300000000), //  6.93147182464599609375e-01\n        lg2_l   = reinterpret<f64>(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n        ovt     = reinterpret<f64>(0x3C971547652B82FE), //  8.0085662595372944372e-017\n        cp      = reinterpret<f64>(0x3FEEC709DC3A03FD), //  9.61796693925975554329e-01\n        cp_h    = reinterpret<f64>(0x3FEEC709E0000000), //  9.61796700954437255859e-01\n        cp_l    = reinterpret<f64>(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n        ivln2   = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        ivln2_h = reinterpret<f64>(0x3FF7154760000000), //  1.44269502162933349609e+00\n        ivln2_l = reinterpret<f64>(0x3E54AE0BF85DDF44), //  1.92596299112661746887e-08\n        inv3    = reinterpret<f64>(0x3FD5555555555555); //  0.3333333333333333333333\n\n      let u_ = reinterpret<u64>(x);\n      let hx = i32(u_ >> 32);\n      let lx = <u32>u_;\n      u_ = reinterpret<u64>(y);\n      let hy = i32(u_ >> 32);\n      let ly = <u32>u_;\n      let ix = hx & 0x7FFFFFFF;\n      let iy = hy & 0x7FFFFFFF;\n      if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n      // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n      if ( // NaN if either arg is NaN\n        ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n        iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n      ) return x + y;\n      let yisint = 0, k: i32;\n      if (hx < 0) {\n        if (iy >= 0x43400000) yisint = 2;\n        else if (iy >= 0x3FF00000) {\n          k = (iy >> 20) - 0x3FF;\n          let offset = select<u32>(52, 20, k > 20) - k;\n          let Ly = select<u32>(ly, iy, k > 20);\n          let jj = Ly >> offset;\n          if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n        }\n      }\n      if (ly == 0) {\n        if (iy == 0x7FF00000) { // y is +-inf\n          if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n          else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n          else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n        }\n        if (iy == 0x3FF00000) {\n          if (hy >= 0) return x;\n          return 1 / x;\n        }\n        if (hy == 0x40000000) return x * x;\n        if (hy == 0x3FE00000) {\n          if (hx >= 0) return builtin_sqrt(x);\n        }\n      }\n      let ax = builtin_abs<f64>(x), z: f64;\n      if (lx == 0) {\n        if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n          z = ax;\n          if (hy < 0) z = 1.0 / z;\n          if (hx < 0) {\n            if (((ix - 0x3FF00000) | yisint) == 0) {\n              let d = z - z;\n              z = d / d;\n            } else if (yisint == 1) z = -z;\n          }\n          return z;\n        }\n      }\n      let s = 1.0;\n      if (hx < 0) {\n        if (yisint == 0) {\n          let d = x - x;\n          return d / d;\n        }\n        if (yisint == 1) s = -1.0;\n      }\n      let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n      let j: i32, n: i32;\n      if (iy > 0x41E00000) {\n        if (iy > 0x43F00000) {\n          if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n          if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n        }\n        if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n        if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n        t = ax - 1.0;\n        w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n        u = ivln2_h * t;\n        v = t * ivln2_l - w * ivln2;\n        t1 = u + v;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = v - (t1 - u);\n      } else {\n        let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n        n = 0;\n        if (ix < 0x00100000) {\n          ax *= two53;\n          n -= 53;\n          ix = <u32>(reinterpret<u64>(ax) >> 32);\n        }\n        n += (ix >> 20) - 0x3FF;\n        j = ix & 0x000FFFFF;\n        ix = j | 0x3FF00000;\n        if (j <= 0x3988E) k = 0;\n        else if (j < 0xBB67A) k = 1;\n        else {\n          k = 0;\n          n += 1;\n          ix -= 0x00100000;\n        }\n        ax = reinterpret<f64>(reinterpret<u64>(ax) & 0xFFFFFFFF | (<u64>ix << 32));\n        let bp = select<f64>(1.5, 1.0, k); // k ? 1.5 : 1.0\n        u = ax - bp;\n        v = 1.0 / (ax + bp);\n        ss = u * v;\n        s_h = ss;\n        s_h = reinterpret<f64>(reinterpret<u64>(s_h) & 0xFFFFFFFF00000000);\n        t_h = reinterpret<f64>(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n        t_l = ax - (t_h - bp);\n        s_l = v * ((u - s_h * t_h) - s_h * t_l);\n        s2 = ss * ss;\n        r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + ss);\n        s2 = s_h * s_h;\n        t_h = 3.0 + s2 + r;\n        t_h = reinterpret<f64>(reinterpret<u64>(t_h) & 0xFFFFFFFF00000000);\n        t_l = r - ((t_h - 3.0) - s2);\n        u = s_h * t_h;\n        v = s_l * t_h + t_l * ss;\n        p_h = u + v;\n        p_h = reinterpret<f64>(reinterpret<u64>(p_h) & 0xFFFFFFFF00000000);\n        p_l = v - (p_h - u);\n        let z_h = cp_h * p_h;\n        let dp_l = select<f64>(dp_l1, 0.0, k);\n        let z_l = cp_l * p_h + p_l * cp + dp_l;\n        t = <f64>n;\n        let dp_h = select<f64>(dp_h1, 0.0, k);\n        t1 = ((z_h + z_l) + dp_h) + t;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = z_l - (((t1 - t) - dp_h) - z_h);\n      }\n      let y1 = y;\n      y1 = reinterpret<f64>(reinterpret<u64>(y1) & 0xFFFFFFFF00000000);\n      p_l = (y - y1) * t1 + y * t2;\n      p_h = y1 * t1;\n      z = p_l + p_h;\n      u_ = reinterpret<u64>(z);\n      j = u32(u_ >> 32);\n      let i = <i32>u_;\n      if (j >= 0x40900000) {\n        if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n        if (p_l + ovt > z - p_h) return s * huge * huge;\n      } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n        if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n        if (p_l <= z - p_h) return s * tiny * tiny;\n      }\n      i = j & 0x7FFFFFFF;\n      k = (i >> 20) - 0x3FF;\n      n = 0;\n      if (i > 0x3FE00000) {\n        n = j + (0x00100000 >> (k + 1));\n        k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n        t = 0.0;\n        t = reinterpret<f64>(u64(n & ~(0x000FFFFF >> k)) << 32);\n        n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n        if (j < 0) n = -n;\n        p_h -= t;\n      }\n      t = p_l + p_h;\n      t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n      u = t * lg2_h;\n      v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n      z = u + v;\n      w = v - (z - u);\n      t = z * z;\n      t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n      r = (z * t1) / (t1 - 2.0) - (w + z * w);\n      z = 1.0 - (r - z);\n      j = u32(reinterpret<u64>(z) >> 32);\n      j += n << 20;\n      if ((j >> 20) <= 0) z = scalbn(z, n);\n      else z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF | (<u64>j << 32));\n      return s * z;\n    }\n  }\n\n  export function seedRandom(value: i64): void {\n    // Instead zero seed use golden ratio:\n    // phi = (1 + sqrt(5)) / 2\n    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n    if (value == 0) value = 0x9e3779b97f4a7c15;\n    random_state0_64 = murmurHash3(value);\n    random_state1_64 = murmurHash3(~random_state0_64);\n    random_state0_32 = splitMix32(<u32>value);\n    random_state1_32 = splitMix32(random_state0_32);\n    random_seeded = true;\n  }\n\n  export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n    let s1 = random_state0_64;\n    let s0 = random_state1_64;\n    random_state0_64 = s0;\n    s1 ^= s1 << 23;\n    s1 ^= s1 >> 17;\n    s1 ^= s0;\n    s1 ^= s0 >> 26;\n    random_state1_64 = s1;\n    let r = (s0 >> 12) | 0x3FF0000000000000;\n    return reinterpret<f64>(r) - 1;\n  }\n\n  export function round(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_ceil<f64>(x) - f64(builtin_ceil<f64>(x) - 0.5 > x);\n    } else {\n      let roundUp = builtin_ceil<f64>(x);\n      return select<f64>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n    }\n  }\n\n  export function sign(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return select<f64>(builtin_copysign<f64>(1, x), x, builtin_abs(x) > 0);\n    } else {\n      return select<f64>(1, select<f64>(-1, x, x < 0), x > 0);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f64): bool {\n    return bool(reinterpret<u64>(x) >>> 63);\n  }\n\n  export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n    let u  = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E500000) { // |x| < 2**-26\n        return x;\n      }\n      return sin_kern(x, 0.0, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    let n  = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n\n    x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n    return n & 2 ? -x : x;\n  }\n\n  export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n    let u = reinterpret<u64>(x) & 0x7FFFFFFFFFFFFFFF;\n    let a = reinterpret<f64>(u);\n    let w = u32(u >> 32);\n    let h = builtin_copysign(0.5, x);\n    if (w < 0x40862E42) {\n      let t = expm1(a);\n      if (w < 0x3FF00000) {\n        if (w < 0x3FF00000 - (26 << 20)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f64): f64 {\n    return builtin_sqrt<f64>(x);\n  }\n\n  export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n    let u = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >>> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E400000) { // |x| < 2**-27\n        return x;\n      }\n      return tan_kern(x, 0.0, 1);\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    let n = rempio2(x, u, sign);\n    return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n  }\n\n  export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n    let u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    let y = reinterpret<f64>(u);\n    let w = u32(u >> 32);\n    let t: f64;\n    if (w > 0x3FE193EA) {\n      if (w > 0x40340000) {\n        t = 1 - 0 / y;\n      } else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (w > 0x3FD058AE) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (w >= 0x00100000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f64>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f64): f64 {\n    return builtin_trunc<f64>(x);\n  }\n\n  export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n    const\n      Ox1p53    = reinterpret<f64>(0x4340000000000000),\n      Ox1p1023  = reinterpret<f64>(0x7FE0000000000000),\n      Ox1p_1022 = reinterpret<f64>(0x0010000000000000);\n\n    let y = x;\n    if (n > 1023) {\n      y *= Ox1p1023;\n      n -= 1023;\n      if (n > 1023) {\n        y *= Ox1p1023;\n        n = builtin_min<i32>(n - 1023, 1023);\n      }\n    } else if (n < -1022) {\n      // make sure final n < -53 to avoid double\n      // rounding in the subnormal range\n      y *= Ox1p_1022 * Ox1p53;\n      n += 1022 - 53;\n      if (n < -1022) {\n        y *= Ox1p_1022 * Ox1p53;\n        n = builtin_max<i32>(n + 1022 - 53, -1022);\n      }\n    }\n    return y * reinterpret<f64>(<u64>(0x3FF + n) << 52);\n  }\n\n  export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n    if (builtin_abs<f64>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f64>(x - builtin_trunc<f64>(x), x);\n    }\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    let ex = i64(ux >> 52 & 0x7FF);\n    let ey = i64(uy >> 52 & 0x7FF);\n    let sx = ux >> 63;\n    let uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0x7FF || isNaN<f64>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    let ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f64(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<i64>(ux << 12);\n      ux <<= 1 - ex;\n    } else {\n      ux &= u64(-1) >> 12;\n      ux |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u64(-1) >> 12;\n      uy |= 1 << 52;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 52); ux <<= 1) --ex;\n    let shift = builtin_clz<i64>(ux << 11);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 52;\n      ux |= ex << 52;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f64>(ux | (sx << 63));\n  }\n\n  export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    let ex = i64(ux >> 52 & 0x7FF);\n    let ey = i64(uy >> 52 & 0x7FF);\n    if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    if (ux << 1 == 0) return x;\n    let uxi = ux;\n    if (!ex) {\n      ex -= builtin_clz<i64>(uxi << 12);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= u64(-1) >> 12;\n      uxi |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u64(-1) >> 12;\n      uy |= 1 << 52;\n    }\n    let q: u32 = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -60;\n      else {\n        let shift = builtin_clz<i64>(uxi << 11);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 52;\n      uxi |= ex << 52;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f64>(uxi);\n    y = builtin_abs<f64>(y);\n    let x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // ++q;\n    }\n    return <i64>ux < 0 ? -x : x;\n  }\n\n  export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n    let u = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3FE921FB) {  // |x| ~<= π/4\n      if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kern(x, 0, 0);\n      sincos_cos = cos_kern(x, 0);\n      return;\n    }\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    let n = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n    let s = sin_kern(y0, y1, 1);\n    let c = cos_kern(y0, y1);\n    let sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data<u64>([\n  0xA2F9836E4E441529,\n  0xFC2757D1F534DDC0,\n  0xDB6295993C439041,\n  0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n  const                    // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f32>(0x3E2AAA75), //  1.6666586697e-01f\n    pS1 = reinterpret<f32>(0xBD2F13BA), // -4.2743422091e-02f\n    pS2 = reinterpret<f32>(0xBC0DD36B), // -8.6563630030e-03f\n    qS1 = reinterpret<f32>(0xBF34E5AE); // -7.0662963390e-01f\n\n  let p = z * (pS0 + z * (pS1 + z * pS2));\n  let q: f32 = 1 + z * qS1;\n  return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                                // see: musl/src/math/__expo2f.c\n    k    = <u32>235,\n    kln2 = reinterpret<f32>(0x4322E3BC); // 0x1.45c778p+7f\n  let scale = reinterpret<f32>(u32(0x7F + (k >> 1)) << 23);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n  let offset = (u >> 23) - 152;\n  let shift  = u64(offset & 63);\n  let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n  let b0 = load<u64>(tblPtr, 0 << 3);\n  let b1 = load<u64>(tblPtr, 1 << 3);\n  let lo: u64;\n\n  if (shift > 32) {\n    let b2 = load<u64>(tblPtr, 2 << 3);\n    lo  = b2 >> (96 - shift);\n    lo |= b1 << (shift - 32);\n  } else {\n    lo = b1 >> (32 - shift);\n  }\n\n  let hi = (b1 >> (64 - shift)) | (b0 << shift);\n  let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n  let product = mantissa * hi + (mantissa * lo >> 32);\n  let r: i64 = product << 2;\n  let q = i32((product >> 62) + (r >>> 63));\n  rempio2f_y = copysign<f64>(coeff, x) * <f64>r;\n  return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const\n    pi2hi = reinterpret<f64>(0x3FF921FB50000000), // 1.57079631090164184570\n    pi2lo = reinterpret<f64>(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n    _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  if (u < 0x4DC90FDB) { // π * 0x1p28\n    let q = nearest(x * _2_pi);\n    rempio2f_y = x - q * pi2hi - q * pi2lo;\n    return <i32>q;\n  }\n\n  let q = pio2f_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n    S2 = reinterpret<f64>(0x3F811110896EFBB2), //  0x111110896efbb2.0p-59\n    S3 = reinterpret<f64>(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n    S4 = reinterpret<f64>(0x3EC6CD878C3B46A7); //  0x16cd878c3b46a7.0p-71\n\n  let z = x * x;\n  let w = z * z;\n  let r = S3 + z * S4;\n  let s = z * x;\n  return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n  const\n    C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n    C1 = reinterpret<f64>(0x3FA55553E1053A42), //  0x155553e1053a42.0p-57\n    C2 = reinterpret<f64>(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n    C3 = reinterpret<f64>(0x3EF99342E0EE5069); //  0x199342e0ee5069.0p-68\n\n  let z = x * x;\n  let w = z * z;\n  let r = C2 + z * C3;\n  return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n  const\n    T0 = reinterpret<f64>(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n    T1 = reinterpret<f64>(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n    T2 = reinterpret<f64>(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n    T3 = reinterpret<f64>(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n    T4 = reinterpret<f64>(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n    T5 = reinterpret<f64>(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n  let z = x * x;\n  let r = T4 + z * T5;\n  let t = T2 + z * T3;\n  let w = z * z;\n  let s = z * x;\n  let u = T0 + z * T1;\n\n  r = (x + s * u) + (s * w) * (t + w * r);\n  return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n  const\n    log2e = reinterpret<f64>(0x3FF71547652B82FE), // 1.44269504088896340736\n    c0 = reinterpret<f64>(0x3FD555554FD9CAEF),    // 0.33333332822728226129\n    c1 = reinterpret<f64>(0x3FC999A7A8AF4132),    // 0.20000167595436263505\n    c2 = reinterpret<f64>(0x3FC2438D79437030),    // 0.14268654271188685375\n    c3 = reinterpret<f64>(0x3FBE2F663B001C97);    // 0.11791075649681414150\n\n  let i = reinterpret<i64>(x);\n  let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n  x = reinterpret<f64>(i - (exponent << 52));\n  x = (x - 1) / (x + 1);\n  let xx = x * x;\n  let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n  return (2 * log2e) * y + <f64>exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n  const\n    c0 = reinterpret<f64>(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n    c1 = reinterpret<f64>(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n    c2 = reinterpret<f64>(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n    c3 = reinterpret<f64>(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n    c4 = reinterpret<f64>(0x3F55F0896145A89F), // 1.339086685300950937e-3\n    c5 = reinterpret<f64>(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n  if (x < -1022) return 0;\n  if (x >= 1024) return Infinity;\n\n  let n = nearest(x);\n  x -= n;\n  let xx = x * x;\n  let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n  return reinterpret<f64>(reinterpret<i64>(y) + (<i64>n << 52));\n}\n\nexport namespace NativeMathf {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = <f32>NativeMath.E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = <f32>NativeMath.LN2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = <f32>NativeMath.LN10;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = <f32>NativeMath.LOG2E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = <f32>NativeMath.LOG10E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = <f32>NativeMath.PI;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = <f32>NativeMath.SQRT1_2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = <f32>NativeMath.SQRT2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_sin: f32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_cos: f32 = 0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function abs(x: f32): f32 {\n    return builtin_abs<f32>(x);\n  }\n\n  export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f32>(0x3FC90FDA), // 1.5707962513e+00f\n      pio2_lo   = reinterpret<f32>(0x33A22168), // 7.5497894159e-08f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    let hx = reinterpret<u32>(x);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3F800000) {\n      if (ix == 0x3F800000) {\n        return select<f32>(2 * pio2_hi + Ox1p_120f, 0, <i32>hx < 0);\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3F000000) {\n      if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n    }\n    let z: f32, w: f32, s: f32;\n    if (<i32>hx < 0) {\n      // z = (1 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f32>(z);\n      w = Rf(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f32>(z);\n    hx = reinterpret<u32>(s);\n    let df = reinterpret<f32>(hx & 0xFFFFF000);\n    let c = (z - df * df) / (s + df);\n    w = Rf(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n    const s = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    let u = reinterpret<u32>(x);\n    let a = u & 0x7FFFFFFF;\n    if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n      let xm1 = x - 1;\n      return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n    }\n    if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n      return log(2 * x - 1 / (x + builtin_sqrt<f32>(x * x - 1)));\n    }\n    // x >= 0x1p12 or x <= -2 or NaN\n    return log(x) + s;\n  }\n\n  export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2      = reinterpret<f32>(0x3FC90FDB), // 1.570796326794896558e+00f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    let sx = x;\n    let hx = reinterpret<u32>(x) & 0x7FFFFFFF;\n    if (hx >= 0x3F800000) {\n      if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (hx < 0x3F000000) {\n      if (hx < 0x39800000 && hx >= 0x00800000) return x;\n      return x + x * Rf(x * x);\n    }\n    // let z: f32 = (1 - builtin_abs<f32>(x)) * 0.5;\n    let z: f32 = 0.5 - builtin_abs<f32>(x) * 0.5;\n    let s = builtin_sqrt<f64>(z); // sic\n    x = f32(pio2 - 2 * (s + s * Rf(z)));\n    return builtin_copysign(x, sx);\n  }\n\n  export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n    const c = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    let u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    let y = reinterpret<f32>(u);\n    if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n    else if (u >= 0x3F800000 + (1 << 23))  y =   log(2 * y + 1 / (builtin_sqrt<f32>(y * y + 1) + y));\n    else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt<f32>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f32>(0x3EED6338), //  4.6364760399e-01f\n      atanhi1   = reinterpret<f32>(0x3F490FDA), //  7.8539812565e-01f\n      atanhi2   = reinterpret<f32>(0x3F7B985E), //  9.8279368877e-01f\n      atanhi3   = reinterpret<f32>(0x3FC90FDA), //  1.5707962513e+00f\n      atanlo0   = reinterpret<f32>(0x31AC3769), //  5.0121582440e-09f\n      atanlo1   = reinterpret<f32>(0x33222168), //  3.7748947079e-08f\n      atanlo2   = reinterpret<f32>(0x33140FB4), //  3.4473217170e-08f\n      atanlo3   = reinterpret<f32>(0x33A22168), //  7.5497894159e-08f\n      aT0       = reinterpret<f32>(0x3EAAAAA9), //  3.3333328366e-01f\n      aT1       = reinterpret<f32>(0xBE4CCA98), // -1.9999158382e-01f\n      aT2       = reinterpret<f32>(0x3E11F50D), //  1.4253635705e-01f\n      aT3       = reinterpret<f32>(0xBDDA1247), // -1.0648017377e-01f\n      aT4       = reinterpret<f32>(0x3D7CAC25), //  6.1687607318e-02f\n      Ox1p_120f = reinterpret<f32>(0x03800000); //  0x1p-120f\n\n    let ix = reinterpret<u32>(x);\n    let sx = x;\n    ix &= 0x7FFFFFFF;\n    let z: f32;\n    if (ix >= 0x4C800000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign(z, sx);\n    }\n    let id: i32;\n    if (ix < 0x3EE00000) {\n      if (ix < 0x39800000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f32>(x);\n      if (ix < 0x3F980000) {\n        if (ix < 0x3F300000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x401C0000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    let w = z * z;\n    let s1 = z * (aT0 + w * (aT2 + w * aT4));\n    let s2 = w * (aT1 + w * aT3);\n    let s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign(z, sx);\n  }\n\n  export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n    let u = reinterpret<u32>(x);\n    let y = builtin_abs(x);\n    if (u < 0x3F800000 - (1 << 23)) {\n      if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n    } else y = 0.5 * log1p(2 * (y / (1 - y)));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n    const\n      pi    = reinterpret<f32>(0x40490FDB), //  3.1415927410e+00f\n      pi_lo = reinterpret<f32>(0xB3BBBD2E); // -8.7422776573e-08f\n\n    if (isNaN(x) || isNaN(y)) return x + y;\n    let ix = reinterpret<u32>(x);\n    let iy = reinterpret<u32>(y);\n    if (ix == 0x3F800000) return atan(y);\n    let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n    ix &= 0x7FFFFFFF;\n    iy &= 0x7FFFFFFF;\n    if (iy == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  pi;\n        case 3: return -pi;\n      }\n    }\n    if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n    if (ix == 0x7F800000) {\n      if (iy == 0x7F800000) {\n        let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t: f32 = m & 2 ? pi : 0.0;\n        return m & 1 ? -t : t;\n      }\n    }\n    if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n    let z: f32;\n    if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n    else z = atan(builtin_abs<f32>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return pi - (z - pi_lo);\n      case 3: return (z - pi_lo) - pi;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n    const\n      B1      = <u32>709958130,\n      B2      = <u32>642849266,\n      Ox1p24f = reinterpret<f32>(0x4B800000);\n\n    let u = reinterpret<u32>(x);\n    let hx = u & 0x7FFFFFFF;\n    if (hx >= 0x7F800000) return x + x;\n    if (hx < 0x00800000) {\n      if (hx == 0) return x;\n      u = reinterpret<u32>(x * Ox1p24f);\n      hx = u & 0x7FFFFFFF;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 0x80000000;\n    u |= hx;\n    let t = <f64>reinterpret<f32>(u);\n    let r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    return <f32>t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f32): f32 {\n    return builtin_ceil<f32>(x);\n  }\n\n  export function clz32(x: f32): f32 {\n    if (!isFinite(x)) return 32;\n    return <f32>builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n    const\n      c1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      c2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      c3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      c4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        // raise inexact if x != 0\n        return 1;\n      }\n      return cos_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {  // |x| ~<= 5π/4\n        if (ux > 0x4016CBE3) { // |x|  ~> 3π/4\n          return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n        } else {\n          return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n        }\n      }\n      if (ux <= 0x40E231D5) {  // |x| ~<= 9π/4\n        if (ux > 0x40AFEDDF) { // |x|  ~> 7π/4\n          return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n        } else {\n          return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n        }\n      }\n    }\n\n    // cos(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    // general argument reduction needed\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n\n    let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n    return (n + 1) & 2 ? -t : t;\n  }\n\n  export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n    let u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    x = reinterpret<f32>(u);\n    if (u < 0x3F317217) {\n      if (u < 0x3F800000 - (12 << 23)) return 1;\n      let t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (u < 0x42B17217) {\n      let t = exp(x);\n      // return 0.5 * (t + 1 / t);\n      return 0.5 * t + 0.5 / t;\n    }\n    return expo2f(x, 1);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f32): f32 {\n    return builtin_floor<f32>(x);\n  }\n\n  export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return expf_lut(x);\n    } else {\n      const\n        ln2hi    = reinterpret<f32>(0x3F317200), //  6.9314575195e-1f\n        ln2lo    = reinterpret<f32>(0x35BFBE8E), //  1.4286067653e-6f\n        invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+0f\n        P1       = reinterpret<f32>(0x3E2AAA8F), //  1.6666625440e-1f\n        P2       = reinterpret<f32>(0xBB355215), // -2.7667332906e-3f\n        Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n      let hx = reinterpret<u32>(x);\n      let sign = hx >> 31;\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x42AEAC50) {\n        if (hx > 0x7F800000) return x; // NaN\n        if (hx >= 0x42B17218) {\n          if (!sign) return x * Ox1p127f;\n          else if (hx >= 0x42CFF1B5) return 0;\n        }\n      }\n      let hi: f32, lo: f32;\n      let k: i32;\n      if (hx > 0x3EB17218) {\n        if (hx > 0x3F851592) {\n          k = i32(invln2 * x + builtin_copysign<f32>(0.5, x));\n        } else {\n          k = 1 - (sign << 1);\n        }\n        hi = x - <f32>k * ln2hi;\n        lo = <f32>k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x39000000) {\n        k = 0;\n        hi = x;\n        lo = 0;\n      } else {\n        return 1 + x;\n      }\n      let xx = x * x;\n      let c = x - xx * (P1 + xx * P2);\n      let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f32): f32 {\n    return exp2f_lut(x);\n  }\n\n  export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi   = reinterpret<f32>(0x3F317180), //  6.9313812256e-01f\n      ln2_lo   = reinterpret<f32>(0x3717F7D1), //  9.0580006145e-06f\n      invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+00f\n      Q1       = reinterpret<f32>(0xBD088868), // -3.3333212137e-02f\n      Q2       = reinterpret<f32>(0x3ACF3010), //  1.5807170421e-03f\n      Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n    let u = reinterpret<u32>(x);\n    let hx = u & 0x7FFFFFFF;\n    let sign = u >> 31;\n    if (hx >= 0x4195B844) {\n      if (hx > 0x7F800000) return x;\n      if (sign) return -1;\n      if (hx > 0x42B17217) { // x > log(FLT_MAX)\n        x *= Ox1p127f;\n        return x;\n      }\n    }\n    let c: f32 = 0.0, t: f32, k: i32;\n    if (hx > 0x3EB17218) {\n      k = select<i32>(\n        1 - (sign << 1),\n        i32(invln2 * x + builtin_copysign<f32>(0.5, x)),\n        hx < 0x3F851592\n      );\n      t = <f32>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x33000000) {\n      return x;\n    } else k = 0;\n    let hfx: f32 = 0.5 * x;\n    let hxs: f32 = x * hfx;\n    let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n    t  = 3.0 - r1 * hfx;\n    let e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e  = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x7F + k) << 23;\n    let twopk = reinterpret<f32>(u);\n    let y: f32;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 128) y = y * 2.0 * Ox1p127f;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x7F - k) << 23;\n    y = reinterpret<f32>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f32): f32 {\n    return x;\n  }\n\n  export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n    const\n      Ox1p90f  = reinterpret<f32>(0x6C800000),\n      Ox1p_90f = reinterpret<f32>(0x12800000);\n\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    ux &= 0x7FFFFFFF;\n    uy &= 0x7FFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    x = reinterpret<f32>(ux);\n    y = reinterpret<f32>(uy);\n    if (uy == 0xFF << 23) return y;\n    if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n    let z: f32 = 1;\n    if (ux >= (0x7F + 60) << 23) {\n      z  = Ox1p90f;\n      x *= Ox1p_90f;\n      y *= Ox1p_90f;\n    } else if (uy < (0x7F - 60) << 23) {\n      z  = Ox1p_90f;\n      x *= Ox1p90f;\n      y *= Ox1p90f;\n    }\n    return z * builtin_sqrt<f32>(f32(<f64>x * x + <f64>y * y));\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function imul(x: f32, y: f32): f32 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return <f32>(dtoi32(x) * dtoi32(y));\n  }\n\n  export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return logf_lut(x);\n    } else {\n      const\n        ln2_hi  = reinterpret<f32>(0x3F317180), // 6.9313812256e-01f\n        ln2_lo  = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06f\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f\n        Lg4     = reinterpret<f32>(0x3E789E26), // 0xf89e26.0p-26f\n        Ox1p25f = reinterpret<f32>(0x4C000000);\n\n      let u = reinterpret<u32>(x);\n      let k = 0;\n      let sign = u >> 31;\n      if (sign || u < 0x00800000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0;\n        k -= 25;\n        x *= Ox1p25f;\n        u = reinterpret<u32>(x);\n      } else if (u >= 0x7F800000) {\n        return x;\n      } else if (u == 0x3F800000) {\n        return 0;\n      }\n      u += 0x3F800000 - 0x3F3504F3;\n      k += i32(u >> 23) - 0x7F;\n      u = (u & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(u);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq = <f32>0.5 * f * f;\n      let dk = <f32>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f32>(0x3EDE6000), //  4.3432617188e-01f\n      ivln10lo  = reinterpret<f32>(0xB804EAD9), // -3.1689971365e-05f\n      log10_2hi = reinterpret<f32>(0x3E9A2080), //  3.0102920532e-01f\n      log10_2lo = reinterpret<f32>(0x355427DB), //  7.9034151668e-07f\n      Lg1       = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2       = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n      Lg3       = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n      Lg4       = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n      Ox1p25f   = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n    let ux = reinterpret<u32>(x);\n    let k = 0;\n    let sign = ux >> 31;\n    if (sign || ux < 0x00800000) {\n      if (ux << 1 == 0) return -1 / (x * x);\n      if (sign) return (x - x) / 0.0;\n      k -= 25;\n      x *= Ox1p25f;\n      ux = reinterpret<u32>(x);\n    } else if (ux >= 0x7F800000) {\n      return x;\n    } else if (ux == 0x3F800000) {\n      return 0;\n    }\n    ux += 0x3F800000 - 0x3F3504F3;\n    k += i32(ux >> 23) - 0x7F;\n    ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n    x = reinterpret<f32>(ux);\n    let f = x - 1.0;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * Lg4);\n    let t2 = z * (Lg1 + w * Lg3);\n    let r = t2 + t1;\n    let hfsq: f32 = 0.5 * f * f;\n    let hi = f - hfsq;\n    ux = reinterpret<u32>(hi);\n    ux &= 0xFFFFF000;\n    hi = reinterpret<f32>(ux);\n    let lo = f - hi - hfsq + s * (hfsq + r);\n    let dk = <f32>k;\n    return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n  }\n\n  export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f32>(0x3F317180), // 6.9313812256e-01\n      ln2_lo = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06\n      Lg1    = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2    = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n      Lg3    = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n      Lg4    = reinterpret<f32>(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n    let ix = reinterpret<u32>(x);\n    let c: f32 = 0;\n    let f: f32 = 0;\n    let k = 1;\n    if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n      if (ix >= 0xBF800000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (ix << 1 < 0x33800000 << 1) return x;\n      if (ix <= 0xBE95F619) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (ix >= 0x7F800000) return x;\n    if (k) {\n      let uf: f32 = 1 + x;\n      let iu = reinterpret<u32>(uf);\n      iu += 0x3F800000 - 0x3F3504F3;\n      k = i32(iu >> 23) - 0x7F;\n      if (k < 25) {\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n      f = reinterpret<f32>(iu) - 1;\n    }\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * Lg4);\n    let t2 = z * (Lg1 + w * Lg3);\n    let r = t2 + t1;\n    let hfsq: f32 = 0.5 * f * f;\n    let dk = <f32>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2f_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f32>(0x3FB8B000), //  1.4428710938e+00f\n        ivln2lo = reinterpret<f32>(0xB9389AD4), // -1.7605285393e-04\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n        Lg4     = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n        Ox1p25f = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n      let ux = reinterpret<u32>(x);\n      let k = 0;\n      let sign = ux >> 31;\n      if (sign || ux < 0x00800000) {\n        if (ux << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 25;\n        x *= Ox1p25f;\n        ux = reinterpret<u32>(x);\n      } else if (ux >= 0x7F800000) {\n        return x;\n      } else if (ux == 0x3F800000) {\n        return 0;\n      }\n      ux += 0x3F800000 - 0x3F3504F3;\n      k += i32(ux >> 23) - 0x7F;\n      ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(ux);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq: f32 = 0.5 * f * f;\n      let hi = f - hfsq;\n      let u = reinterpret<u32>(hi);\n      u &= 0xFFFFF000;\n      hi = reinterpret<f32>(u);\n      let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n      let dk = <f32>k;\n      return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f32, value2: f32): f32 {\n    return builtin_max<f32>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f32, value2: f32): f32 {\n    return builtin_min<f32>(value1, value2);\n  }\n\n  export function pow(x: f32, y: f32): f32 {\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f32>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f32>(\n          builtin_abs<f32>(builtin_sqrt<f32>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      // see: musl/src/math/powf.c\n      return powf_lut(x, y);\n    } else {\n      // based on:  jdh8/metallic/src/math/float/powf.c\n      if (y == 0) return 1;\n      // @ts-ignore: cast\n      if (isNaN(x) | isNaN(y)) {\n        return NaN;\n      }\n      let sign: u32 = 0;\n      let uy = reinterpret<u32>(y);\n      let ux = reinterpret<u32>(x);\n      let sx = ux >> 31;\n      ux &= 0x7FFFFFFF;\n      if (sx && nearest(y) == y) {\n        x = -x;\n        sx = 0;\n        sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n      }\n      let m: u32;\n      if (ux == 0x3F800000) { // x == 1\n        m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n      } else if (ux == 0) {\n        m = <i32>uy < 0 ? 0x7F800000 : 0;\n      } else if (ux == 0x7F800000) {\n        m = <i32>uy < 0 ? 0 : 0x7F800000;\n      } else if (sx) {\n        m = 0x7FC00000;\n      } else {\n        m = reinterpret<u32>(<f32>exp2f(<f64>y * log2f(x)));\n      }\n      return reinterpret<f32>(m | sign);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function seedRandom(value: i64): void {\n    NativeMath.seedRandom(value);\n  }\n\n  // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n  export function random(): f32 {\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n\n    let s0 = random_state0_32;\n    let s1 = random_state1_32;\n    let r  = rotl<u32>(s0 * 0x9E3779BB, 5) * 5;\n\n    s1 ^= s0;\n    random_state0_32 = rotl<u32>(s0, 26) ^ s1 ^ (s1 << 9);\n    random_state1_32 = rotl<u32>(s1, 13);\n\n    return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;\n  }\n\n  export function round(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_ceil<f32>(x) - f32(builtin_ceil<f32>(x) - 0.5 > x);\n    } else {\n      let roundUp = builtin_ceil<f32>(x);\n      return select<f32>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n    }\n  }\n\n  export function sign(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return select<f32>(builtin_copysign<f32>(1, x), x, builtin_abs(x) > 0);\n    } else {\n      return select<f32>(1, select<f32>(-1, x, x < 0), x > 0);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f32): bool {\n    return <bool>(reinterpret<u32>(x) >>> 31);\n  }\n\n  export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return sin_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n        }\n        return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n      }\n\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n        }\n        return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n      }\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n\n    let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n    return n & 2 ? -t : t;\n  }\n\n  export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n    let u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    let a = reinterpret<f32>(u);\n    let h = builtin_copysign<f32>(0.5, x);\n    if (u < 0x42B17217) {\n      let t = expm1(a);\n      if (u < 0x3F800000) {\n        if (u < 0x3F800000 - (12 << 23)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2f(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f32): f32 {\n    return builtin_sqrt<f32>(x);\n  }\n\n  export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n    const\n      t1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      t2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      t3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      t4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return tan_kernf(x, 0);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n        }\n      }\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n        }\n      }\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    // argument reduction\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n    return tan_kernf(y, n & 1);\n  }\n\n  export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n    let u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    let y = reinterpret<f32>(u);\n    let t: f32;\n    if (u > 0x3F0C9F54) {\n      if (u > 0x41200000) t = 1 + 0 / y;\n      else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (u > 0x3E82C578) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (u >= 0x00800000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f32>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f32): f32 {\n    return builtin_trunc<f32>(x);\n  }\n\n  export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n    const\n      Ox1p24f   = reinterpret<f32>(0x4B800000),\n      Ox1p127f  = reinterpret<f32>(0x7F000000),\n      Ox1p_126f = reinterpret<f32>(0x00800000);\n\n    let y = x;\n    if (n > 127) {\n      y *= Ox1p127f;\n      n -= 127;\n      if (n > 127) {\n        y *= Ox1p127f;\n        n = builtin_min<i32>(n - 127, 127);\n      }\n    } else if (n < -126) {\n      y *= Ox1p_126f * Ox1p24f;\n      n += 126 - 24;\n      if (n < -126) {\n        y *= Ox1p_126f * Ox1p24f;\n        n = builtin_max<i32>(n + 126 - 24, -126);\n      }\n    }\n    return y * reinterpret<f32>(<u32>(0x7F + n) << 23);\n  }\n\n  export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n    if (builtin_abs<f32>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f32>(x - builtin_trunc<f32>(x), x);\n    }\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    let ex = i32(ux >> 23 & 0xFF);\n    let ey = i32(uy >> 23 & 0xFF);\n    let sm = ux & 0x80000000;\n    let uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0xFF || isNaN<f32>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    let ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f32(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<u32>(ux << 9);\n      ux <<= 1 - ex;\n    } else {\n      ux &= <u32>-1 >> 9;\n      ux |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u32(-1) >> 9;\n      uy |= 1 << 23;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 23); ux <<= 1) --ex;\n    let shift = <i32>builtin_clz<u32>(ux << 8);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 23;\n      ux |= <u32>ex << 23;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f32>(ux | sm);\n  }\n\n  export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    let ex = i32(ux >> 23 & 0xFF);\n    let ey = i32(uy >> 23 & 0xFF);\n    let uxi = ux;\n    if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n    if (ux << 1 == 0) return x;\n    if (!ex) {\n      ex -= builtin_clz<u32>(uxi << 9);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= u32(-1) >> 9;\n      uxi |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u32(-1) >> 9;\n      uy |= 1 << 23;\n    }\n    let q = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -30;\n      else {\n        let shift = builtin_clz<i32>(uxi << 8);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 23;\n      uxi |= <u32>ex << 23;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f32>(uxi);\n    y = builtin_abs<f32>(y);\n    let x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (<f32>x2 > y || (<f32>x2 == y && bool(q & 1))))) {\n      x -= y;\n      // q++;\n    }\n    return <i32>ux < 0 ? -x : x;\n  }\n\n  export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kernf(x);\n      sincos_cos = cos_kernf(x);\n      return;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          if (sign) {\n            sincos_sin = -cos_kernf(x + s1pio2);\n            sincos_cos =  sin_kernf(x + s1pio2);\n          } else {\n            sincos_sin = cos_kernf(s1pio2 - x);\n            sincos_cos = sin_kernf(s1pio2 - x);\n          }\n          return;\n        }\n        // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n        sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n        sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n        return;\n      }\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          if (sign) {\n            sincos_sin =  cos_kernf(x + s3pio2);\n            sincos_cos = -sin_kernf(x + s3pio2);\n          } else {\n            sincos_sin = -cos_kernf(x - s3pio2);\n            sincos_cos =  sin_kernf(x - s3pio2);\n          }\n          return;\n        }\n        sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n        sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n        return;\n      }\n    }\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n    let s = sin_kernf(y);\n    let c = cos_kernf(y);\n    let sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n  let out = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i32>(1 << e, 0, <u32>e < 32);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i32>(-1, 1, e & 1);\n      return i32(e == 0) | i32(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 32) {\n      let log = 32 - clz(e);\n      // 32 = 2 ^ 5, so need only five cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n  let out: i64 = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i64>(1 << e, 0, <u64>e < 64);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i64>(-1, 1, e & 1);\n      return i64(e == 0) | i64(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 64) {\n      let log = 64 - <i32>clz(e);\n      // 64 = 2 ^ 6, so need only six cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 6: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n  case  1: return x;\n  case  2: return x * x;\n  case  3: return x * x * x;\n  case  4: return (b = x * x) * b;\n  case  5: return (b = x * x) * b * x;\n  case  6: return (b = x * x) * b * b;\n  case  7: return (b = x * x) * b * b * x;\n  case  8: return (d = (b = x * x) * b) * d;\n  case  9: return (c = x * x * x) * c * c;\n  case 10: return (d = (b = x * x) * b) * d * b;\n  case 11: return (d = (b = x * x) * b) * d * b * x;\n  case 12: return (d = (b = x * x) * b) * d * d;\n  case 13: return (d = (b = x * x) * b) * d * d * x;\n  case 14: return (d = (b = x * x) * b) * d * d * b;\n  case 15: return (k = (b = x * x) * b * x) * k * k;\n  case 16: return (h = (d = (b = x * x) * b) * d) * h;\n  case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n  case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n  case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n  case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n  case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n  case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n  case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n  case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n  case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n  case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n  case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n  case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n  case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n  case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n  case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n  case 32:\n  ...\n  case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid<T>(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof<T>(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret<T>(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq<T>(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne<T>(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store<T>(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof<T>(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof<T>(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype<T>(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert<T>(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked<T>(expr: T): T;\n\nexport namespace inline {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function always<T>(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect<T>(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate<T>(...args: auto[]): T;\n\nexport namespace atomic {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load<T>(ptr: usize, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store<T>(ptr: usize, value: T, immOffset?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function notify(ptr: usize, count: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n  OK = 0,\n  NOT_EQUAL = 1,\n  TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i8 = -128;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i8 =  127;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i8 {\n    return <i8>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i16 = -32768;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i16 =  32767;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i16 {\n    return <i16>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i32 = -2147483648;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i32 =  2147483647;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i32 {\n    return strtol<i32>(value, radix);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_s(left: i32, right: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_u(left: u32, right: u32): u32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f32(value: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i64 = -9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i64 =  9223372036854775807;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i64 {\n    return strtol<i64>(value, radix);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: i64, right:i64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: i64, right:i64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_s(left: i64, right: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_u(left: u64, right: u64): u64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f64(value: f64): i64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw32 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? -2147483648\n    : <isize>-9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? 2147483647\n    : <isize>9223372036854775807;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): isize {\n    return <isize>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u8 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u8 = 255;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u8 {\n    return <u8>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u16 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u16 = 65535;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u16 {\n    return <u16>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u32 = 4294967295;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u32 {\n    return <u32>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u64 = 18446744073709551615;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u64 {\n    return <u64>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: usize = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()\n    ? 4294967295\n    : <usize>18446744073709551615;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): usize {\n    return <usize>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: bool = false;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: bool = true;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): bool {\n    return strtob(value);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f32 =  16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f32 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f32 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): f32 {\n    return <f32>strtod(value);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f32, y: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i32(value: i32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: f32, right: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f64 =  9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f64 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f64 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): f64 {\n    return strtod(value);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f64, y: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i64(value: i64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: f64, right: f64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat<T>(x: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane<T>(x: v128, idx: u8): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_zero<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function andnot(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function not(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true<T>(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask<T>(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot<T>(a: v128, b: v128): v128; // i16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr<T>(a: v128, b: v128): v128; // u8, u16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_zero<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_zero<T = f64>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low<T = f32>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_zero<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd<T>(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd<T>(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect<T>(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_q15mulr<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_add<T>(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n    l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_f64x2_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low_f32x4(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n  // @ts-ignore: decorator\n  @builtin\n  static new(value: i32): i31ref { return changetype<i31ref>(unreachable()); }\n\n  // @ts-ignore: decorator\n  @builtin\n  static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n  message?: string | null,\n  fileName?: string | null,\n  lineNumber?: u32,\n  columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n  message: string,\n  n?: i32,\n  a0?: f64,\n  a1?: f64,\n  a2?: f64,\n  a3?: f64,\n  a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","/**\r\n * Array Operations for AssemblyScript\r\n *\r\n * High-performance array operations using typed arrays.\r\n * These operations work directly on Float64Array data.\r\n */\r\n\r\n// =============================================================================\r\n// Reduction Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Sum all elements in the array\r\n */\r\nexport function array_sum(data: Float64Array): f64 {\r\n  let total: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    total += unchecked(data[i]);\r\n  }\r\n  return total;\r\n}\r\n\r\n/**\r\n * Product of all elements\r\n */\r\nexport function array_product(data: Float64Array): f64 {\r\n  let product: f64 = 1.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    product *= unchecked(data[i]);\r\n  }\r\n  return product;\r\n}\r\n\r\n/**\r\n * Mean (average) of all elements\r\n */\r\nexport function array_mean(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n  return array_sum(data) / f64(len);\r\n}\r\n\r\n/**\r\n * Variance (population variance)\r\n */\r\nexport function array_variance(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  const mean = array_mean(data);\r\n  let sumSqDiff: f64 = 0.0;\r\n\r\n  for (let i = 0; i < len; i++) {\r\n    const diff = unchecked(data[i]) - mean;\r\n    sumSqDiff += diff * diff;\r\n  }\r\n\r\n  return sumSqDiff / f64(len);\r\n}\r\n\r\n/**\r\n * Standard deviation (population)\r\n */\r\nexport function array_stddev(data: Float64Array): f64 {\r\n  return sqrt(array_variance(data));\r\n}\r\n\r\n/**\r\n * Minimum value\r\n */\r\nexport function array_min(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let minVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) minVal = val;\r\n  }\r\n  return minVal;\r\n}\r\n\r\n/**\r\n * Maximum value\r\n */\r\nexport function array_max(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let maxVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) maxVal = val;\r\n  }\r\n  return maxVal;\r\n}\r\n\r\n/**\r\n * Index of minimum value\r\n */\r\nexport function array_argmin(data: Float64Array): i32 {\r\n  const len = data.length;\r\n  if (len == 0) return -1;\r\n\r\n  let minIdx: i32 = 0;\r\n  let minVal = unchecked(data[0]);\r\n\r\n  for (let i: i32 = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) {\r\n      minVal = val;\r\n      minIdx = i;\r\n    }\r\n  }\r\n  return minIdx;\r\n}\r\n\r\n/**\r\n * Index of maximum value\r\n */\r\nexport function array_argmax(data: Float64Array): i32 {\r\n  const len = data.length;\r\n  if (len == 0) return -1;\r\n\r\n  let maxIdx: i32 = 0;\r\n  let maxVal = unchecked(data[0]);\r\n\r\n  for (let i: i32 = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) {\r\n      maxVal = val;\r\n      maxIdx = i;\r\n    }\r\n  }\r\n  return maxIdx;\r\n}\r\n\r\n/**\r\n * L2 norm (Euclidean norm)\r\n */\r\nexport function array_norm(data: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    sumSq += val * val;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * L1 norm (sum of absolute values)\r\n */\r\nexport function array_norm_l1(data: Float64Array): f64 {\r\n  let sum: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    sum += abs(unchecked(data[i]));\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * L-infinity norm (max absolute value)\r\n */\r\nexport function array_norm_linf(data: Float64Array): f64 {\r\n  let maxAbs: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const absVal = abs(unchecked(data[i]));\r\n    if (absVal > maxAbs) maxAbs = absVal;\r\n  }\r\n  return maxAbs;\r\n}\r\n\r\n// =============================================================================\r\n// Vector Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Dot product of two arrays\r\n */\r\nexport function array_dot(a: Float64Array, b: Float64Array): f64 {\r\n  const len = min(a.length, b.length);\r\n  let result: f64 = 0.0;\r\n  for (let i = 0; i < len; i++) {\r\n    result += unchecked(a[i]) * unchecked(b[i]);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Element-wise addition: result = a + b\r\n */\r\nexport function array_add(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise subtraction: result = a - b\r\n */\r\nexport function array_sub(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) - unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise multiplication: result = a * b\r\n */\r\nexport function array_mul(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) * unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise division: result = a / b\r\n */\r\nexport function array_div(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) / unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Scale array by scalar: result = a * scalar\r\n */\r\nexport function array_scale(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar to array: result = a + scalar\r\n */\r\nexport function array_add_scalar(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) + scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Negate array: result = -a\r\n */\r\nexport function array_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = -unchecked(a[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Absolute value: result = |a|\r\n */\r\nexport function array_abs(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = abs(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Square root: result = sqrt(a)\r\n */\r\nexport function array_sqrt(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = sqrt(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Square: result = a^2\r\n */\r\nexport function array_square(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(a[i]);\r\n    unchecked(result[i] = val * val);\r\n  }\r\n}\r\n\r\n/**\r\n * Exponential: result = Math.exp(a)\r\n */\r\nexport function array_exp(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = Math.exp(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Natural log: result = Math.log(a)\r\n */\r\nexport function array_log(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = Math.log(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Sine: result = Math.sin(a)\r\n */\r\nexport function array_sin(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = Math.sin(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Cosine: result = Math.cos(a)\r\n */\r\nexport function array_cos(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = Math.cos(unchecked(a[i])));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Helpers\r\n// =============================================================================\r\n\r\n/**\r\n * Linear combination: result = alpha*a + beta*b (AXPBY)\r\n */\r\nexport function array_axpby(\r\n  alpha: f64, a: Float64Array,\r\n  beta: f64, b: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = alpha * unchecked(a[i]) + beta * unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Euclidean distance between two vectors\r\n */\r\nexport function array_distance(a: Float64Array, b: Float64Array): f64 {\r\n  const len = min(a.length, b.length);\r\n  let sumSq: f64 = 0.0;\r\n  for (let i = 0; i < len; i++) {\r\n    const diff = unchecked(a[i]) - unchecked(b[i]);\r\n    sumSq += diff * diff;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * Cosine similarity between two vectors\r\n */\r\nexport function array_cosine_similarity(a: Float64Array, b: Float64Array): f64 {\r\n  const dot = array_dot(a, b);\r\n  const normA = array_norm(a);\r\n  const normB = array_norm(b);\r\n  if (normA == 0.0 || normB == 0.0) return 0.0;\r\n  return dot / (normA * normB);\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations (modify input array)\r\n// =============================================================================\r\n\r\n/**\r\n * Scale array in place: a *= scalar\r\n */\r\nexport function array_scale_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar in place: a += scalar\r\n */\r\nexport function array_add_scalar_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) + scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Add arrays in place: a += b\r\n */\r\nexport function array_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Clamp all values in place to [lo, hi]\r\n */\r\nexport function array_clamp_inplace(a: Float64Array, lo: f64, hi: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(a[i]);\r\n    unchecked(a[i] = max(lo, min(hi, val)));\r\n  }\r\n}\r\n\r\n/**\r\n * Fill array with value\r\n */\r\nexport function array_fill(a: Float64Array, value: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = value);\r\n  }\r\n}\r\n\r\n/**\r\n * Copy array: dst = src\r\n */\r\nexport function array_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(dst[i] = unchecked(src[i]));\r\n  }\r\n}\r\n","import { compareImpl } from \"./string\";\n\ntype Comparator<T> = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n  return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR<T>(): Comparator<T> {\n  if (isInteger<T>()) {\n    if (isSigned<T>() && sizeof<T>() <= 4) {\n      return (a, b) => i32(a) - i32(b);\n    } else {\n      return (a, b) => i32(a > b) - i32(a < b);\n    }\n  } else if (isFloat<T>()) {\n    if (sizeof<T>() == 4) {\n      return (a, b) => {\n        let ia = reinterpret<i32>(f32(a));\n        let ib = reinterpret<i32>(f32(b));\n        ia ^= ia >> 31 >>> 1;\n        ib ^= ib >> 31 >>> 1;\n        return i32(ia > ib) - i32(ia < ib);\n      };\n    } else {\n      return (a, b) => {\n        let ia = reinterpret<i64>(f64(a));\n        let ib = reinterpret<i64>(f64(b));\n        ia ^= ia >> 63 >>> 1;\n        ib ^= ib >> 63 >>> 1;\n        return i32(ia > ib) - i32(ia < ib);\n      };\n    }\n  } else if (isString<T>()) {\n    return (a, b) => {\n      if (\n        changetype<usize>(a) == changetype<usize>(b) ||\n        changetype<usize>(a) == 0 ||\n        changetype<usize>(b) == 0\n      ) return 0;\n      let alen = changetype<string>(a).length;\n      let blen = changetype<string>(b).length;\n      if (!(alen | blen)) return 0;\n      if (!alen) return -1;\n      if (!blen) return  1;\n      let res = compareImpl(\n        changetype<string>(a), 0,\n        changetype<string>(b), 0,\n        <usize>min(alen, blen)\n      );\n      return res ? res : alen - blen;\n    };\n  } else {\n    return (a, b) => i32(a > b) - i32(a < b);\n  }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT<T>(\n  ptr: usize,\n  len: i32,\n  comparator: Comparator<T>\n): void {\n  if (len <= INSERTION_SORT_THRESHOLD) {\n    if (len <= 1) return;\n    if (ASC_SHRINK_LEVEL < 1) {\n      switch (len) {\n        case 3: {\n          let a = load<T>(ptr, 0);\n          let b = load<T>(ptr, 1 << alignof<T>());\n          let c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 0);\n          a = select<T>(a, b, c);\n          b = load<T>(ptr, 2 << alignof<T>());\n          c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 1 << alignof<T>());\n          store<T>(ptr, select<T>(a, b, c), 2 << alignof<T>());\n        }\n        case 2: {\n          let a = load<T>(ptr, 0);\n          let b = load<T>(ptr, 1 << alignof<T>());\n          let c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 0);\n          store<T>(ptr, select<T>(a, b, c), 1 << alignof<T>());\n          return;\n        }\n      }\n    }\n    insertionSort<T>(ptr, 0, len - 1, 0, comparator);\n    return;\n  }\n\n  let lgPlus2         = log2u(len) + 2;\n  let lgPlus2Size     = lgPlus2 << alignof<u32>();\n  let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n  let leftRunEndBuf   = leftRunStartBuf + lgPlus2Size;\n\n  for (let i: u32 = 0; i < lgPlus2; ++i) {\n    store<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()), EMPTY);\n  }\n\n  let buffer = __alloc(len << alignof<T>());\n\n  let hi   = len - 1;\n  let endA = extendRunRight<T>(ptr, 0, hi, comparator);\n  let lenA = endA + 1;\n\n  if (lenA < MIN_RUN_LENGTH) {\n    endA = min(hi, MIN_RUN_LENGTH - 1);\n    insertionSort<T>(ptr, 0, endA, lenA, comparator);\n  }\n\n  let top: u32 = 0, startA = 0;\n  while (endA < hi) {\n    let startB = endA + 1;\n    let endB = extendRunRight<T>(ptr, startB, hi, comparator);\n    let lenB = endB - startB + 1;\n\n    if (lenB < MIN_RUN_LENGTH) {\n      endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n      insertionSort<T>(ptr, startB, endB, lenB, comparator);\n    }\n\n    let k = nodePower(0, hi, startA, startB, endB);\n\n    for (let i = top; i > k; --i) {\n      let start = load<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()));\n      if (start != EMPTY) {\n        mergeRuns<T>(\n          ptr,\n          start,\n          load<u32>(leftRunEndBuf + (<usize>i << alignof<u32>())) + 1,\n          endA,\n          buffer,\n          comparator\n        );\n        startA = start;\n        store<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()), EMPTY);\n      }\n    }\n\n    store<u32>(leftRunStartBuf + (<usize>k << alignof<u32>()), startA);\n    store<u32>(leftRunEndBuf   + (<usize>k << alignof<u32>()), endA);\n    startA = startB;\n    endA = endB;\n    top = k;\n  }\n\n  for (let i = top; i != 0; --i) {\n    let start = load<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()));\n    if (start != EMPTY) {\n      mergeRuns<T>(\n        ptr,\n        start,\n        load<u32>(leftRunEndBuf + (<usize>i << alignof<u32>())) + 1,\n        hi,\n        buffer,\n        comparator\n      );\n    }\n  }\n  // dealloc aux buffers\n  __free(buffer);\n  __free(leftRunStartBuf);\n}\n\nfunction insertionSort<T>(\n  ptr: usize,\n  left: i32,\n  right: i32,\n  presorted: i32,\n  comparator: Comparator<T>\n): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    // slightly improved original insertion sort\n    for (let i = left + presorted; i <= right; ++i) {\n      let j = i - 1;\n      let a = load<T>(ptr + (<usize>i << alignof<T>()));\n      while (j >= left) {\n        let b = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, b) < 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), b, 1 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), a, 1 << alignof<T>());\n    }\n  } else {\n    // even-odd two-way insertion sort which allow increase minRunLen\n    let range = right - left + 1;\n    let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n    for (; i <= right; i += 2) {\n      let a = load<T>(ptr + (<usize>i << alignof<T>()), 0);\n      let b = load<T>(ptr + (<usize>i << alignof<T>()), 1 << alignof<T>());\n      let min = b, max = a;\n      if (comparator(a, b) <= 0) {\n        min = a, max = b;\n      }\n      let j = i - 1;\n      while (j >= left) {\n        a = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, max) > 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), a, 2 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), max, 2 << alignof<T>());\n      while (j >= left) {\n        a = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, min) > 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), a, 1 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), min, 1 << alignof<T>());\n    }\n  }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n  let n: u64 = right - left + 1;\n  let s = startB - (left << 1);\n  let l = startA + s;\n  let r = endB   + s + 1;\n  let a = (<u64>l << 30) / n;\n  let b = (<u64>r << 30) / n;\n  return clz(<u32>(a ^ b));\n}\n\nfunction extendRunRight<T>(\n  ptr: usize,\n  i: i32,\n  right: i32,\n  comparator: Comparator<T>\n): i32 {\n  if (i == right) return i;\n  let j = i;\n  if (comparator(\n    load<T>(ptr + (<usize>  j << alignof<T>())),\n    load<T>(ptr + (<usize>++j << alignof<T>()))\n  ) > 0) {\n    while (\n      j < right &&\n      (comparator(\n        load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),\n        load<T>(ptr + (<usize>j << alignof<T>()))\n      ) >>> 31) // < 0\n    ) ++j;\n    // reverse\n    let k = j;\n    while (i < k) {\n      let tmp = load<T>(ptr + (<usize>i << alignof<T>()));\n      store<T>(ptr + (<usize>i << alignof<T>()), load<T>(ptr + (<usize>k << alignof<T>()))); ++i;\n      store<T>(ptr + (<usize>k << alignof<T>()), tmp); --k;\n    }\n  } else {\n    while (\n      j < right &&\n      comparator(\n        load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),\n        load<T>(ptr + (<usize>j << alignof<T>()))\n      ) >= 0\n    ) ++j;\n  }\n  return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns<T>(\n  ptr: usize,\n  l: i32,\n  m: i32,\n  r: i32,\n  buffer: usize,\n  comparator: Comparator<T>\n): void {\n  --m;\n  let i: i32, j: i32, t = r + m;\n  for (i = m + 1; i > l; --i) {\n    store<T>(\n      buffer + (<usize>(i - 1) << alignof<T>()),\n      load<T>(ptr + (<usize>(i - 1) << alignof<T>()))\n    );\n  }\n  for (j = m; j < r; ++j) {\n    store<T>(\n      buffer + (<usize>(t - j) << alignof<T>()),\n      load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>())\n    );\n  }\n  for (let k = l; k <= r; ++k) {\n    let a = load<T>(buffer + (<usize>j << alignof<T>()));\n    let b = load<T>(buffer + (<usize>i << alignof<T>()));\n    if (comparator(a, b) < 0) {\n      store<T>(ptr + (<usize>k << alignof<T>()), a);\n      --j;\n    } else {\n      store<T>(ptr + (<usize>k << alignof<T>()), b);\n      ++i;\n    }\n  }\n}\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n  /** Simple bump allocator without GC. */\n  Stub = 0,\n  /** Stop the world semi-automatic GC. */\n  Minimal = 1,\n  /** incremental GC. */\n  Incremental = 2,\n}\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n  [key: number]: i8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i8>();\n\n  constructor(length: i32) {\n    super(length, alignof<i8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i8 {\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i8>): void {\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): i8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: i8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {\n    SORT<i8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SLICE<Int8Array, i8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SUBARRAY<Int8Array, i8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n    return COPY_WITHIN<Int8Array, i8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n    return MAP<Int8Array, i8>(this, fn);\n  }\n\n  filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n    return FILTER<Int8Array, i8>(this, fn);\n  }\n\n  findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return SOME<Int8Array, i8>(this, fn);\n  }\n\n  every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return EVERY<Int8Array, i8>(this, fn);\n  }\n\n  forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n    FOREACH<Int8Array, i8>(this, fn);\n  }\n\n  reverse(): Int8Array {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i8>(this.dataStart, this.length, separator);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n    return WRAP<Int8Array, i8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): u8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {\n    SORT<u8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SLICE<Uint8Array, u8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SUBARRAY<Uint8Array, u8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n    return MAP<Uint8Array, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n    return FILTER<Uint8Array, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return SOME<Uint8Array, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return EVERY<Uint8Array, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n    FOREACH<Uint8Array, u8>(this, fn);\n  }\n\n  reverse(): Uint8Array {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n    return WRAP<Uint8Array, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  at(index: i32): u8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    value = ~(value >> 31) & (((255 - value) >> 31) | value);\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {\n    SORT<u8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SLICE<Uint8ClampedArray, u8>(this, begin, end);\n  }\n\n  subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n    return MAP<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n    return FILTER<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_LAST_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return SOME<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return EVERY<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n    FOREACH<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  reverse(): Uint8ClampedArray {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n    return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int16Array extends ArrayBufferView {\n  [key: number]: i16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i16>();\n\n  constructor(length: i32) {\n    super(length, alignof<i16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i16 {\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i16>): void {\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  at(index: i32): i16 {\n    let len = this.byteLength >>> alignof<i16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  includes(searchElement: i16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    FILL<u16>(this.dataStart, this.length, u16(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {\n    SORT<i16>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SLICE<Int16Array, i16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SUBARRAY<Int16Array, i16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n    return COPY_WITHIN<Int16Array, i16>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n    return MAP<Int16Array, i16>(this, fn);\n  }\n\n  filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n    return FILTER<Int16Array, i16>(this, fn);\n  }\n\n  findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return SOME<Int16Array, i16>(this, fn);\n  }\n\n  every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return EVERY<Int16Array, i16>(this, fn);\n  }\n\n  forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n    FOREACH<Int16Array, i16>(this, fn);\n  }\n\n  reverse(): Int16Array {\n    REVERSE<u16>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n    return WRAP<Int16Array, i16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n  [key: number]: u16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u16>();\n\n  constructor(length: i32) {\n    super(length, alignof<u16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u16 {\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u16>): void {\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  at(index: i32): u16 {\n    let len = this.byteLength >>> alignof<u16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  includes(searchElement: u16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    FILL<u16>(this.dataStart, this.length, u16(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {\n    SORT<u16>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SLICE<Uint16Array, u16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SUBARRAY<Uint16Array, u16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n    return MAP<Uint16Array, u16>(this, fn);\n  }\n\n  filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n    return FILTER<Uint16Array, u16>(this, fn);\n  }\n\n  findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return SOME<Uint16Array, u16>(this, fn);\n  }\n\n  every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return EVERY<Uint16Array, u16>(this, fn);\n  }\n\n  forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n    FOREACH<Uint16Array, u16>(this, fn);\n  }\n\n  reverse(): Uint16Array {\n    REVERSE<u16>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n    return WRAP<Uint16Array, u16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int32Array extends ArrayBufferView {\n  [key: number]: i32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i32>();\n\n  constructor(length: i32) {\n    super(length, alignof<i32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i32 {\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i32): void {\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  at(index: i32): i32 {\n    let len = this.byteLength >>> alignof<i32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  includes(searchElement: i32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    FILL<u32>(this.dataStart, this.length, u32(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {\n    SORT<i32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SLICE<Int32Array, i32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SUBARRAY<Int32Array, i32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n    return COPY_WITHIN<Int32Array, i32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n    return MAP<Int32Array, i32>(this, fn);\n  }\n\n  filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n    return FILTER<Int32Array, i32>(this, fn);\n  }\n\n  findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return SOME<Int32Array, i32>(this, fn);\n  }\n\n  every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return EVERY<Int32Array, i32>(this, fn);\n  }\n\n  forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n    FOREACH<Int32Array, i32>(this, fn);\n  }\n\n  reverse(): Int32Array {\n    REVERSE<u32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n    return WRAP<Int32Array, i32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n  [key: number]: u32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u32>();\n\n  constructor(length: i32) {\n    super(length, alignof<u32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u32 {\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u32): void {\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  at(index: i32): u32 {\n    let len = this.byteLength >>> alignof<u32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  includes(searchElement: u32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    FILL<u32>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {\n    SORT<u32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SLICE<Uint32Array, u32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SUBARRAY<Uint32Array, u32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n    return MAP<Uint32Array, u32>(this, fn);\n  }\n\n  filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n    return FILTER<Uint32Array, u32>(this, fn);\n  }\n\n  findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return SOME<Uint32Array, u32>(this, fn);\n  }\n\n  every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return EVERY<Uint32Array, u32>(this, fn);\n  }\n\n  forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n    FOREACH<Uint32Array, u32>(this, fn);\n  }\n\n  reverse(): Uint32Array {\n    REVERSE<u32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n    return WRAP<Uint32Array, u32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int64Array extends ArrayBufferView {\n  [key: number]: i64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i64>();\n\n  constructor(length: i32) {\n    super(length, alignof<i64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i64 {\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i64): void {\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  at(index: i32): i64 {\n    let len = this.byteLength >>> alignof<i64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  includes(searchElement: i64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    FILL<u64>(this.dataStart, this.length, u64(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {\n    SORT<i64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SLICE<Int64Array, i64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SUBARRAY<Int64Array, i64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n    return COPY_WITHIN<Int64Array, i64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n    return MAP<Int64Array, i64>(this, fn);\n  }\n\n  filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n    return FILTER<Int64Array, i64>(this, fn);\n  }\n\n  findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return SOME<Int64Array, i64>(this, fn);\n  }\n\n  every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return EVERY<Int64Array, i64>(this, fn);\n  }\n\n  forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n    FOREACH<Int64Array, i64>(this, fn);\n  }\n\n  reverse(): Int64Array {\n    REVERSE<u64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n    return WRAP<Int64Array, i64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n  [key: number]: u64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u64>();\n\n  constructor(length: i32) {\n    super(length, alignof<u64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u64 {\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u64): void {\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  at(index: i32): u64 {\n    let len = this.byteLength >>> alignof<u64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  includes(searchElement: u64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    FILL<u64>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {\n    SORT<u64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SLICE<Uint64Array, u64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SUBARRAY<Uint64Array, u64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return COPY_WITHIN<Uint64Array, u64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n    return MAP<Uint64Array, u64>(this, fn);\n  }\n\n  filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n    return FILTER<Uint64Array, u64>(this, fn);\n  }\n\n  findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return SOME<Uint64Array, u64>(this, fn);\n  }\n\n  every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return EVERY<Uint64Array, u64>(this, fn);\n  }\n\n  forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n    FOREACH<Uint64Array, u64>(this, fn);\n  }\n\n  reverse(): Uint64Array {\n    REVERSE<u64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n    return WRAP<Uint64Array, u64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float32Array extends ArrayBufferView {\n  [key: number]: f32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f32>();\n\n  constructor(length: i32) {\n    super(length, alignof<f32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f32 {\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f32): void {\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  at(index: i32): f32 {\n    let len = this.byteLength >>> alignof<f32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  includes(searchElement: f32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    FILL<f32>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {\n    SORT<f32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SLICE<Float32Array, f32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SUBARRAY<Float32Array, f32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n    return COPY_WITHIN<Float32Array, f32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n    return MAP<Float32Array, f32>(this, fn);\n  }\n\n  filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n    return FILTER<Float32Array, f32>(this, fn);\n  }\n\n  findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return SOME<Float32Array, f32>(this, fn);\n  }\n\n  every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return EVERY<Float32Array, f32>(this, fn);\n  }\n\n  forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n    FOREACH<Float32Array, f32>(this, fn);\n  }\n\n  reverse(): Float32Array {\n    REVERSE<f32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n    return WRAP<Float32Array, f32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float64Array extends ArrayBufferView {\n  [key: number]: f64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f64>();\n\n  constructor(length: i32) {\n    super(length, alignof<f64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f64 {\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f64): void {\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  at(index: i32): f64 {\n    let len = this.byteLength >>> alignof<f64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  includes(searchElement: f64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    FILL<f64>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {\n    SORT<f64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SLICE<Float64Array, f64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SUBARRAY<Float64Array, f64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n    return COPY_WITHIN<Float64Array, f64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n    return MAP<Float64Array, f64>(this, fn);\n  }\n\n  filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n    return FILTER<Float64Array, f64>(this, fn);\n  }\n\n  findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return SOME<Float64Array, f64>(this, fn);\n  }\n\n  every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return EVERY<Float64Array, f64>(this, fn);\n  }\n\n  forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n    FOREACH<Float64Array, f64>(this, fn);\n  }\n\n  reverse(): Float64Array {\n    REVERSE<f64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n    return WRAP<Float64Array, f64>(buffer, byteOffset, length);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  start: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  start  = start < 0 ? max(start + len, 0) : min(start, len);\n  end    = end   < 0 ? max(end   + len, 0) : min(end  , len);\n  len = max(end - start, 0);\n  let slice = instantiate<TArray>(len);\n  memory.copy(\n    slice.dataStart,\n    array.dataStart + (<usize>start << alignof<T>()),\n    <usize>len << alignof<T>()\n  );\n  return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  begin: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  end   = max(end, begin);\n\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<usize>(array.buffer);\n  store<usize>(changetype<usize>(out), buf, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), buf, false);\n  store<usize>(changetype<usize>(out), array.dataStart + (<usize>begin << alignof<T>()), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), (end - begin) << alignof<T>(), offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  target: i32,\n  start: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  let ptr = array.dataStart;\n\n  end   = min<i32>(end, len);\n  let to    = target < 0 ? max(len + target, 0) : min(target, len);\n  let from  = start < 0 ? max(len + start, 0) : min(start, len);\n  let last  = end < 0 ? max(len + end, 0) : min(end, len);\n  let count = min(last - from, len - to);\n\n  memory.copy(\n    ptr + (<usize>to << alignof<T>()),\n    ptr + (<usize>from << alignof<T>()),\n    <usize>count << alignof<T>()\n  );\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE<TArray extends ArrayBufferView, T extends number, TRet extends number>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    initialValue = fn(initialValue, load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT<TArray extends ArrayBufferView, T extends number, TRet extends number>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  let ptr = array.dataStart;\n  for (let i = array.length - 1; i >= 0; i--) {\n    initialValue = fn(initialValue, load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n  let len = array.length;\n  let ptr = array.dataStart;\n\n  let byteLength = len << alignof<T>();\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<ArrayBuffer>(__new(byteLength, idof<ArrayBuffer>()));\n  for (let i = 0; i < len; i++) {\n    store<T>(\n      changetype<usize>(buf) + (<usize>i << alignof<T>()),\n      fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)\n    );\n  }\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buf), false);\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n  let len = array.length;\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<ArrayBuffer>(__new(len << alignof<T>(), idof<ArrayBuffer>()));\n  let dataStart  = array.dataStart;\n  let j: usize = 0;\n  for (let i = 0; i < len; i++) {\n    let value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    if (fn(value, i, array)) {\n      store<T>(\n        changetype<usize>(buf) + (j++ << alignof<T>()),\n        value\n      );\n    }\n  }\n  // shrink output buffer\n  let byteLength = j << alignof<T>();\n  let data = __renew(changetype<usize>(buf), byteLength);\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), data, false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  let ptr = array.dataStart;\n  for (let i = array.length - 1; i >= 0; --i) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): bool {\n  if (isFloat<T>()) {\n    let index: isize = fromIndex;\n    let len: isize = array.length;\n    if (len == 0 || index >= len) return false;\n    if (index < 0) index = max(len + index, 0);\n    let dataStart = array.dataStart;\n    while (index < len) {\n      let elem = load<T>(dataStart + (index << alignof<T>()));\n      // @ts-ignore\n      if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n      ++index;\n    }\n    return false;\n  } else {\n    return INDEX_OF<TArray, T>(array, searchElement, fromIndex) >= 0;\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  let index: isize = fromIndex;\n  let len: isize = array.length;\n  if (len == 0 || index >= len) return -1;\n  if (index < 0) index = max(len + index, 0);\n  let dataStart = array.dataStart;\n  while (index < len) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    ++index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  let index: isize = fromIndex;\n  let len: isize = array.length;\n  if (len == 0) return -1;\n  if (index < 0) index = len + index; // no need to clamp\n  else if (index >= len) index = len - 1;\n  let dataStart = array.dataStart;\n  while (index >= 0) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    --index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return true;\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) continue;\n    return false;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => void,\n): void {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP<TArray extends ArrayBufferView, T>(\n  buffer: ArrayBuffer,\n  byteOffset: i32 = 0,\n  len: i32 = -1\n): TArray {\n  let byteLength: i32;\n  let bufferByteLength = buffer.byteLength;\n  const mask: u32 = sizeof<T>() - 1;\n  if (i32(<u32>byteOffset > <u32>bufferByteLength) | (byteOffset & mask)) {\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  if (len < 0) {\n    if (len == -1) {\n      if (bufferByteLength & mask) {\n        throw new RangeError(E_INVALIDLENGTH);\n      }\n      byteLength = bufferByteLength - byteOffset;\n    } else {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  } else {\n    byteLength = len << alignof<T>();\n    if (byteOffset + byteLength > bufferByteLength) {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  }\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buffer), false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer) + <usize>byteOffset, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n  TArray extends ArrayLike<number>,\n  UArray extends ArrayLike<number>\n>(\n  target: TArray,\n  source: UArray,\n  offset: i32 = 0\n): void {\n  // need to assert at compile time that U is not a reference or a function\n  if (isReference<valueof<UArray>>()) {\n    ERROR(E_NOTIMPLEMENTED);\n  }\n  let sourceLen = source.length;\n  if (offset < 0 || sourceLen + offset > target.length) {\n    // offset is out of bounds\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  // @ts-ignore: dataStart\n  let targetStart = target.dataStart + (<usize>offset << (alignof<valueof<TArray>>()));\n  // @ts-ignore: dataStart\n  let sourceStart = source.dataStart;\n  // if the types align and match, use memory.copy() instead of manual loop\n  if (\n    isInteger<valueof<TArray>>() == isInteger<valueof<UArray>>() &&\n    alignof<valueof<TArray>>() == alignof<valueof<UArray>>() &&\n    !(isSigned<valueof<UArray>>() && target instanceof Uint8ClampedArray)\n  ) {\n    memory.copy(targetStart, sourceStart, <usize>sourceLen << (alignof<valueof<UArray>>()));\n  } else {\n    for (let i = 0; i < sourceLen; i++) {\n      let ptr = targetStart + (<usize>i << (alignof<valueof<TArray>>()));\n      let value = load<valueof<UArray>>(sourceStart + (<usize>i << (alignof<valueof<UArray>>())));\n      // if TArray is Uint8ClampedArray, then values must be clamped\n      if (target instanceof Uint8ClampedArray) {\n        if (isFloat<valueof<UArray>>()) {\n          store<valueof<TArray>>(ptr,\n            isFinite<valueof<UArray>>(value)\n              ? <valueof<TArray>>max<valueof<UArray>>(0, min<valueof<UArray>>(255, value))\n              : 0\n          );\n        } else {\n          if (!isSigned<valueof<UArray>>()) {\n            store<valueof<TArray>>(ptr, min<valueof<UArray>>(255, value));\n          } else if (sizeof<valueof<TArray>>() <= 4) {\n            store<valueof<TArray>>(ptr, ~(<i32>value >> 31) & (((255 - <i32>value) >> 31) | value));\n          } else {\n            store<valueof<TArray>>(ptr, ~(<i64>value >> 63) & (((255 - <i64>value) >> 63) | value));\n          }\n        }\n      } else {\n        if (isFloat<valueof<UArray>>() && !isFloat<valueof<TArray>>()) {\n          store<valueof<TArray>>(ptr, isFinite<valueof<UArray>>(value) ? <valueof<TArray>>value : 0);\n        } else {\n          store<valueof<TArray>>(ptr, <valueof<TArray>>value);\n        }\n      }\n    }\n  }\n}\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n  readonly buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  readonly byteLength: i32;\n\n  get byteOffset(): i32 {\n    return <i32>(this.dataStart - changetype<usize>(this.buffer));\n  }\n\n  protected constructor(length: i32, alignLog2: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    let buffer = changetype<ArrayBuffer>(__new(length = length << alignLog2, idof<ArrayBuffer>()));\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    }\n    this.buffer = buffer; // links\n    this.dataStart = changetype<usize>(buffer);\n    this.byteLength = length;\n  }\n}\n\n@final export class ArrayBuffer {\n\n  static isView<T>(value: T): bool {\n    if (isNullable<T>()) {\n      if (changetype<usize>(value) == 0) return false;\n    }\n    if (value instanceof Int8Array) return true;\n    if (value instanceof Uint8Array) return true;\n    if (value instanceof Uint8ClampedArray) return true;\n    if (value instanceof Int16Array) return true;\n    if (value instanceof Uint16Array) return true;\n    if (value instanceof Int32Array) return true;\n    if (value instanceof Uint32Array) return true;\n    if (value instanceof Int64Array) return true;\n    if (value instanceof Uint64Array) return true;\n    if (value instanceof Float32Array) return true;\n    if (value instanceof Float64Array) return true;\n    if (value instanceof DataView) return true;\n    return false;\n  }\n\n  constructor(length: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n    let buffer = changetype<ArrayBuffer>(__new(<usize>length, idof<ArrayBuffer>()));\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    }\n    return buffer;\n  }\n\n  get byteLength(): i32 {\n    return changetype<OBJECT>(changetype<usize>(this) - TOTAL_OVERHEAD).rtSize;\n  }\n\n  slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n    let length = this.byteLength;\n    begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n    end   = end   < 0 ? max(length + end  , 0) : min(end  , length);\n    let outSize = <usize>max(end - begin, 0);\n    let out = changetype<ArrayBuffer>(__new(outSize, idof<ArrayBuffer>()));\n    memory.copy(changetype<usize>(out), changetype<usize>(this) + <usize>begin, outSize);\n    return out;\n  }\n\n  toString(): string {\n    return \"[object ArrayBuffer]\";\n  }\n}\n","/**\r\n * Matrix Operations for AssemblyScript\r\n *\r\n * Dense matrix operations using flat Float64Array storage.\r\n * Row-major order: element at (i,j) is at index i*cols + j\r\n *\r\n * Note: AssemblyScript doesn't support classes with complex patterns,\r\n * so we use pure functions with explicit dimensions.\r\n */\r\n\r\n// =============================================================================\r\n// Matrix Creation\r\n// =============================================================================\r\n\r\n/**\r\n * Create a matrix filled with zeros\r\n */\r\nexport function matrix_zeros(rows: i32, cols: i32): Float64Array {\r\n  return new Float64Array(rows * cols);\r\n}\r\n\r\n/**\r\n * Create a matrix filled with ones\r\n */\r\nexport function matrix_ones(rows: i32, cols: i32): Float64Array {\r\n  const data = new Float64Array(rows * cols);\r\n  const len = rows * cols;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(data[i] = 1.0);\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create a matrix filled with a specific value\r\n */\r\nexport function matrix_fill(rows: i32, cols: i32, value: f64): Float64Array {\r\n  const data = new Float64Array(rows * cols);\r\n  const len = rows * cols;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(data[i] = value);\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create an identity matrix\r\n */\r\nexport function matrix_identity(n: i32): Float64Array {\r\n  const data = new Float64Array(n * n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(data[i * n + i] = 1.0);\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create a diagonal matrix from array of values\r\n */\r\nexport function matrix_diag(values: Float64Array): Float64Array {\r\n  const n = values.length;\r\n  const data = new Float64Array(n * n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(data[i * n + i] = unchecked(values[i]));\r\n  }\r\n  return data;\r\n}\r\n\r\n// =============================================================================\r\n// Element Access\r\n// =============================================================================\r\n\r\n/**\r\n * Get element at (row, col)\r\n */\r\nexport function matrix_get(data: Float64Array, cols: i32, row: i32, col: i32): f64 {\r\n  return unchecked(data[row * cols + col]);\r\n}\r\n\r\n/**\r\n * Set element at (row, col)\r\n */\r\nexport function matrix_set(data: Float64Array, cols: i32, row: i32, col: i32, value: f64): void {\r\n  unchecked(data[row * cols + col] = value);\r\n}\r\n\r\n/**\r\n * Get a row as a new array\r\n */\r\nexport function matrix_get_row(data: Float64Array, cols: i32, row: i32): Float64Array {\r\n  const result = new Float64Array(cols);\r\n  const offset = row * cols;\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked(result[j] = unchecked(data[offset + j]));\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Get a column as a new array\r\n */\r\nexport function matrix_get_col(data: Float64Array, rows: i32, cols: i32, col: i32): Float64Array {\r\n  const result = new Float64Array(rows);\r\n  for (let i = 0; i < rows; i++) {\r\n    unchecked(result[i] = unchecked(data[i * cols + col]));\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Get diagonal elements\r\n */\r\nexport function matrix_get_diag(data: Float64Array, rows: i32, cols: i32): Float64Array {\r\n  const n = min(rows, cols);\r\n  const result = new Float64Array(n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(result[i] = unchecked(data[i * cols + i]));\r\n  }\r\n  return result;\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Matrix addition: C = A + B\r\n */\r\nexport function matrix_add(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Matrix subtraction: C = A - B\r\n */\r\nexport function matrix_sub(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) - unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise multiplication (Hadamard product): C = A .* B\r\n */\r\nexport function matrix_mul_elementwise(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) * unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise division: C = A ./ B\r\n */\r\nexport function matrix_div_elementwise(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) / unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Scalar multiplication: C = A * scalar\r\n */\r\nexport function matrix_scale(\r\n  a: Float64Array, scalar: f64, result: Float64Array\r\n): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Scalar addition: C = A + scalar\r\n */\r\nexport function matrix_add_scalar(\r\n  a: Float64Array, scalar: f64, result: Float64Array\r\n): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) + scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Negate matrix: C = -A\r\n */\r\nexport function matrix_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = -unchecked(a[i]));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Multiplication\r\n// =============================================================================\r\n\r\n/**\r\n * Matrix multiplication: C = A * B\r\n * A is (aRows x aCols), B is (aCols x bCols), C is (aRows x bCols)\r\n *\r\n * Uses naive O(n^3) algorithm - suitable for SIMD optimization\r\n */\r\nexport function matrix_multiply(\r\n  a: Float64Array, aRows: i32, aCols: i32,\r\n  b: Float64Array, bCols: i32,\r\n  result: Float64Array\r\n): void {\r\n  // Clear result\r\n  const resultLen = aRows * bCols;\r\n  for (let i = 0; i < resultLen; i++) {\r\n    unchecked(result[i] = 0.0);\r\n  }\r\n\r\n  // Naive matmul with good cache access pattern\r\n  for (let i = 0; i < aRows; i++) {\r\n    for (let k = 0; k < aCols; k++) {\r\n      const aik = unchecked(a[i * aCols + k]);\r\n      for (let j = 0; j < bCols; j++) {\r\n        unchecked(result[i * bCols + j] += aik * unchecked(b[k * bCols + j]));\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Matrix-vector multiplication: y = A * x\r\n * A is (rows x cols), x is (cols), y is (rows)\r\n */\r\nexport function matrix_vector_multiply(\r\n  a: Float64Array, rows: i32, cols: i32,\r\n  x: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    let sum: f64 = 0.0;\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      sum += unchecked(a[offset + j]) * unchecked(x[j]);\r\n    }\r\n    unchecked(result[i] = sum);\r\n  }\r\n}\r\n\r\n/**\r\n * Vector-matrix multiplication: y = x^T * A\r\n * x is (rows), A is (rows x cols), y is (cols)\r\n */\r\nexport function vector_matrix_multiply(\r\n  x: Float64Array,\r\n  a: Float64Array, rows: i32, cols: i32,\r\n  result: Float64Array\r\n): void {\r\n  // Clear result\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked(result[j] = 0.0);\r\n  }\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    const xi = unchecked(x[i]);\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked(result[j] += xi * unchecked(a[offset + j]));\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Outer product: C = x * y^T\r\n * x is (m), y is (n), C is (m x n)\r\n */\r\nexport function matrix_outer(\r\n  x: Float64Array, y: Float64Array, result: Float64Array\r\n): void {\r\n  const m = x.length;\r\n  const n = y.length;\r\n  for (let i = 0; i < m; i++) {\r\n    const xi = unchecked(x[i]);\r\n    const offset = i * n;\r\n    for (let j = 0; j < n; j++) {\r\n      unchecked(result[offset + j] = xi * unchecked(y[j]));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Transpose\r\n// =============================================================================\r\n\r\n/**\r\n * Transpose matrix: B = A^T\r\n * A is (rows x cols), B is (cols x rows)\r\n */\r\nexport function matrix_transpose(\r\n  a: Float64Array, rows: i32, cols: i32, result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked(result[j * rows + i] = unchecked(a[i * cols + j]));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Reductions\r\n// =============================================================================\r\n\r\n/**\r\n * Sum of all elements\r\n */\r\nexport function matrix_sum(data: Float64Array): f64 {\r\n  let sum: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    sum += unchecked(data[i]);\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * Mean of all elements\r\n */\r\nexport function matrix_mean(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n  return matrix_sum(data) / f64(len);\r\n}\r\n\r\n/**\r\n * Minimum element\r\n */\r\nexport function matrix_min(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let minVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) minVal = val;\r\n  }\r\n  return minVal;\r\n}\r\n\r\n/**\r\n * Maximum element\r\n */\r\nexport function matrix_max(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let maxVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) maxVal = val;\r\n  }\r\n  return maxVal;\r\n}\r\n\r\n/**\r\n * Frobenius norm (sqrt of sum of squares)\r\n */\r\nexport function matrix_norm_frobenius(data: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    sumSq += val * val;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * Trace (sum of diagonal elements)\r\n */\r\nexport function matrix_trace(data: Float64Array, rows: i32, cols: i32): f64 {\r\n  const n = min(rows, cols);\r\n  let sum: f64 = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    sum += unchecked(data[i * cols + i]);\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * Sum along rows (result is column vector)\r\n */\r\nexport function matrix_sum_rows(\r\n  data: Float64Array, rows: i32, cols: i32, result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    let sum: f64 = 0.0;\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      sum += unchecked(data[offset + j]);\r\n    }\r\n    unchecked(result[i] = sum);\r\n  }\r\n}\r\n\r\n/**\r\n * Sum along columns (result is row vector)\r\n */\r\nexport function matrix_sum_cols(\r\n  data: Float64Array, rows: i32, cols: i32, result: Float64Array\r\n): void {\r\n  // Clear result\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked(result[j] = 0.0);\r\n  }\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked(result[j] += unchecked(data[offset + j]));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Queries\r\n// =============================================================================\r\n\r\n/**\r\n * Check if matrix is square\r\n */\r\nexport function matrix_is_square(rows: i32, cols: i32): bool {\r\n  return rows == cols;\r\n}\r\n\r\n/**\r\n * Check if matrix is symmetric (within tolerance)\r\n */\r\nexport function matrix_is_symmetric(\r\n  data: Float64Array, rows: i32, cols: i32, tolerance: f64\r\n): bool {\r\n  if (rows != cols) return false;\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = i + 1; j < cols; j++) {\r\n      const aij = unchecked(data[i * cols + j]);\r\n      const aji = unchecked(data[j * cols + i]);\r\n      if (abs(aij - aji) > tolerance) return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Check if matrix is diagonal (within tolerance)\r\n */\r\nexport function matrix_is_diagonal(\r\n  data: Float64Array, rows: i32, cols: i32, tolerance: f64\r\n): bool {\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      if (i != j) {\r\n        if (abs(unchecked(data[i * cols + j])) > tolerance) return false;\r\n      }\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Check if matrix equals identity (within tolerance)\r\n */\r\nexport function matrix_is_identity(\r\n  data: Float64Array, rows: i32, cols: i32, tolerance: f64\r\n): bool {\r\n  if (rows != cols) return false;\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      const expected: f64 = i == j ? 1.0 : 0.0;\r\n      if (abs(unchecked(data[i * cols + j]) - expected) > tolerance) return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Scale matrix in place: A *= scalar\r\n */\r\nexport function matrix_scale_inplace(data: Float64Array, scalar: f64): void {\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(data[i] = unchecked(data[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar in place: A += scalar\r\n */\r\nexport function matrix_add_scalar_inplace(data: Float64Array, scalar: f64): void {\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(data[i] = unchecked(data[i]) + scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Add matrix in place: A += B\r\n */\r\nexport function matrix_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Copy matrix: dst = src\r\n */\r\nexport function matrix_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(dst[i] = unchecked(src[i]));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Basics\r\n// =============================================================================\r\n\r\n/**\r\n * AXPY operation: Y = alpha*X + Y (BLAS Level 1)\r\n */\r\nexport function matrix_axpy(\r\n  alpha: f64, x: Float64Array, y: Float64Array\r\n): void {\r\n  const len = min(x.length, y.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(y[i] = alpha * unchecked(x[i]) + unchecked(y[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * GEMM: C = alpha*A*B + beta*C (General Matrix Multiply)\r\n * A is (m x k), B is (k x n), C is (m x n)\r\n */\r\nexport function matrix_gemm(\r\n  alpha: f64, a: Float64Array, m: i32, k: i32,\r\n  b: Float64Array, n: i32,\r\n  beta: f64, c: Float64Array\r\n): void {\r\n  // Scale C by beta\r\n  const cLen = m * n;\r\n  for (let i = 0; i < cLen; i++) {\r\n    unchecked(c[i] = beta * unchecked(c[i]));\r\n  }\r\n\r\n  // Add alpha * A * B\r\n  for (let i = 0; i < m; i++) {\r\n    for (let p = 0; p < k; p++) {\r\n      const aip = alpha * unchecked(a[i * k + p]);\r\n      for (let j = 0; j < n; j++) {\r\n        unchecked(c[i * n + j] += aip * unchecked(b[p * n + j]));\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * GEMV: y = alpha*A*x + beta*y (General Matrix-Vector Multiply)\r\n * A is (m x n), x is (n), y is (m)\r\n */\r\nexport function matrix_gemv(\r\n  alpha: f64, a: Float64Array, m: i32, n: i32,\r\n  x: Float64Array,\r\n  beta: f64, y: Float64Array\r\n): void {\r\n  for (let i = 0; i < m; i++) {\r\n    let dot: f64 = 0.0;\r\n    const offset = i * n;\r\n    for (let j = 0; j < n; j++) {\r\n      dot += unchecked(a[offset + j]) * unchecked(x[j]);\r\n    }\r\n    unchecked(y[i] = alpha * dot + beta * unchecked(y[i]));\r\n  }\r\n}\r\n","/**\r\n * Complex Number Operations for AssemblyScript\r\n *\r\n * Standalone functions for complex number arithmetic.\r\n * These complement the Complex class methods for use cases\r\n * where functional style is preferred.\r\n */\r\n\r\nimport { Complex, complexFromPolar } from '../types/complex';\r\n\r\n// =============================================================================\r\n// Basic Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Add two complex numbers\r\n */\r\nexport function complex_add(a: Complex, b: Complex): Complex {\r\n  return a.add(b);\r\n}\r\n\r\n/**\r\n * Subtract two complex numbers\r\n */\r\nexport function complex_sub(a: Complex, b: Complex): Complex {\r\n  return a.sub(b);\r\n}\r\n\r\n/**\r\n * Multiply two complex numbers\r\n */\r\nexport function complex_mul(a: Complex, b: Complex): Complex {\r\n  return a.mul(b);\r\n}\r\n\r\n/**\r\n * Divide two complex numbers\r\n */\r\nexport function complex_div(a: Complex, b: Complex): Complex {\r\n  return a.div(b);\r\n}\r\n\r\n/**\r\n * Negate a complex number\r\n */\r\nexport function complex_neg(a: Complex): Complex {\r\n  return a.neg();\r\n}\r\n\r\n/**\r\n * Complex conjugate\r\n */\r\nexport function complex_conj(a: Complex): Complex {\r\n  return a.conj();\r\n}\r\n\r\n/**\r\n * Reciprocal (1/z)\r\n */\r\nexport function complex_reciprocal(a: Complex): Complex {\r\n  return a.reciprocal();\r\n}\r\n\r\n// =============================================================================\r\n// Magnitude and Phase\r\n// =============================================================================\r\n\r\n/**\r\n * Absolute value (magnitude)\r\n */\r\nexport function complex_abs(a: Complex): f64 {\r\n  return a.abs();\r\n}\r\n\r\n/**\r\n * Argument (phase angle)\r\n */\r\nexport function complex_arg(a: Complex): f64 {\r\n  return a.arg();\r\n}\r\n\r\n/**\r\n * Squared magnitude (faster than abs^2)\r\n */\r\nexport function complex_abs_squared(a: Complex): f64 {\r\n  return a.re * a.re + a.im * a.im;\r\n}\r\n\r\n// =============================================================================\r\n// Power and Root Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Square root of complex number\r\n */\r\nexport function complex_sqrt(a: Complex): Complex {\r\n  return a.sqrt();\r\n}\r\n\r\n/**\r\n * Complex power: a^n where n is real\r\n */\r\nexport function complex_pow(a: Complex, n: f64): Complex {\r\n  return a.powReal(n);\r\n}\r\n\r\n/**\r\n * Complex to complex power: a^b\r\n */\r\nexport function complex_cpow(a: Complex, b: Complex): Complex {\r\n  // a^b = Math.exp(b * Math.log(a))\r\n  const logA = a.log();\r\n  const product = new Complex(\r\n    b.re * logA.re - b.im * logA.im,\r\n    b.re * logA.im + b.im * logA.re\r\n  );\r\n  return product.exp();\r\n}\r\n\r\n/**\r\n * Square\r\n */\r\nexport function complex_square(a: Complex): Complex {\r\n  return new Complex(\r\n    a.re * a.re - a.im * a.im,\r\n    2.0 * a.re * a.im\r\n  );\r\n}\r\n\r\n/**\r\n * Cube\r\n */\r\nexport function complex_cube(a: Complex): Complex {\r\n  const re2 = a.re * a.re;\r\n  const im2 = a.im * a.im;\r\n  return new Complex(\r\n    a.re * (re2 - 3.0 * im2),\r\n    a.im * (3.0 * re2 - im2)\r\n  );\r\n}\r\n\r\n// =============================================================================\r\n// Exponential and Logarithmic\r\n// =============================================================================\r\n\r\n/**\r\n * Complex exponential\r\n */\r\nexport function complex_exp(a: Complex): Complex {\r\n  return a.exp();\r\n}\r\n\r\n/**\r\n * Complex natural logarithm\r\n */\r\nexport function complex_log(a: Complex): Complex {\r\n  return a.log();\r\n}\r\n\r\n/**\r\n * Complex base-10 logarithm\r\n */\r\nexport function complex_log10(a: Complex): Complex {\r\n  const ln = a.log();\r\n  const ln10 = 2.302585092994046;\r\n  return new Complex(ln.re / ln10, ln.im / ln10);\r\n}\r\n\r\n/**\r\n * Complex base-2 logarithm\r\n */\r\nexport function complex_log2(a: Complex): Complex {\r\n  const ln = a.log();\r\n  const ln2 = 0.6931471805599453;\r\n  return new Complex(ln.re / ln2, ln.im / ln2);\r\n}\r\n\r\n// =============================================================================\r\n// Trigonometric Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Complex sine\r\n */\r\nexport function complex_sin(a: Complex): Complex {\r\n  return a.sin();\r\n}\r\n\r\n/**\r\n * Complex cosine\r\n */\r\nexport function complex_cos(a: Complex): Complex {\r\n  return a.cos();\r\n}\r\n\r\n/**\r\n * Complex tangent\r\n */\r\nexport function complex_tan(a: Complex): Complex {\r\n  return a.tan();\r\n}\r\n\r\n/**\r\n * Complex arc sine\r\n */\r\nexport function complex_asin(a: Complex): Complex {\r\n  return a.asin();\r\n}\r\n\r\n/**\r\n * Complex arc cosine\r\n */\r\nexport function complex_acos(a: Complex): Complex {\r\n  return a.acos();\r\n}\r\n\r\n/**\r\n * Complex arc tangent\r\n */\r\nexport function complex_atan(a: Complex): Complex {\r\n  return a.atan();\r\n}\r\n\r\n// =============================================================================\r\n// Hyperbolic Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Complex hyperbolic sine\r\n */\r\nexport function complex_sinh(a: Complex): Complex {\r\n  return a.sinh();\r\n}\r\n\r\n/**\r\n * Complex hyperbolic cosine\r\n */\r\nexport function complex_cosh(a: Complex): Complex {\r\n  return a.cosh();\r\n}\r\n\r\n/**\r\n * Complex hyperbolic tangent\r\n */\r\nexport function complex_tanh(a: Complex): Complex {\r\n  return a.tanh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic sine\r\n */\r\nexport function complex_asinh(a: Complex): Complex {\r\n  return a.asinh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic cosine\r\n */\r\nexport function complex_acosh(a: Complex): Complex {\r\n  return a.acosh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic tangent\r\n */\r\nexport function complex_atanh(a: Complex): Complex {\r\n  return a.atanh();\r\n}\r\n\r\n// =============================================================================\r\n// Utility Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Check equality (exact)\r\n */\r\nexport function complex_equals(a: Complex, b: Complex): bool {\r\n  return a.equals(b);\r\n}\r\n\r\n/**\r\n * Check approximate equality\r\n */\r\nexport function complex_approx_equals(a: Complex, b: Complex, tolerance: f64): bool {\r\n  return a.approxEquals(b, tolerance);\r\n}\r\n\r\n/**\r\n * Check if complex number is zero\r\n */\r\nexport function complex_is_zero(a: Complex): bool {\r\n  return a.isZero();\r\n}\r\n\r\n/**\r\n * Check if complex number is real (imaginary part is zero)\r\n */\r\nexport function complex_is_real(a: Complex): bool {\r\n  return a.isReal();\r\n}\r\n\r\n/**\r\n * Check if complex number is purely imaginary\r\n */\r\nexport function complex_is_imaginary(a: Complex): bool {\r\n  return a.isImaginary();\r\n}\r\n\r\n/**\r\n * Check if complex number is NaN\r\n */\r\nexport function complex_is_nan(a: Complex): bool {\r\n  return isNaN(a.re) || isNaN(a.im);\r\n}\r\n\r\n/**\r\n * Check if complex number is finite\r\n */\r\nexport function complex_is_finite(a: Complex): bool {\r\n  return isFinite(a.re) && isFinite(a.im);\r\n}\r\n\r\n// =============================================================================\r\n// Construction Helpers\r\n// =============================================================================\r\n\r\n/**\r\n * Create complex from real part only\r\n */\r\nexport function complex_from_real(re: f64): Complex {\r\n  return new Complex(re, 0.0);\r\n}\r\n\r\n/**\r\n * Create complex from imaginary part only\r\n */\r\nexport function complex_from_imag(im: f64): Complex {\r\n  return new Complex(0.0, im);\r\n}\r\n\r\n/**\r\n * Create complex from polar coordinates\r\n */\r\nexport function complex_from_polar(r: f64, theta: f64): Complex {\r\n  return complexFromPolar(r, theta);\r\n}\r\n\r\n/**\r\n * Convert to polar: returns [r, theta]\r\n */\r\nexport function complex_to_polar(a: Complex): Float64Array {\r\n  const result = new Float64Array(2);\r\n  unchecked(result[0] = a.abs());\r\n  unchecked(result[1] = a.arg());\r\n  return result;\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Linear combination: alpha*a + beta*b\r\n */\r\nexport function complex_axpby(\r\n  alpha: Complex, a: Complex,\r\n  beta: Complex, b: Complex\r\n): Complex {\r\n  return alpha.mul(a).add(beta.mul(b));\r\n}\r\n\r\n/**\r\n * Euclidean distance between two complex numbers\r\n */\r\nexport function complex_distance(a: Complex, b: Complex): f64 {\r\n  const diff = a.sub(b);\r\n  return diff.abs();\r\n}\r\n","/**\r\n * Complex Array Operations for AssemblyScript\r\n *\r\n * Operations on arrays of complex numbers.\r\n * Complex arrays use interleaved storage: [re0, im0, re1, im1, ...]\r\n * A Float64Array of length 2n represents n complex numbers.\r\n */\r\n\r\nimport { Complex } from '../types/complex';\r\n\r\n// =============================================================================\r\n// Array Creation\r\n// =============================================================================\r\n\r\n/**\r\n * Create complex array of zeros\r\n * Returns array of length 2*n (interleaved)\r\n */\r\nexport function complex_array_zeros(n: i32): Float64Array {\r\n  return new Float64Array(n * 2);\r\n}\r\n\r\n/**\r\n * Create complex array of ones (1 + 0i)\r\n */\r\nexport function complex_array_ones(n: i32): Float64Array {\r\n  const data = new Float64Array(n * 2);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(data[i * 2] = 1.0);  // real part\r\n    // imaginary part is already 0\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create complex array with value (re + im*i)\r\n */\r\nexport function complex_array_fill(n: i32, re: f64, im: f64): Float64Array {\r\n  const data = new Float64Array(n * 2);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(data[i * 2] = re);\r\n    unchecked(data[i * 2 + 1] = im);\r\n  }\r\n  return data;\r\n}\r\n\r\n// =============================================================================\r\n// Element Access\r\n// =============================================================================\r\n\r\n/**\r\n * Get complex number at index (returns new Complex)\r\n */\r\nexport function complex_array_get(data: Float64Array, index: i32): Complex {\r\n  const re = unchecked(data[index * 2]);\r\n  const im = unchecked(data[index * 2 + 1]);\r\n  return new Complex(re, im);\r\n}\r\n\r\n/**\r\n * Set complex number at index\r\n */\r\nexport function complex_array_set(data: Float64Array, index: i32, value: Complex): void {\r\n  unchecked(data[index * 2] = value.re);\r\n  unchecked(data[index * 2 + 1] = value.im);\r\n}\r\n\r\n/**\r\n * Set complex number at index from components\r\n */\r\nexport function complex_array_set_parts(data: Float64Array, index: i32, re: f64, im: f64): void {\r\n  unchecked(data[index * 2] = re);\r\n  unchecked(data[index * 2 + 1] = im);\r\n}\r\n\r\n/**\r\n * Get real part at index\r\n */\r\nexport function complex_array_get_re(data: Float64Array, index: i32): f64 {\r\n  return unchecked(data[index * 2]);\r\n}\r\n\r\n/**\r\n * Get imaginary part at index\r\n */\r\nexport function complex_array_get_im(data: Float64Array, index: i32): f64 {\r\n  return unchecked(data[index * 2 + 1]);\r\n}\r\n\r\n/**\r\n * Get number of complex elements (array length / 2)\r\n */\r\nexport function complex_array_length(data: Float64Array): i32 {\r\n  return data.length / 2;\r\n}\r\n\r\n// =============================================================================\r\n// Element-wise Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Complex array addition: result = a + b\r\n */\r\nexport function complex_array_add(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array subtraction: result = a - b\r\n */\r\nexport function complex_array_sub(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) - unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array multiplication: result = a * b (element-wise)\r\n * (a + bi)(c + di) = (ac - bd) + (ad + bc)i\r\n */\r\nexport function complex_array_mul(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const n = min(min(a.length, b.length), result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = unchecked(b[idx + 1]);\r\n\r\n    unchecked(result[idx] = aRe * bRe - aIm * bIm);\r\n    unchecked(result[idx + 1] = aRe * bIm + aIm * bRe);\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array division: result = a / b (element-wise)\r\n */\r\nexport function complex_array_div(\r\n  a: Float64Array, b: Float64Array, result: Float64Array\r\n): void {\r\n  const n = min(min(a.length, b.length), result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = unchecked(b[idx + 1]);\r\n\r\n    const denom = bRe * bRe + bIm * bIm;\r\n    unchecked(result[idx] = (aRe * bRe + aIm * bIm) / denom);\r\n    unchecked(result[idx + 1] = (aIm * bRe - aRe * bIm) / denom);\r\n  }\r\n}\r\n\r\n/**\r\n * Scale complex array by real scalar: result = a * scalar\r\n */\r\nexport function complex_array_scale_real(\r\n  a: Float64Array, scalar: f64, result: Float64Array\r\n): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = unchecked(a[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Scale complex array by complex scalar: result = a * (re + im*i)\r\n */\r\nexport function complex_array_scale_complex(\r\n  a: Float64Array, re: f64, im: f64, result: Float64Array\r\n): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n\r\n    unchecked(result[idx] = aRe * re - aIm * im);\r\n    unchecked(result[idx + 1] = aRe * im + aIm * re);\r\n  }\r\n}\r\n\r\n/**\r\n * Negate complex array: result = -a\r\n */\r\nexport function complex_array_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(result[i] = -unchecked(a[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex conjugate array: result = conj(a)\r\n */\r\nexport function complex_array_conj(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    unchecked(result[idx] = unchecked(a[idx]));        // real unchanged\r\n    unchecked(result[idx + 1] = -unchecked(a[idx + 1])); // negate imaginary\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Element-wise Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Magnitude (absolute value) of each element: result[i] = |a[i]|\r\n */\r\nexport function complex_array_abs(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked(result[i] = sqrt(re * re + im * im));\r\n  }\r\n}\r\n\r\n/**\r\n * Phase (argument) of each element: result[i] = arg(a[i])\r\n */\r\nexport function complex_array_arg(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked(result[i] = Math.atan2(im, re));\r\n  }\r\n}\r\n\r\n/**\r\n * Square of magnitude: result[i] = |a[i]|^2\r\n */\r\nexport function complex_array_abs_squared(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked(result[i] = re * re + im * im);\r\n  }\r\n}\r\n\r\n/**\r\n * Extract real parts\r\n */\r\nexport function complex_array_real(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length / 2, result.length);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(result[i] = unchecked(a[i * 2]));\r\n  }\r\n}\r\n\r\n/**\r\n * Extract imaginary parts\r\n */\r\nexport function complex_array_imag(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length / 2, result.length);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(result[i] = unchecked(a[i * 2 + 1]));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex exponential: result = Math.exp(a)\r\n */\r\nexport function complex_array_exp(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    const expRe = Math.exp(re);\r\n    unchecked(result[idx] = expRe * Math.cos(im));\r\n    unchecked(result[idx + 1] = expRe * Math.sin(im));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex natural log: result = Math.log(a)\r\n */\r\nexport function complex_array_log(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    unchecked(result[idx] = Math.log(sqrt(re * re + im * im)));\r\n    unchecked(result[idx + 1] = Math.atan2(im, re));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex square root: result = sqrt(a)\r\n */\r\nexport function complex_array_sqrt(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    const r = sqrt(re * re + im * im);\r\n    const sqrtR = sqrt(r);\r\n    const halfTheta = Math.atan2(im, re) / 2.0;\r\n\r\n    unchecked(result[idx] = sqrtR * Math.cos(halfTheta));\r\n    unchecked(result[idx + 1] = sqrtR * Math.sin(halfTheta));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Reductions\r\n// =============================================================================\r\n\r\n/**\r\n * Sum of complex array\r\n */\r\nexport function complex_array_sum(a: Float64Array): Complex {\r\n  let sumRe: f64 = 0.0;\r\n  let sumIm: f64 = 0.0;\r\n  const n = a.length / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    sumRe += unchecked(a[i * 2]);\r\n    sumIm += unchecked(a[i * 2 + 1]);\r\n  }\r\n\r\n  return new Complex(sumRe, sumIm);\r\n}\r\n\r\n/**\r\n * Mean of complex array\r\n */\r\nexport function complex_array_mean(a: Float64Array): Complex {\r\n  const n = a.length / 2;\r\n  if (n == 0) return new Complex(f64.NaN, f64.NaN);\r\n\r\n  const sum = complex_array_sum(a);\r\n  return new Complex(sum.re / f64(n), sum.im / f64(n));\r\n}\r\n\r\n/**\r\n * Dot product of two complex arrays: sum(a[i] * conj(b[i]))\r\n */\r\nexport function complex_array_dot(a: Float64Array, b: Float64Array): Complex {\r\n  let sumRe: f64 = 0.0;\r\n  let sumIm: f64 = 0.0;\r\n  const n = min(a.length, b.length) / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = -unchecked(b[idx + 1]); // conjugate of b\r\n\r\n    sumRe += aRe * bRe - aIm * bIm;\r\n    sumIm += aRe * bIm + aIm * bRe;\r\n  }\r\n\r\n  return new Complex(sumRe, sumIm);\r\n}\r\n\r\n/**\r\n * L2 norm of complex array: sqrt(sum(|a[i]|^2))\r\n */\r\nexport function complex_array_norm(a: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const n = a.length / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    sumSq += re * re + im * im;\r\n  }\r\n\r\n  return sqrt(sumSq);\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Scale in place: a *= scalar (real)\r\n */\r\nexport function complex_array_scale_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) * scalar);\r\n  }\r\n}\r\n\r\n/**\r\n * Conjugate in place\r\n */\r\nexport function complex_array_conj_inplace(a: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked(a[i * 2 + 1] = -unchecked(a[i * 2 + 1]));\r\n  }\r\n}\r\n\r\n/**\r\n * Add in place: a += b\r\n */\r\nexport function complex_array_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(a[i] = unchecked(a[i]) + unchecked(b[i]));\r\n  }\r\n}\r\n\r\n/**\r\n * Copy complex array\r\n */\r\nexport function complex_array_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked(dst[i] = unchecked(src[i]));\r\n  }\r\n}\r\n"]}
+{"version":3,"sources":["~lib/rt/common.ts","src/types/complex.ts","~lib/rt/stub.ts","~lib/util/error.ts","src/ops/scalar.ts","src/ops/svd.ts","src/algebra/decomposition.ts","src/ops/special.ts","src/ops/number-theory.ts","src/special.ts","~lib/util/math.ts","~lib/util/number.ts","~lib/util/string.ts","~lib/math.ts","~lib/builtins.ts","src/ops/array.ts","~lib/util/sort.ts","~lib/shared/runtime.ts","~lib/typedarray.ts","~lib/arraybuffer.ts","src/ops/matrix.ts","src/ops/polynomial.ts","~lib/array.ts","~lib/shared/typeinfo.ts","~lib/rt.ts","src/ops/signal.ts","src/signal.ts","src/ops/linalg.ts","src/ops/curvefit.ts","src/ops/optimization.ts","src/ops/approx.ts","src/ops/tensor.ts","src/ops/complex-ops.ts","src/ops/bitwise.ts","src/poly.ts","src/tridiag.ts","src/sort.ts","src/ops/complex-array.ts"],"names":[],"mappings":"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","sourceRoot":"./mathts-debug","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                           MM info                             │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class BLOCK {\n  /** Memory manager info. */\n  mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof<BLOCK>();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │                     Memory manager block                      │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │                            GC info                            │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │                            GC info                            │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT id                              │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │                            RT size                            │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │                              ...                              │\n@unmanaged export class OBJECT extends BLOCK {\n  /** Garbage collector info. */\n  gcInfo: u32;\n  /** Garbage collector info. */\n  gcInfo2: u32;\n  /** Runtime class id. */\n  rtId: u32;\n  /** Runtime object size. */\n  rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof<OBJECT>() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","/**\r\n * AssemblyScript-compatible Complex Number Implementation\r\n *\r\n * This is a simplified Complex number class designed for AssemblyScript\r\n * compilation. It avoids:\r\n * - Optional parameters (use overloaded functions instead)\r\n * - Regex parsing (use factory functions)\r\n * - Closures\r\n * - Dynamic types\r\n */\r\n\r\n/**\r\n * Complex number represented as (re + im*i)\r\n */\r\n@final\r\nexport class Complex {\r\n  /** Real part */\r\n  re: f64;\r\n  /** Imaginary part */\r\n  im: f64;\r\n\r\n  constructor(re: f64, im: f64) {\r\n    this.re = re;\r\n    this.im = im;\r\n  }\r\n\r\n  /**\r\n   * Create a copy of this complex number\r\n   */\r\n  clone(): Complex {\r\n    return new Complex(this.re, this.im);\r\n  }\r\n\r\n  /**\r\n   * Check equality with another complex number\r\n   */\r\n  equals(other: Complex): bool {\r\n    return this.re == other.re && this.im == other.im;\r\n  }\r\n\r\n  /**\r\n   * Check approximate equality (within epsilon)\r\n   */\r\n  approxEquals(other: Complex, epsilon: f64 = 1e-12): bool {\r\n    const diffRe = this.re - other.re;\r\n    const diffIm = this.im - other.im;\r\n    return abs(diffRe) < epsilon && abs(diffIm) < epsilon;\r\n  }\r\n\r\n  // =========================================================================\r\n  // Arithmetic Operations\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Add another complex number\r\n   */\r\n  add(other: Complex): Complex {\r\n    return new Complex(this.re + other.re, this.im + other.im);\r\n  }\r\n\r\n  /**\r\n   * Add a real number\r\n   */\r\n  addReal(value: f64): Complex {\r\n    return new Complex(this.re + value, this.im);\r\n  }\r\n\r\n  /**\r\n   * Subtract another complex number\r\n   */\r\n  sub(other: Complex): Complex {\r\n    return new Complex(this.re - other.re, this.im - other.im);\r\n  }\r\n\r\n  /**\r\n   * Subtract a real number\r\n   */\r\n  subReal(value: f64): Complex {\r\n    return new Complex(this.re - value, this.im);\r\n  }\r\n\r\n  /**\r\n   * Multiply by another complex number\r\n   * (a + bi)(c + di) = (ac - bd) + (ad + bc)i\r\n   */\r\n  mul(other: Complex): Complex {\r\n    return new Complex(\r\n      this.re * other.re - this.im * other.im,\r\n      this.re * other.im + this.im * other.re\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Multiply by a real number\r\n   */\r\n  mulReal(value: f64): Complex {\r\n    return new Complex(this.re * value, this.im * value);\r\n  }\r\n\r\n  /**\r\n   * Divide by another complex number\r\n   * (a + bi) / (c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)\r\n   */\r\n  div(other: Complex): Complex {\r\n    const denom = other.re * other.re + other.im * other.im;\r\n    if (denom == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(\r\n      (this.re * other.re + this.im * other.im) / denom,\r\n      (this.im * other.re - this.re * other.im) / denom\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Divide by a real number\r\n   */\r\n  divReal(value: f64): Complex {\r\n    if (value == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(this.re / value, this.im / value);\r\n  }\r\n\r\n  /**\r\n   * Negate the complex number\r\n   */\r\n  neg(): Complex {\r\n    return new Complex(-this.re, -this.im);\r\n  }\r\n\r\n  /**\r\n   * Complex conjugate\r\n   */\r\n  conj(): Complex {\r\n    return new Complex(this.re, -this.im);\r\n  }\r\n\r\n  /**\r\n   * Reciprocal (1/z)\r\n   */\r\n  reciprocal(): Complex {\r\n    const denom = this.re * this.re + this.im * this.im;\r\n    if (denom == 0.0) {\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return new Complex(this.re / denom, -this.im / denom);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Magnitude and Phase\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Absolute value (magnitude)\r\n   * |z| = sqrt(re² + im²)\r\n   */\r\n  abs(): f64 {\r\n    return sqrt(this.re * this.re + this.im * this.im);\r\n  }\r\n\r\n  /**\r\n   * Squared magnitude (avoids sqrt for comparisons)\r\n   */\r\n  abs2(): f64 {\r\n    return this.re * this.re + this.im * this.im;\r\n  }\r\n\r\n  /**\r\n   * Argument (phase angle in radians)\r\n   * arg(z) = Math.atan2(im, re)\r\n   */\r\n  arg(): f64 {\r\n    return Math.atan2(this.im, this.re);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Exponential and Logarithmic\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex exponential\r\n   * Math.exp(a + bi) = Math.exp(a) * (Math.cos(b) + i*Math.sin(b))\r\n   */\r\n  exp(): Complex {\r\n    const expRe = Math.exp(this.re);\r\n    return new Complex(expRe * Math.cos(this.im), expRe * Math.sin(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex natural logarithm (principal value)\r\n   * Math.log(z) = log|z| + i*arg(z)\r\n   */\r\n  log(): Complex {\r\n    return new Complex(Math.log(this.abs()), this.arg());\r\n  }\r\n\r\n  /**\r\n   * Complex square root (principal value)\r\n   */\r\n  sqrt(): Complex {\r\n    const r = this.abs();\r\n    const halfArg = this.arg() / 2.0;\r\n    const sqrtR = sqrt(r);\r\n    return new Complex(sqrtR * Math.cos(halfArg), sqrtR * Math.sin(halfArg));\r\n  }\r\n\r\n  /**\r\n   * Complex power (z^n where n is real)\r\n   */\r\n  powReal(n: f64): Complex {\r\n    if (n == 0.0) {\r\n      return new Complex(1.0, 0.0);\r\n    }\r\n    const r = this.abs();\r\n    const theta = this.arg();\r\n    const rn = Math.pow(r, n);\r\n    const nTheta = n * theta;\r\n    return new Complex(rn * Math.cos(nTheta), rn * Math.sin(nTheta));\r\n  }\r\n\r\n  /**\r\n   * Complex power (z^w where w is complex)\r\n   * z^w = Math.exp(w * Math.log(z))\r\n   */\r\n  pow(w: Complex): Complex {\r\n    if (this.re == 0.0 && this.im == 0.0) {\r\n      if (w.re > 0.0) {\r\n        return new Complex(0.0, 0.0);\r\n      }\r\n      return new Complex(f64.NaN, f64.NaN);\r\n    }\r\n    return w.mul(this.log()).exp();\r\n  }\r\n\r\n  // =========================================================================\r\n  // Trigonometric Functions\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex sine\r\n   * Math.sin(z) = (Math.exp(iz) - Math.exp(-iz)) / 2i\r\n   */\r\n  sin(): Complex {\r\n    return new Complex(Math.sin(this.re) * cosh(this.im), Math.cos(this.re) * sinh(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex cosine\r\n   * Math.cos(z) = (Math.exp(iz) + Math.exp(-iz)) / 2\r\n   */\r\n  cos(): Complex {\r\n    return new Complex(Math.cos(this.re) * cosh(this.im), -Math.sin(this.re) * sinh(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex tangent\r\n   * Math.tan(z) = Math.sin(z) / Math.cos(z)\r\n   */\r\n  tan(): Complex {\r\n    return this.sin().div(this.cos());\r\n  }\r\n\r\n  // =========================================================================\r\n  // Hyperbolic Functions\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Complex hyperbolic sine\r\n   */\r\n  sinh(): Complex {\r\n    return new Complex(sinh(this.re) * Math.cos(this.im), cosh(this.re) * Math.sin(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex hyperbolic cosine\r\n   */\r\n  cosh(): Complex {\r\n    return new Complex(cosh(this.re) * Math.cos(this.im), sinh(this.re) * Math.sin(this.im));\r\n  }\r\n\r\n  /**\r\n   * Complex hyperbolic tangent\r\n   */\r\n  tanh(): Complex {\r\n    return this.sinh().div(this.cosh());\r\n  }\r\n\r\n  /**\r\n   * Complex inverse sine: asin(z) = -i * ln(iz + sqrt(1 - z²))\r\n   */\r\n  asin(): Complex {\r\n    const iz = new Complex(-this.im, this.re);\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(1.0 - z2.re, -z2.im).sqrt();\r\n    const logArg = iz.add(inner);\r\n    const ln = logArg.log();\r\n    return new Complex(ln.im, -ln.re);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse cosine: acos(z) = -i * ln(z + sqrt(z² - 1))\r\n   */\r\n  acos(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re - 1.0, z2.im).sqrt();\r\n    const logArg = this.add(inner);\r\n    const ln = logArg.log();\r\n    return new Complex(ln.im, -ln.re);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse tangent: atan(z) = (i/2) * ln((i+z)/(i-z))\r\n   */\r\n  atan(): Complex {\r\n    const iPlusZ = new Complex(this.re, this.im + 1.0);\r\n    const iMinusZ = new Complex(-this.re, 1.0 - this.im);\r\n    const ratio = iPlusZ.div(iMinusZ);\r\n    const ln = ratio.log();\r\n    return new Complex(-ln.im * 0.5, ln.re * 0.5);\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic sine: asinh(z) = ln(z + sqrt(z² + 1))\r\n   */\r\n  asinh(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re + 1.0, z2.im).sqrt();\r\n    return this.add(inner).log();\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic cosine: acosh(z) = ln(z + sqrt(z² - 1))\r\n   */\r\n  acosh(): Complex {\r\n    const z2 = this.mul(this);\r\n    const inner = new Complex(z2.re - 1.0, z2.im).sqrt();\r\n    return this.add(inner).log();\r\n  }\r\n\r\n  /**\r\n   * Complex inverse hyperbolic tangent: atanh(z) = 0.5 * ln((1+z)/(1-z))\r\n   */\r\n  atanh(): Complex {\r\n    const onePlusZ = new Complex(1.0 + this.re, this.im);\r\n    const oneMinusZ = new Complex(1.0 - this.re, -this.im);\r\n    const ln = onePlusZ.div(oneMinusZ).log();\r\n    return new Complex(ln.re * 0.5, ln.im * 0.5);\r\n  }\r\n\r\n  // =========================================================================\r\n  // Query Methods\r\n  // =========================================================================\r\n\r\n  /**\r\n   * Check if this is a real number (imaginary part is zero)\r\n   */\r\n  isReal(): bool {\r\n    return this.im == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is purely imaginary (real part is zero)\r\n   */\r\n  isImaginary(): bool {\r\n    return this.re == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is zero\r\n   */\r\n  isZero(): bool {\r\n    return this.re == 0.0 && this.im == 0.0;\r\n  }\r\n\r\n  /**\r\n   * Check if this is NaN\r\n   */\r\n  isNaN(): bool {\r\n    return isNaN(this.re) || isNaN(this.im);\r\n  }\r\n\r\n  /**\r\n   * Check if this is finite\r\n   */\r\n  isFinite(): bool {\r\n    return isFinite(this.re) && isFinite(this.im);\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Factory Functions (avoid constructor overloading)\r\n// =============================================================================\r\n\r\n/**\r\n * Create a complex number from real and imaginary parts\r\n */\r\nexport function complex(re: f64, im: f64): Complex {\r\n  return new Complex(re, im);\r\n}\r\n\r\n/**\r\n * Create a complex number from polar coordinates (r, theta)\r\n */\r\nexport function complexFromPolar(r: f64, theta: f64): Complex {\r\n  return new Complex(r * Math.cos(theta), r * Math.sin(theta));\r\n}\r\n\r\n/**\r\n * Create a complex number from a real value (im = 0)\r\n */\r\nexport function complexFromReal(value: f64): Complex {\r\n  return new Complex(value, 0.0);\r\n}\r\n\r\n/**\r\n * Create a complex number from an imaginary value (re = 0)\r\n */\r\nexport function complexFromImaginary(value: f64): Complex {\r\n  return new Complex(0.0, value);\r\n}\r\n\r\n// =============================================================================\r\n// Constants\r\n// =============================================================================\r\n\r\n/** Complex zero */\r\nexport const COMPLEX_ZERO: Complex = new Complex(0.0, 0.0);\r\n\r\n/** Complex one */\r\nexport const COMPLEX_ONE: Complex = new Complex(1.0, 0.0);\r\n\r\n/** Complex imaginary unit i */\r\nexport const COMPLEX_I: Complex = new Complex(0.0, 1.0);\r\n\r\n/** Complex negative one */\r\nexport const COMPLEX_NEG_ONE: Complex = new Complex(-1.0, 0.0);\r\n\r\n// =============================================================================\r\n// Math helpers (AS doesn't have Math.sinh, Math.cosh by default in older versions)\r\n// =============================================================================\r\n\r\nfunction sinh(x: f64): f64 {\r\n  const ex = Math.exp(x);\r\n  return (ex - 1.0 / ex) / 2.0;\r\n}\r\n\r\nfunction cosh(x: f64): f64 {\r\n  const ex = Math.exp(x);\r\n  return (ex + 1.0 / ex) / 2.0;\r\n}\r\n","import { AL_MASK, OBJECT, OBJECT_OVERHEAD, BLOCK_MAXSIZE, BLOCK_OVERHEAD, BLOCK, OBJECT_MAXSIZE } from \"./common\";\nimport { E_ALLOCATION_TOO_LARGE } from \"../util/error\";\n\n// === A minimal runtime stub ===\n\n// @ts-ignore: decorator\n@lazy let startOffset: usize = ((__heap_base + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n// @ts-ignore: decorator\n@lazy let offset: usize = startOffset;\n\nfunction maybeGrowMemory(newOffset: usize): void {\n  // assumes newOffset is aligned\n  let pagesBefore = memory.size();\n  let maxOffset = ((<usize>pagesBefore << 16) + AL_MASK) & ~AL_MASK;\n  if (newOffset > maxOffset) {\n    let pagesNeeded = <i32>(((newOffset - maxOffset + 0xffff) & ~0xffff) >>> 16);\n    let pagesWanted = max(pagesBefore, pagesNeeded); // double memory\n    if (memory.grow(pagesWanted) < 0) {\n      if (memory.grow(pagesNeeded) < 0) unreachable(); // out of memory\n    }\n  }\n  offset = newOffset;\n}\n\n// @ts-ignore: decorator\n@inline function computeSize(size: usize): usize {\n  return ((size + BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK) - BLOCK_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __alloc(size: usize): usize {\n  if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let block = changetype<BLOCK>(offset);\n  let ptr = offset + BLOCK_OVERHEAD;\n  let payloadSize = computeSize(size);\n  maybeGrowMemory(ptr + payloadSize);\n  block.mmInfo = payloadSize;\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __realloc(ptr: usize, size: usize): usize {\n  assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n  let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n  let actualSize = block.mmInfo;\n  let isLast = ptr + actualSize == offset;\n  let payloadSize = computeSize(size);\n  if (size > actualSize) {\n    if (isLast) { // last block: grow\n      if (size > BLOCK_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n      maybeGrowMemory(ptr + payloadSize);\n      block.mmInfo = payloadSize;\n    } else { // copy to new block at least double the size\n      let newPtr = __alloc(max<usize>(payloadSize, actualSize << 1));\n      memory.copy(newPtr, ptr, actualSize);\n      block = changetype<BLOCK>((ptr = newPtr) - BLOCK_OVERHEAD);\n    }\n  } else if (isLast) { // last block: shrink\n    offset = ptr + payloadSize;\n    block.mmInfo = payloadSize;\n  }\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __free(ptr: usize): void {\n  assert(ptr != 0 && !(ptr & AL_MASK)); // must exist and be aligned\n  let block = changetype<BLOCK>(ptr - BLOCK_OVERHEAD);\n  if (ptr + block.mmInfo == offset) { // last block: discard\n    offset = changetype<usize>(block);\n  }\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __reset(): void { // special\n  offset = startOffset;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __new(size: usize, id: u32): usize {\n  if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let ptr = __alloc(OBJECT_OVERHEAD + size);\n  let object = changetype<OBJECT>(ptr - BLOCK_OVERHEAD);\n  object.gcInfo = 0;\n  object.gcInfo2 = 0;\n  object.rtId = id;\n  object.rtSize = <u32>size;\n  return ptr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@unsafe @global\nexport function __renew(oldPtr: usize, size: usize): usize {\n  if (size > OBJECT_MAXSIZE) throw new Error(E_ALLOCATION_TOO_LARGE);\n  let newPtr = __realloc(oldPtr - OBJECT_OVERHEAD, OBJECT_OVERHEAD + size);\n  changetype<OBJECT>(newPtr - BLOCK_OVERHEAD).rtSize = <u32>size;\n  return newPtr + OBJECT_OVERHEAD;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void {\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __pin(ptr: usize): usize {\n  return ptr;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __unpin(ptr: usize): void {\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __visit(ptr: usize, cookie: u32): void { // eslint-disable-line @typescript-eslint/no-unused-vars\n  // nop\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nexport function __collect(): void {\n  // nop\n}\n","// Common error messages for use across the standard library. Keeping error messages compact\n// and reusing them where possible ensures minimal static data in binaries.\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INDEXOUTOFRANGE: string = \"Index out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_VALUEOUTOFRANGE: string = \"Value out of range\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDLENGTH: string = \"Invalid length\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_EMPTYARRAY: string = \"Array is empty\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_HOLEYARRAY: string = \"Element type must be nullable if array is holey\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOTIMPLEMENTED: string = \"Not implemented\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_KEYNOTFOUND: string = \"Key does not exist\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALLOCATION_TOO_LARGE: string = \"Allocation too large\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_ALREADY_PINNED: string = \"Object already pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_NOT_PINNED: string = \"Object is not pinned\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_URI_MALFORMED: string = \"URI malformed\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_INVALIDDATE: string = \"Invalid Date\";\n\n// @ts-ignore: decorator\n@lazy @inline\nexport const E_UNPAIRED_SURROGATE: string = \"Unpaired surrogate\";\n","/**\r\n * Scalar Operations for AssemblyScript\r\n *\r\n * Basic numeric operations exported for WASM.\r\n * These wrap the built-in AssemblyScript math functions with\r\n * consistent naming and behavior.\r\n */\r\n\r\n// =============================================================================\r\n// Basic Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Add two f64 values\r\n */\r\nexport function add_f64(a: f64, b: f64): f64 {\r\n  return a + b;\r\n}\r\n\r\n/**\r\n * Subtract two f64 values\r\n */\r\nexport function sub_f64(a: f64, b: f64): f64 {\r\n  return a - b;\r\n}\r\n\r\n/**\r\n * Multiply two f64 values\r\n */\r\nexport function mul_f64(a: f64, b: f64): f64 {\r\n  return a * b;\r\n}\r\n\r\n/**\r\n * Divide two f64 values\r\n */\r\nexport function div_f64(a: f64, b: f64): f64 {\r\n  return a / b;\r\n}\r\n\r\n/**\r\n * Modulo operation\r\n */\r\nexport function mod_f64(a: f64, b: f64): f64 {\r\n  return a % b;\r\n}\r\n\r\n/**\r\n * Negation\r\n */\r\nexport function neg_f64(a: f64): f64 {\r\n  return -a;\r\n}\r\n\r\n// =============================================================================\r\n// Power and Roots\r\n// =============================================================================\r\n\r\n/**\r\n * Square root\r\n */\r\nexport function sqrt_f64(a: f64): f64 {\r\n  return sqrt(a);\r\n}\r\n\r\n/**\r\n * Power (a^b)\r\n */\r\nexport function pow_f64(a: f64, b: f64): f64 {\r\n  return Math.pow(a, b);\r\n}\r\n\r\n/**\r\n * Square\r\n */\r\nexport function square_f64(a: f64): f64 {\r\n  return a * a;\r\n}\r\n\r\n/**\r\n * Cube\r\n */\r\nexport function cube_f64(a: f64): f64 {\r\n  return a * a * a;\r\n}\r\n\r\n/**\r\n * Cube root\r\n */\r\nexport function cbrt_f64(a: f64): f64 {\r\n  if (a >= 0) {\r\n    return Math.pow(a, 1.0 / 3.0);\r\n  }\r\n  return -Math.pow(-a, 1.0 / 3.0);\r\n}\r\n\r\n/**\r\n * N-th root\r\n */\r\nexport function nthRoot_f64(a: f64, n: f64): f64 {\r\n  if (n == 0.0) return f64.NaN;\r\n  if (a >= 0) {\r\n    return Math.pow(a, 1.0 / n);\r\n  }\r\n  // For negative bases, only odd integer roots are real\r\n  const nInt = i64(n);\r\n  if (f64(nInt) == n && (nInt & 1) == 1) {\r\n    return -Math.pow(-a, 1.0 / n);\r\n  }\r\n  return f64.NaN;\r\n}\r\n\r\n// =============================================================================\r\n// Exponential and Logarithmic\r\n// =============================================================================\r\n\r\n/**\r\n * Natural exponential (e^x)\r\n */\r\nexport function exp_f64(a: f64): f64 {\r\n  return Math.exp(a);\r\n}\r\n\r\n/**\r\n * e^x - 1 (more accurate for small x)\r\n */\r\nexport function expm1_f64(a: f64): f64 {\r\n  return Math.expm1(a);\r\n}\r\n\r\n/**\r\n * Natural logarithm\r\n */\r\nexport function log_f64(a: f64): f64 {\r\n  return Math.log(a);\r\n}\r\n\r\n/**\r\n * Math.log(1 + x) (more accurate for small x)\r\n */\r\nexport function log1p_f64(a: f64): f64 {\r\n  return Math.log1p(a);\r\n}\r\n\r\n/**\r\n * Base-10 logarithm\r\n */\r\nexport function log10_f64(a: f64): f64 {\r\n  return Math.log10(a);\r\n}\r\n\r\n/**\r\n * Base-2 logarithm\r\n */\r\nexport function log2_f64(a: f64): f64 {\r\n  return Math.log2(a);\r\n}\r\n\r\n// =============================================================================\r\n// Trigonometric Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Sine\r\n */\r\nexport function sin_f64(a: f64): f64 {\r\n  return Math.sin(a);\r\n}\r\n\r\n/**\r\n * Cosine\r\n */\r\nexport function cos_f64(a: f64): f64 {\r\n  return Math.cos(a);\r\n}\r\n\r\n/**\r\n * Tangent\r\n */\r\nexport function tan_f64(a: f64): f64 {\r\n  return Math.tan(a);\r\n}\r\n\r\n/**\r\n * Arc sine\r\n */\r\nexport function asin_f64(a: f64): f64 {\r\n  return Math.asin(a);\r\n}\r\n\r\n/**\r\n * Arc cosine\r\n */\r\nexport function acos_f64(a: f64): f64 {\r\n  return Math.acos(a);\r\n}\r\n\r\n/**\r\n * Arc tangent\r\n */\r\nexport function atan_f64(a: f64): f64 {\r\n  return Math.atan(a);\r\n}\r\n\r\n/**\r\n * Two-argument arc tangent\r\n */\r\nexport function atan2_f64(y: f64, x: f64): f64 {\r\n  return Math.atan2(y, x);\r\n}\r\n\r\n// =============================================================================\r\n// Hyperbolic Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Hyperbolic sine\r\n */\r\nexport function sinh_f64(a: f64): f64 {\r\n  const ex = Math.exp(a);\r\n  return (ex - 1.0 / ex) / 2.0;\r\n}\r\n\r\n/**\r\n * Hyperbolic cosine\r\n */\r\nexport function cosh_f64(a: f64): f64 {\r\n  const ex = Math.exp(a);\r\n  return (ex + 1.0 / ex) / 2.0;\r\n}\r\n\r\n/**\r\n * Hyperbolic tangent\r\n */\r\nexport function tanh_f64(a: f64): f64 {\r\n  const ex = Math.exp(2.0 * a);\r\n  return (ex - 1.0) / (ex + 1.0);\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic sine\r\n */\r\nexport function asinh_f64(a: f64): f64 {\r\n  return Math.log(a + sqrt(a * a + 1.0));\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic cosine\r\n */\r\nexport function acosh_f64(a: f64): f64 {\r\n  return Math.log(a + sqrt(a * a - 1.0));\r\n}\r\n\r\n/**\r\n * Inverse hyperbolic tangent\r\n */\r\nexport function atanh_f64(a: f64): f64 {\r\n  return 0.5 * Math.log((1.0 + a) / (1.0 - a));\r\n}\r\n\r\n// =============================================================================\r\n// Rounding and Comparison\r\n// =============================================================================\r\n\r\n/**\r\n * Absolute value\r\n */\r\nexport function abs_f64(a: f64): f64 {\r\n  return abs(a);\r\n}\r\n\r\n/**\r\n * Floor\r\n */\r\nexport function floor_f64(a: f64): f64 {\r\n  return floor(a);\r\n}\r\n\r\n/**\r\n * Ceiling\r\n */\r\nexport function ceil_f64(a: f64): f64 {\r\n  return ceil(a);\r\n}\r\n\r\n/**\r\n * Round to nearest\r\n */\r\nexport function round_f64(a: f64): f64 {\r\n  return nearest(a);\r\n}\r\n\r\n/**\r\n * Truncate (round toward zero)\r\n */\r\nexport function trunc_f64(a: f64): f64 {\r\n  return trunc(a);\r\n}\r\n\r\n/**\r\n * Sign function (-1, 0, or 1)\r\n */\r\nexport function sign_f64(a: f64): f64 {\r\n  if (a > 0.0) return 1.0;\r\n  if (a < 0.0) return -1.0;\r\n  return 0.0;\r\n}\r\n\r\n/**\r\n * Minimum of two values\r\n */\r\nexport function min_f64(a: f64, b: f64): f64 {\r\n  return min(a, b);\r\n}\r\n\r\n/**\r\n * Maximum of two values\r\n */\r\nexport function max_f64(a: f64, b: f64): f64 {\r\n  return max(a, b);\r\n}\r\n\r\n/**\r\n * Clamp value to range [lo, hi]\r\n */\r\nexport function clamp_f64(value: f64, lo: f64, hi: f64): f64 {\r\n  return max(lo, min(hi, value));\r\n}\r\n\r\n// =============================================================================\r\n// Special Values\r\n// =============================================================================\r\n\r\n/**\r\n * Check if value is NaN\r\n */\r\nexport function isNaN_f64(a: f64): bool {\r\n  return isNaN(a);\r\n}\r\n\r\n/**\r\n * Check if value is finite\r\n */\r\nexport function isFinite_f64(a: f64): bool {\r\n  return isFinite(a);\r\n}\r\n\r\n// =============================================================================\r\n// Constants\r\n// =============================================================================\r\n\r\n/** Mathematical constant pi */\r\nexport const PI: f64 = 3.141592653589793;\r\n\r\n/** Mathematical constant e */\r\nexport const E: f64 = 2.718281828459045;\r\n\r\n/** Golden ratio phi */\r\nexport const PHI: f64 = 1.618033988749895;\r\n\r\n/** Square root of 2 */\r\nexport const SQRT2: f64 = 1.4142135623730951;\r\n\r\n/** Square root of 1/2 */\r\nexport const SQRT1_2: f64 = 0.7071067811865476;\r\n\r\n/** Natural log of 2 */\r\nexport const LN2: f64 = 0.6931471805599453;\r\n\r\n/** Natural log of 10 */\r\nexport const LN10: f64 = 2.302585092994046;\r\n\r\n/** Log base 2 of e */\r\nexport const LOG2E: f64 = 1.4426950408889634;\r\n\r\n/** Log base 10 of e */\r\nexport const LOG10E: f64 = 0.4342944819032518;\r\n\r\n/** Machine epsilon for f64 */\r\nexport const EPSILON: f64 = 2.220446049250313e-16;\r\n","/**\r\n * Singular Value Decomposition via the one-sided Jacobi algorithm.\r\n *\r\n * AssemblyScript fallback mirroring the Rust implementation in\r\n * `wasm-rust/crates/mathts-wasm/src/matrix/svd.rs`. One-sided Jacobi is\r\n * compact, allocation-light, numerically robust, and needs no\r\n * bidiagonalization — it works for any real m x n matrix.\r\n */\r\n\r\nconst SVD_MAX_SWEEPS: i32 = 60;\r\nconst SVD_EPS: f64 = 1e-15;\r\n\r\n/**\r\n * Thin (economy) SVD of a row-major `m x n` matrix `A`.\r\n *\r\n * Returns a packed `Float64Array` `[ U (m*k) | S (k) | V (n*k) ]` with\r\n * `k = min(m, n)`, such that `A = U * diag(S) * V^T`. `S` is sorted\r\n * descending. The caller slices the result using known `m`, `n`, `k`.\r\n */\r\nexport function matrix_svd(a: Float64Array, m: i32, n: i32): Float64Array {\r\n  const k: i32 = m < n ? m : n;\r\n  const out = new Float64Array(m * k + k + n * k);\r\n  if (m <= 0 || n <= 0) return out;\r\n  svdCore(a, m, n, out, 0, m * k, m * k + k);\r\n  return out;\r\n}\r\n\r\n/**\r\n * Singular values only — a `Float64Array` of length `min(m, n)`, descending.\r\n */\r\nexport function matrix_singular_values(a: Float64Array, m: i32, n: i32): Float64Array {\r\n  const k: i32 = m < n ? m : n;\r\n  const s = new Float64Array(k);\r\n  if (m <= 0 || n <= 0) return s;\r\n  const scratch = new Float64Array(m * k + k + n * k);\r\n  svdCore(a, m, n, scratch, 0, m * k, m * k + k);\r\n  for (let i = 0; i < k; i++) s[i] = scratch[m * k + i];\r\n  return s;\r\n}\r\n\r\nfunction svdCore(\r\n  a: Float64Array,\r\n  m: i32,\r\n  n: i32,\r\n  out: Float64Array,\r\n  uOff: i32,\r\n  sOff: i32,\r\n  vOff: i32\r\n): void {\r\n  // One-sided Jacobi orthogonalizes COLUMNS, so it wants rows >= cols.\r\n  // For wide matrices (m < n) decompose A^T and swap U/V at the end.\r\n  const transposed: bool = m < n;\r\n  const rows: i32 = transposed ? n : m;\r\n  const cols: i32 = transposed ? m : n;\r\n\r\n  // Working matrix `w` (rows x cols) = A (or A^T).\r\n  const w = new Float64Array(rows * cols);\r\n  if (transposed) {\r\n    for (let i = 0; i < rows; i++) {\r\n      for (let j = 0; j < cols; j++) {\r\n        w[i * cols + j] = a[j * rows + i];\r\n      }\r\n    }\r\n  } else {\r\n    for (let i = 0; i < rows * cols; i++) w[i] = a[i];\r\n  }\r\n\r\n  // `v` (cols x cols) starts as identity, accumulates the rotations.\r\n  const v = new Float64Array(cols * cols);\r\n  for (let i = 0; i < cols; i++) v[i * cols + i] = 1.0;\r\n\r\n  let sweeps: i32 = 0;\r\n  while (true) {\r\n    let rotated: bool = false;\r\n    for (let p = 0; p < cols; p++) {\r\n      for (let q = p + 1; q < cols; q++) {\r\n        let alpha: f64 = 0.0;\r\n        let beta: f64 = 0.0;\r\n        let gamma: f64 = 0.0;\r\n        for (let i = 0; i < rows; i++) {\r\n          const wip = w[i * cols + p];\r\n          const wiq = w[i * cols + q];\r\n          alpha += wip * wip;\r\n          beta += wiq * wiq;\r\n          gamma += wip * wiq;\r\n        }\r\n        if (Math.abs(gamma) <= SVD_EPS * Math.sqrt(alpha * beta)) continue;\r\n        rotated = true;\r\n        const zeta = (beta - alpha) / (2.0 * gamma);\r\n        let t: f64;\r\n        if (zeta >= 0.0) {\r\n          t = 1.0 / (zeta + Math.sqrt(1.0 + zeta * zeta));\r\n        } else {\r\n          t = -1.0 / (-zeta + Math.sqrt(1.0 + zeta * zeta));\r\n        }\r\n        const c = 1.0 / Math.sqrt(1.0 + t * t);\r\n        const s = c * t;\r\n        for (let i = 0; i < rows; i++) {\r\n          const wip = w[i * cols + p];\r\n          const wiq = w[i * cols + q];\r\n          w[i * cols + p] = c * wip - s * wiq;\r\n          w[i * cols + q] = s * wip + c * wiq;\r\n        }\r\n        for (let i = 0; i < cols; i++) {\r\n          const vip = v[i * cols + p];\r\n          const viq = v[i * cols + q];\r\n          v[i * cols + p] = c * vip - s * viq;\r\n          v[i * cols + q] = s * vip + c * viq;\r\n        }\r\n      }\r\n    }\r\n    sweeps++;\r\n    if (!rotated || sweeps >= SVD_MAX_SWEEPS) break;\r\n  }\r\n\r\n  // Singular values = column norms of the converged working matrix.\r\n  const sigma = new Float64Array(cols);\r\n  for (let j = 0; j < cols; j++) {\r\n    let nrm: f64 = 0.0;\r\n    for (let i = 0; i < rows; i++) {\r\n      const x = w[i * cols + j];\r\n      nrm += x * x;\r\n    }\r\n    sigma[j] = Math.sqrt(nrm);\r\n  }\r\n\r\n  // Order columns by descending singular value (insertion sort).\r\n  const order = new Int32Array(cols);\r\n  for (let i = 0; i < cols; i++) order[i] = i;\r\n  for (let i = 1; i < cols; i++) {\r\n    const key = order[i];\r\n    let j = i;\r\n    while (j > 0 && sigma[order[j - 1]] < sigma[key]) {\r\n      order[j] = order[j - 1];\r\n      j--;\r\n    }\r\n    order[j] = key;\r\n  }\r\n\r\n  // Build thin U (rows x cols), reordered V (cols x cols), reordered S.\r\n  const uThin = new Float64Array(rows * cols);\r\n  const vOrd = new Float64Array(cols * cols);\r\n  const sOrd = new Float64Array(cols);\r\n  for (let nj = 0; nj < cols; nj++) {\r\n    const oj = order[nj];\r\n    const sv = sigma[oj];\r\n    sOrd[nj] = sv;\r\n    for (let i = 0; i < rows; i++) {\r\n      uThin[i * cols + nj] = sv > 1e-300 ? w[i * cols + oj] / sv : 0.0;\r\n    }\r\n    for (let i = 0; i < cols; i++) {\r\n      vOrd[i * cols + nj] = v[i * cols + oj];\r\n    }\r\n  }\r\n\r\n  // Write outputs, mapped back to the original orientation.\r\n  //  not transposed: A   = uThin * diag(s) * vOrd^T -> U=uThin, V=vOrd\r\n  //  transposed:     A^T = uThin * diag(s) * vOrd^T\r\n  //              =>  A   = vOrd  * diag(s) * uThin^T -> U=vOrd,  V=uThin\r\n  if (transposed) {\r\n    for (let i = 0; i < cols * cols; i++) out[uOff + i] = vOrd[i];\r\n    for (let i = 0; i < cols; i++) out[sOff + i] = sOrd[i];\r\n    for (let i = 0; i < rows * cols; i++) out[vOff + i] = uThin[i];\r\n  } else {\r\n    for (let i = 0; i < rows * cols; i++) out[uOff + i] = uThin[i];\r\n    for (let i = 0; i < cols; i++) out[sOff + i] = sOrd[i];\r\n    for (let i = 0; i < cols * cols; i++) out[vOff + i] = vOrd[i];\r\n  }\r\n}\r\n","/**\r\n * Dense matrix decompositions: LU, QR, Cholesky, inverse, determinant.\r\n *\r\n * AssemblyScript port of `wasm-rust/crates/mathts-wasm/src/algebra/\r\n * decomposition.rs` (which Rust uses directly). The Rust crate operates\r\n * on flat-memory pointers + lengths; AS-managed Float64Array / Int32Array\r\n * arguments carry their own length via the AS runtime header, so the\r\n * signatures here drop the per-buffer length params and keep `n`/`m` as\r\n * shape metadata. Apart from that, the algorithms are line-for-line\r\n * equivalent — Doolittle LU with partial pivoting, Householder QR, and\r\n * a right-looking Cholesky.\r\n *\r\n * Indexing convention: row-major. `a[i * n + j]` denotes row `i`, col `j`.\r\n *\r\n * Return codes:\r\n *   0  → success\r\n *   -1 → singular / not-positive-definite (kernel-specific, documented per fn)\r\n */\r\n\r\nconst DECOMP_EPS: f64 = 1e-14;\r\n\r\n/**\r\n * LU decomposition with partial pivoting (Doolittle form): `P * A = L * U`.\r\n *\r\n * `a` is read-only (n*n, row-major). The factorization is split across:\r\n *   - `l_out` (n*n): unit lower-triangular L (diagonal == 1)\r\n *   - `u_out` (n*n): upper-triangular U\r\n *   - `perm_out` (n):  the row permutation. `perm_out[i] = j` means the\r\n *                      `i`th row of `P*A` is the `j`th row of `A`.\r\n *\r\n * Returns 0 on success, -1 if the matrix is singular (no nonzero pivot\r\n * found in any sub-column).\r\n */\r\nexport function matrix_lu_decompose(\r\n  a: Float64Array,\r\n  n: i32,\r\n  l_out: Float64Array,\r\n  u_out: Float64Array,\r\n  perm_out: Int32Array\r\n): i32 {\r\n  // Work copy — the elimination happens in place. After we're done,\r\n  // L lives below the diagonal and U on/above; we'll split them into\r\n  // l_out / u_out as a final step.\r\n  const work = new Float64Array(n * n);\r\n  for (let i = 0; i < n * n; i++) work[i] = a[i];\r\n\r\n  for (let i = 0; i < n; i++) perm_out[i] = i;\r\n\r\n  for (let k = 0; k < n - 1; k++) {\r\n    // Partial pivot: pick the row with the largest |a[i, k]| for i >= k.\r\n    let maxVal: f64 = Math.abs(work[k * n + k]);\r\n    let pivotRow: i32 = k;\r\n    for (let i = k + 1; i < n; i++) {\r\n      const v = Math.abs(work[i * n + k]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        pivotRow = i;\r\n      }\r\n    }\r\n\r\n    if (maxVal < DECOMP_EPS) {\r\n      return -1; // singular\r\n    }\r\n\r\n    if (pivotRow != k) {\r\n      for (let j = 0; j < n; j++) {\r\n        const tmp = work[k * n + j];\r\n        work[k * n + j] = work[pivotRow * n + j];\r\n        work[pivotRow * n + j] = tmp;\r\n      }\r\n      const tmp = perm_out[k];\r\n      perm_out[k] = perm_out[pivotRow];\r\n      perm_out[pivotRow] = tmp;\r\n    }\r\n\r\n    // Eliminate column k below the diagonal.\r\n    const pivot = work[k * n + k];\r\n    for (let i = k + 1; i < n; i++) {\r\n      const factor: f64 = work[i * n + k] / pivot;\r\n      work[i * n + k] = factor; // store L below the diagonal\r\n      for (let j = k + 1; j < n; j++) {\r\n        work[i * n + j] -= factor * work[k * n + j];\r\n      }\r\n    }\r\n  }\r\n\r\n  // Final pivot must also be nonzero for the matrix to be non-singular.\r\n  if (Math.abs(work[(n - 1) * n + (n - 1)]) < DECOMP_EPS) {\r\n    return -1;\r\n  }\r\n\r\n  // Split the in-place factorization into l_out (unit lower) and u_out (upper).\r\n  for (let i = 0; i < n; i++) {\r\n    for (let j = 0; j < n; j++) {\r\n      if (i > j) {\r\n        l_out[i * n + j] = work[i * n + j];\r\n        u_out[i * n + j] = 0.0;\r\n      } else if (i == j) {\r\n        l_out[i * n + j] = 1.0;\r\n        u_out[i * n + j] = work[i * n + j];\r\n      } else {\r\n        l_out[i * n + j] = 0.0;\r\n        u_out[i * n + j] = work[i * n + j];\r\n      }\r\n    }\r\n  }\r\n\r\n  return 0;\r\n}\r\n\r\n/**\r\n * QR decomposition via Householder reflections.\r\n *\r\n * `a` is read-only (m*n, row-major) with `m >= n`. Outputs:\r\n *   - `q_out` (m*m): orthogonal Q\r\n *   - `r_out` (m*n): upper-trapezoidal R (zero below the diagonal)\r\n *\r\n * Returns 0 on success.\r\n *\r\n * Algorithm mirrors `wasm-rust/.../decomposition.rs::qrDecomposition`:\r\n * apply Householder reflectors to a working copy of A (becomes R) and\r\n * accumulate them into Q starting from the identity. Householder vector\r\n * `v` is normalized such that `v[0] = 1`; the trailing entries live\r\n * in `r_below_diag / u1` and we recompute them on the fly per column\r\n * (matches the Rust implementation exactly — no intermediate `v` array).\r\n */\r\nexport function matrix_qr_decompose(\r\n  a: Float64Array,\r\n  m: i32,\r\n  n: i32,\r\n  q_out: Float64Array,\r\n  r_out: Float64Array\r\n): i32 {\r\n  // R starts as a copy of A; we annihilate the below-diagonal entries.\r\n  for (let i = 0; i < m * n; i++) r_out[i] = a[i];\r\n\r\n  // Q starts as the identity; we accumulate reflectors into it.\r\n  for (let i = 0; i < m * m; i++) q_out[i] = 0.0;\r\n  for (let i = 0; i < m; i++) q_out[i * m + i] = 1.0;\r\n\r\n  const minDim: i32 = m < n ? m : n;\r\n\r\n  // Precompute the Householder vector once per column. We can't re-derive\r\n  // `v[i] = r[i,k] / u1` inside the R-update loop the way the Rust ref\r\n  // does, because the first column-update iteration mutates r[i,k] in\r\n  // place — after that, the on-the-fly `vi` reads would see garbage and\r\n  // the algorithm degenerates (all subsequent updates skip). Storing the\r\n  // reflector in a fresh buffer matches the JS reference in\r\n  // `WASMBackend.qrDecompositionJS` exactly.\r\n  const vBuf = new Float64Array(m);\r\n\r\n  for (let k = 0; k < minDim; k++) {\r\n    // Column norm below (and including) the diagonal pivot.\r\n    let norm: f64 = 0.0;\r\n    for (let i = k; i < m; i++) {\r\n      const v = r_out[i * n + k];\r\n      norm += v * v;\r\n    }\r\n    norm = Math.sqrt(norm);\r\n\r\n    if (norm < DECOMP_EPS) {\r\n      continue; // already zero — nothing to reflect\r\n    }\r\n\r\n    const akk = r_out[k * n + k];\r\n    const sign: f64 = akk >= 0.0 ? 1.0 : -1.0;\r\n    const u1: f64 = akk + sign * norm;\r\n\r\n    // Householder vector v of length m-k: v[0] = 1, v[i] = r[k+i,k] / u1.\r\n    vBuf[0] = 1.0;\r\n    let vDotV: f64 = 1.0;\r\n    for (let i = 1; i < m - k; i++) {\r\n      const vi: f64 = r_out[(k + i) * n + k] / u1;\r\n      vBuf[i] = vi;\r\n      vDotV += vi * vi;\r\n    }\r\n    const tau: f64 = 2.0 / vDotV;\r\n\r\n    // Apply Householder to R: R := (I - tau * v * v^T) * R.\r\n    for (let j = k; j < n; j++) {\r\n      let vDotCol: f64 = 0.0;\r\n      for (let i = 0; i < m - k; i++) {\r\n        vDotCol += vBuf[i] * r_out[(k + i) * n + j];\r\n      }\r\n      const factor: f64 = tau * vDotCol;\r\n      for (let i = 0; i < m - k; i++) {\r\n        r_out[(k + i) * n + j] -= factor * vBuf[i];\r\n      }\r\n    }\r\n\r\n    // Apply Householder to Q (from the left, but stored row-major so the\r\n    // loop walks rows): Q := (I - tau * v * v^T) * Q.\r\n    for (let j = 0; j < m; j++) {\r\n      let vDotCol: f64 = 0.0;\r\n      for (let i = 0; i < m - k; i++) {\r\n        vDotCol += vBuf[i] * q_out[(k + i) * m + j];\r\n      }\r\n      const factor: f64 = tau * vDotCol;\r\n      for (let i = 0; i < m - k; i++) {\r\n        q_out[(k + i) * m + j] -= factor * vBuf[i];\r\n      }\r\n    }\r\n\r\n    // Zero out the sub-diagonal entries of R explicitly (they're numerically\r\n    // ~0 by construction but we want exact zeros for downstream consumers).\r\n    for (let i = k + 1; i < m; i++) {\r\n      r_out[i * n + k] = 0.0;\r\n    }\r\n  }\r\n\r\n  // NOTE: q_out is stored as `Q^T` (Householder reflectors applied from\r\n  // the left to the identity), so `Q^T * R = A`. The matrix-package\r\n  // QR API documents this — see matrix/tests/wasm/accuracy.test.ts and\r\n  // `WASMBackend.qrDecompositionJS` (the JS reference) for the same\r\n  // convention. Callers wanting Q itself should transpose q_out.\r\n\r\n  return 0;\r\n}\r\n\r\n/**\r\n * Cholesky decomposition: `A = L * L^T` for symmetric positive-definite A.\r\n *\r\n * `a` is read-only (n*n). `l_out` (n*n) receives the lower-triangular\r\n * factor; the upper triangle is zeroed.\r\n *\r\n * Returns 0 on success, -1 if A is not positive-definite (detected as\r\n * a non-positive diagonal element during the factorization).\r\n *\r\n * Uses the right-looking variant that mirrors the Rust reference: for\r\n * each column j we compute `L[j,j] = sqrt(A[j,j] - sum_k L[j,k]^2)` and\r\n * `L[i,j] = (A[i,j] - sum_k L[i,k] * L[j,k]) / L[j,j]` for i > j.\r\n */\r\nexport function matrix_cholesky(a: Float64Array, n: i32, l_out: Float64Array): i32 {\r\n  for (let i = 0; i < n * n; i++) l_out[i] = 0.0;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    for (let j = 0; j <= i; j++) {\r\n      let sum: f64 = a[i * n + j];\r\n      for (let k = 0; k < j; k++) {\r\n        sum -= l_out[i * n + k] * l_out[j * n + k];\r\n      }\r\n      if (i == j) {\r\n        if (sum <= 0.0) return -1; // not positive-definite\r\n        l_out[i * n + j] = Math.sqrt(sum);\r\n      } else {\r\n        const ljj = l_out[j * n + j];\r\n        l_out[i * n + j] = sum / ljj;\r\n      }\r\n    }\r\n  }\r\n  return 0;\r\n}\r\n\r\n/**\r\n * Compute `A^-1` for a square n*n matrix via LU + column-wise back-solve.\r\n *\r\n * `work` is a scratch buffer of length >= 2*n*n + 2*n: the first n*n\r\n * holds the in-place LU factorization, the next n*n is unused (room\r\n * for callers who pre-size matching the inverse layout), and the\r\n * trailing 2*n holds the permutation + RHS/solution vectors. To keep\r\n * the AS API simple the caller passes a single `work` Float64Array\r\n * sized at least `n * n`; we allocate the small Int32/Float64 helpers\r\n * internally (AS new is cheap and the GC is a no-op under\r\n * `--runtime stub`, so this doesn't change leak characteristics).\r\n *\r\n * Returns 0 on success, -1 if A is singular (in which case `result`\r\n * is left zeroed).\r\n */\r\nexport function matrix_inverse(\r\n  a: Float64Array,\r\n  n: i32,\r\n  result: Float64Array,\r\n  work: Float64Array\r\n): i32 {\r\n  // Copy A into the work buffer; LU will eliminate in place.\r\n  for (let i = 0; i < n * n; i++) work[i] = a[i];\r\n\r\n  const perm = new Int32Array(n);\r\n  for (let i = 0; i < n; i++) perm[i] = i;\r\n\r\n  // Doolittle LU with partial pivoting — same algorithm as\r\n  // matrix_lu_decompose, just inline so we can re-use the factored\r\n  // buffer for the back-solve below.\r\n  for (let k = 0; k < n - 1; k++) {\r\n    let maxVal: f64 = Math.abs(work[k * n + k]);\r\n    let pivotRow: i32 = k;\r\n    for (let i = k + 1; i < n; i++) {\r\n      const v = Math.abs(work[i * n + k]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        pivotRow = i;\r\n      }\r\n    }\r\n    if (maxVal < DECOMP_EPS) {\r\n      for (let i = 0; i < n * n; i++) result[i] = 0.0;\r\n      return -1;\r\n    }\r\n    if (pivotRow != k) {\r\n      for (let j = 0; j < n; j++) {\r\n        const tmp = work[k * n + j];\r\n        work[k * n + j] = work[pivotRow * n + j];\r\n        work[pivotRow * n + j] = tmp;\r\n      }\r\n      const tmp = perm[k];\r\n      perm[k] = perm[pivotRow];\r\n      perm[pivotRow] = tmp;\r\n    }\r\n    const pivot = work[k * n + k];\r\n    for (let i = k + 1; i < n; i++) {\r\n      const factor: f64 = work[i * n + k] / pivot;\r\n      work[i * n + k] = factor;\r\n      for (let j = k + 1; j < n; j++) {\r\n        work[i * n + j] -= factor * work[k * n + j];\r\n      }\r\n    }\r\n  }\r\n  if (Math.abs(work[(n - 1) * n + (n - 1)]) < DECOMP_EPS) {\r\n    for (let i = 0; i < n * n; i++) result[i] = 0.0;\r\n    return -1;\r\n  }\r\n\r\n  // Solve A * X = I one column at a time.\r\n  const b = new Float64Array(n);\r\n  const x = new Float64Array(n);\r\n  for (let col = 0; col < n; col++) {\r\n    for (let i = 0; i < n; i++) b[i] = i == col ? 1.0 : 0.0;\r\n\r\n    // Forward substitution: L * y = P * b. Since L has unit diagonal,\r\n    // y[i] = b[perm[i]] - sum_{j<i} L[i,j] * y[j].\r\n    for (let i = 0; i < n; i++) {\r\n      let sum: f64 = b[perm[i]];\r\n      for (let j = 0; j < i; j++) sum -= work[i * n + j] * x[j];\r\n      x[i] = sum;\r\n    }\r\n\r\n    // Backward substitution: U * x = y.\r\n    for (let ii = 0; ii < n; ii++) {\r\n      const i = n - 1 - ii;\r\n      let sum: f64 = x[i];\r\n      for (let j = i + 1; j < n; j++) sum -= work[i * n + j] * x[j];\r\n      x[i] = sum / work[i * n + i];\r\n    }\r\n\r\n    for (let i = 0; i < n; i++) result[i * n + col] = x[i];\r\n  }\r\n\r\n  return 0;\r\n}\r\n\r\n/**\r\n * Determinant of a square n*n matrix via LU.\r\n *\r\n * Returns `det(A)`. Returns 0.0 when the matrix is singular — note this\r\n * value is also legitimately reachable by a tiny non-singular matrix, so\r\n * callers wanting a singularity flag should test against a tolerance\r\n * rather than exact zero.\r\n *\r\n * `work` is a scratch Float64Array of length >= n*n.\r\n */\r\nexport function matrix_determinant(a: Float64Array, n: i32, work: Float64Array): f64 {\r\n  for (let i = 0; i < n * n; i++) work[i] = a[i];\r\n\r\n  const perm = new Int32Array(n);\r\n  for (let i = 0; i < n; i++) perm[i] = i;\r\n\r\n  let swaps: i32 = 0;\r\n\r\n  for (let k = 0; k < n - 1; k++) {\r\n    let maxVal: f64 = Math.abs(work[k * n + k]);\r\n    let pivotRow: i32 = k;\r\n    for (let i = k + 1; i < n; i++) {\r\n      const v = Math.abs(work[i * n + k]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        pivotRow = i;\r\n      }\r\n    }\r\n    if (maxVal < DECOMP_EPS) return 0.0;\r\n    if (pivotRow != k) {\r\n      for (let j = 0; j < n; j++) {\r\n        const tmp = work[k * n + j];\r\n        work[k * n + j] = work[pivotRow * n + j];\r\n        work[pivotRow * n + j] = tmp;\r\n      }\r\n      swaps++;\r\n    }\r\n    const pivot = work[k * n + k];\r\n    for (let i = k + 1; i < n; i++) {\r\n      const factor: f64 = work[i * n + k] / pivot;\r\n      work[i * n + k] = factor;\r\n      for (let j = k + 1; j < n; j++) {\r\n        work[i * n + j] -= factor * work[k * n + j];\r\n      }\r\n    }\r\n  }\r\n\r\n  // det(A) = (-1)^swaps * product(diag(U)).\r\n  let det: f64 = swaps % 2 == 0 ? 1.0 : -1.0;\r\n  for (let i = 0; i < n; i++) det *= work[i * n + i];\r\n  return det;\r\n}\r\n","/**\r\n * Orthogonal polynomials and integral special functions — AssemblyScript\r\n * fallback mirroring `wasm-rust/.../special/{orthogonal,integral}.rs`.\r\n */\r\n\r\nconst EULER: f64 = 0.5772156649015329;\r\n\r\n// --- Orthogonal polynomials -------------------------------------------------\r\n\r\n/** Chebyshev polynomial of the first kind, T_n(x). */\r\nexport function chebyshevT(n: f64, x: f64): f64 {\r\n  const ni: i32 = <i32>Math.round(n);\r\n  if (ni < 0) return NaN;\r\n  if (ni == 0) return 1.0;\r\n  if (ni == 1) return x;\r\n  let prev: f64 = 1.0;\r\n  let curr: f64 = x;\r\n  for (let k: i32 = 2; k <= ni; k++) {\r\n    const next: f64 = 2.0 * x * curr - prev;\r\n    prev = curr;\r\n    curr = next;\r\n  }\r\n  return curr;\r\n}\r\n\r\n/** Hermite polynomial H_n(x) (physicists' convention). */\r\nexport function hermiteH(n: f64, x: f64): f64 {\r\n  const ni: i32 = <i32>Math.round(n);\r\n  if (ni < 0) return NaN;\r\n  if (ni == 0) return 1.0;\r\n  if (ni == 1) return 2.0 * x;\r\n  let prev: f64 = 1.0;\r\n  let curr: f64 = 2.0 * x;\r\n  for (let k: i32 = 2; k <= ni; k++) {\r\n    const next: f64 = 2.0 * x * curr - 2.0 * <f64>(k - 1) * prev;\r\n    prev = curr;\r\n    curr = next;\r\n  }\r\n  return curr;\r\n}\r\n\r\n/** Laguerre polynomial L_n(x). */\r\nexport function laguerreL(n: f64, x: f64): f64 {\r\n  const ni: i32 = <i32>Math.round(n);\r\n  if (ni < 0) return NaN;\r\n  if (ni == 0) return 1.0;\r\n  if (ni == 1) return 1.0 - x;\r\n  let prev: f64 = 1.0;\r\n  let curr: f64 = 1.0 - x;\r\n  for (let k: i32 = 2; k <= ni; k++) {\r\n    const kf: f64 = <f64>k;\r\n    const next: f64 = ((2.0 * kf - 1.0 - x) * curr - (kf - 1.0) * prev) / kf;\r\n    prev = curr;\r\n    curr = next;\r\n  }\r\n  return curr;\r\n}\r\n\r\n/** Legendre polynomial P_n(x). */\r\nexport function legendreP(n: f64, x: f64): f64 {\r\n  const ni: i32 = <i32>Math.round(n);\r\n  if (ni < 0) return NaN;\r\n  if (ni == 0) return 1.0;\r\n  if (ni == 1) return x;\r\n  let prev: f64 = 1.0;\r\n  let curr: f64 = x;\r\n  for (let k: i32 = 2; k <= ni; k++) {\r\n    const kf: f64 = <f64>k;\r\n    const next: f64 = ((2.0 * kf - 1.0) * x * curr - (kf - 1.0) * prev) / kf;\r\n    prev = curr;\r\n    curr = next;\r\n  }\r\n  return curr;\r\n}\r\n\r\n// --- Error / integral functions ---------------------------------------------\r\n\r\n/** Imaginary error function erfi(x). */\r\nexport function erfi(x: f64): f64 {\r\n  const c: f64 = 2.0 / Math.sqrt(Math.PI);\r\n  let sum: f64 = 0.0;\r\n  let term: f64 = x;\r\n  for (let n: i32 = 0; n < 100; n++) {\r\n    const nf: f64 = <f64>n;\r\n    sum += term / (2.0 * nf + 1.0);\r\n    term *= (x * x) / (nf + 1.0);\r\n    if (Math.abs(term / (2.0 * nf + 3.0)) < Math.abs(sum) * 1e-15) break;\r\n  }\r\n  return c * sum;\r\n}\r\n\r\n/** Exponential integral Ei(x). */\r\nexport function expIntegralEi(x: f64): f64 {\r\n  if (x == 0.0) return -Infinity;\r\n  if (Math.abs(x) <= 40.0) {\r\n    let sum: f64 = 0.0;\r\n    let term: f64 = 1.0;\r\n    for (let n: i32 = 1; n < 200; n++) {\r\n      const nf: f64 = <f64>n;\r\n      term *= x / nf;\r\n      sum += term / nf;\r\n      if (Math.abs(term / nf) < Math.abs(sum) * 1e-15) break;\r\n    }\r\n    return EULER + Math.log(Math.abs(x)) + sum;\r\n  }\r\n  let sum: f64 = 1.0;\r\n  let term: f64 = 1.0;\r\n  for (let n: i32 = 1; n <= 30; n++) {\r\n    term *= <f64>n / x;\r\n    sum += term;\r\n    if (Math.abs(term) < 1e-15) break;\r\n  }\r\n  return (Math.exp(x) / x) * sum;\r\n}\r\n\r\n/** Sine integral Si(x). */\r\nexport function sinIntegral(x: f64): f64 {\r\n  if (x == 0.0) return 0.0;\r\n  const sign: f64 = x < 0.0 ? -1.0 : 1.0;\r\n  const ax: f64 = Math.abs(x);\r\n  let sum: f64 = 0.0;\r\n  let term: f64 = ax;\r\n  for (let n: i32 = 0; n < 100; n++) {\r\n    const nf: f64 = <f64>n;\r\n    sum += term / (2.0 * nf + 1.0);\r\n    term *= (-ax * ax) / ((2.0 * nf + 2.0) * (2.0 * nf + 3.0));\r\n    if (Math.abs(term / (2.0 * nf + 3.0)) < 1e-15) break;\r\n  }\r\n  return sign * sum;\r\n}\r\n\r\n/** Cosine integral Ci(x), x > 0. */\r\nexport function cosIntegral(x: f64): f64 {\r\n  if (x <= 0.0) return NaN;\r\n  if (x <= 25.0) {\r\n    let sum: f64 = 0.0;\r\n    let term: f64 = 1.0;\r\n    for (let n: i32 = 1; n < 200; n++) {\r\n      const nf: f64 = <f64>n;\r\n      term *= (-x * x) / ((2.0 * nf - 1.0) * (2.0 * nf));\r\n      sum += term / (2.0 * nf);\r\n      if (Math.abs(term / (2.0 * nf)) < 1e-16) break;\r\n    }\r\n    return EULER + Math.log(x) + sum;\r\n  }\r\n  const x2: f64 = x * x;\r\n  let f: f64 = 1.0;\r\n  let g: f64 = 1.0;\r\n  let fTerm: f64 = 1.0;\r\n  let gTerm: f64 = 1.0;\r\n  for (let n: i32 = 1; n <= 25; n++) {\r\n    const nf: f64 = <f64>n;\r\n    fTerm *= (-(2.0 * nf) * (2.0 * nf - 1.0)) / x2;\r\n    gTerm *= (-(2.0 * nf + 1.0) * (2.0 * nf)) / x2;\r\n    f += fTerm;\r\n    g += gTerm;\r\n    if (Math.abs(fTerm) < 1e-17 && Math.abs(gTerm) < 1e-17) break;\r\n  }\r\n  return (f / x) * Math.sin(x) - (g / x2) * Math.cos(x);\r\n}\r\n\r\n/** Logarithmic integral li(x) = Ei(ln x), x > 0 and x != 1. */\r\nexport function logIntegral(x: f64): f64 {\r\n  if (x <= 0.0 || x == 1.0) return NaN;\r\n  return expIntegralEi(Math.log(x));\r\n}\r\n","/**\r\n * Number-theory functions — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../combinatorics/number_theory.rs`.\r\n *\r\n * Array-valued functions return a `Float64Array` (AssemblyScript manages the\r\n * memory); `chineseRemainder` takes two `Float64Array`s.\r\n */\r\n\r\nconst MAX_SAFE_INT: f64 = 9.007199254740992e15; // 2^53\r\n\r\nfunction isInt(x: f64): bool {\r\n  return x >= -MAX_SAFE_INT && x <= MAX_SAFE_INT && Math.floor(x) == x;\r\n}\r\n\r\nfunction gcdU(a: i64, b: i64): i64 {\r\n  while (b != 0) {\r\n    const t: i64 = b;\r\n    b = a % b;\r\n    a = t;\r\n  }\r\n  return a;\r\n}\r\n\r\nfunction lcmU(a: i64, b: i64): i64 {\r\n  if (a == 0 || b == 0) return 0;\r\n  return (a / gcdU(a, b)) * b;\r\n}\r\n\r\n/** Euler's totient phi(n). */\r\nexport function eulerPhi(n: f64): f64 {\r\n  if (!isInt(n) || n < 1.0) return NaN;\r\n  let result: i64 = <i64>n;\r\n  let m: i64 = <i64>n;\r\n  for (let p: i64 = 2; p * p <= m; p++) {\r\n    if (m % p == 0) {\r\n      while (m % p == 0) m /= p;\r\n      result -= result / p;\r\n    }\r\n  }\r\n  if (m > 1) result -= result / m;\r\n  return <f64>result;\r\n}\r\n\r\n/** Sum of k-th powers of divisors, sigma_k(n). divisorSigma(n,0) = count. */\r\nexport function divisorSigma(n: f64, k: f64): f64 {\r\n  if (!isInt(n) || n < 1.0 || !isInt(k) || k < 0.0) return NaN;\r\n  const nn: i64 = <i64>n;\r\n  let sum: f64 = 0.0;\r\n  for (let i: i64 = 1; i * i <= nn; i++) {\r\n    if (nn % i == 0) {\r\n      sum += Math.pow(<f64>i, k);\r\n      const j: i64 = nn / i;\r\n      if (j != i) sum += Math.pow(<f64>j, k);\r\n    }\r\n  }\r\n  return sum;\r\n}\r\n\r\n/** Mobius function mu(n) — 1, 0 or -1. */\r\nexport function moebiusMu(n: f64): f64 {\r\n  if (!isInt(n) || n < 1.0) return NaN;\r\n  if (n == 1.0) return 1.0;\r\n  let m: i64 = <i64>n;\r\n  let numFactors: i32 = 0;\r\n  for (let p: i64 = 2; p * p <= m; p++) {\r\n    if (m % p == 0) {\r\n      m /= p;\r\n      if (m % p == 0) return 0.0;\r\n      numFactors++;\r\n    }\r\n  }\r\n  if (m > 1) numFactors++;\r\n  return numFactors % 2 == 0 ? 1.0 : -1.0;\r\n}\r\n\r\nfunction carmichaelPrimePower(p: i64, pk: i64): i64 {\r\n  if (p == 2) {\r\n    if (pk <= 2) return 1;\r\n    if (pk == 4) return 2;\r\n    return pk / 4;\r\n  }\r\n  return (pk / p) * (p - 1);\r\n}\r\n\r\n/** Carmichael function lambda(n). */\r\nexport function carmichaelLambda(n: f64): f64 {\r\n  if (!isInt(n) || n < 1.0) return NaN;\r\n  if (n == 1.0) return 1.0;\r\n  let m: i64 = <i64>n;\r\n  let result: i64 = 1;\r\n  for (let p: i64 = 2; p * p <= m; p++) {\r\n    if (m % p == 0) {\r\n      let pk: i64 = 1;\r\n      while (m % p == 0) {\r\n        pk *= p;\r\n        m /= p;\r\n      }\r\n      result = lcmU(result, carmichaelPrimePower(p, pk));\r\n    }\r\n  }\r\n  if (m > 1) result = lcmU(result, m - 1);\r\n  return <f64>result;\r\n}\r\n\r\n/** Jacobi symbol (a / n) — n a positive odd integer. */\r\nexport function jacobiSymbol(a: f64, n: f64): f64 {\r\n  if (!isInt(a) || !isInt(n)) return NaN;\r\n  const ni: i64 = <i64>n;\r\n  if (ni < 1 || ni % 2 == 0) return NaN;\r\n  if (ni == 1) return 1.0;\r\n  const ai: i64 = <i64>a;\r\n  let aa: i64 = ((ai % ni) + ni) % ni;\r\n  let nn: i64 = ni;\r\n  let result: i64 = 1;\r\n  while (aa != 0) {\r\n    while (aa % 2 == 0) {\r\n      aa /= 2;\r\n      if (nn % 8 == 3 || nn % 8 == 5) result = -result;\r\n    }\r\n    const t: i64 = aa;\r\n    aa = nn;\r\n    nn = t;\r\n    if (aa % 4 == 3 && nn % 4 == 3) result = -result;\r\n    aa %= nn;\r\n  }\r\n  return nn == 1 ? <f64>result : 0.0;\r\n}\r\n\r\n/** n-th harmonic number H(n). */\r\nexport function harmonicNumber(n: f64): f64 {\r\n  if (!isInt(n) || n < 1.0) return NaN;\r\n  const nn: i64 = <i64>n;\r\n  let sum: f64 = 0.0;\r\n  for (let i: i64 = 1; i <= nn; i++) sum += 1.0 / <f64>i;\r\n  return sum;\r\n}\r\n\r\n/** Integer partition count p(n). */\r\nexport function partitions(n: f64): f64 {\r\n  if (!isInt(n) || n < 0.0) return NaN;\r\n  const nn: i32 = <i32>n;\r\n  const dp = new Float64Array(nn + 1);\r\n  dp[0] = 1.0;\r\n  for (let k: i32 = 1; k <= nn; k++) {\r\n    for (let i: i32 = k; i <= nn; i++) dp[i] += dp[i - k];\r\n  }\r\n  return dp[nn];\r\n}\r\n\r\n/** Prime factorization of n >= 2 (with multiplicity, ascending). */\r\nexport function primeFactors(n: f64): Float64Array {\r\n  if (!isInt(n) || n < 2.0) return new Float64Array(0);\r\n  let count: i32 = 0;\r\n  let mc: i64 = <i64>n;\r\n  for (let d: i64 = 2; d * d <= mc; d++) {\r\n    while (mc % d == 0) {\r\n      count++;\r\n      mc /= d;\r\n    }\r\n  }\r\n  if (mc > 1) count++;\r\n\r\n  const out = new Float64Array(count);\r\n  let m: i64 = <i64>n;\r\n  let idx: i32 = 0;\r\n  for (let d: i64 = 2; d * d <= m; d++) {\r\n    while (m % d == 0) {\r\n      out[idx++] = <f64>d;\r\n      m /= d;\r\n    }\r\n  }\r\n  if (m > 1) out[idx++] = <f64>m;\r\n  return out;\r\n}\r\n\r\n/** All positive divisors of n >= 1, ascending. */\r\nexport function divisors(n: f64): Float64Array {\r\n  if (!isInt(n) || n < 1.0) return new Float64Array(0);\r\n  const nn: i64 = <i64>n;\r\n  let count: i32 = 0;\r\n  for (let i: i64 = 1; i * i <= nn; i++) {\r\n    if (nn % i == 0) count += i == nn / i ? 1 : 2;\r\n  }\r\n  const out = new Float64Array(count);\r\n  let small: i32 = 0;\r\n  let large: i32 = count - 1;\r\n  for (let i: i64 = 1; i * i <= nn; i++) {\r\n    if (nn % i == 0) {\r\n      out[small++] = <f64>i;\r\n      const j: i64 = nn / i;\r\n      if (j != i) out[large--] = <f64>j;\r\n    }\r\n  }\r\n  return out;\r\n}\r\n\r\n/** Digits of n >= 0 in base >= 2, most-significant first. */\r\nexport function integerDigits(n: f64, base: f64): Float64Array {\r\n  if (!isInt(n) || n < 0.0 || !isInt(base) || base < 2.0) {\r\n    return new Float64Array(0);\r\n  }\r\n  const nn: i64 = <i64>n;\r\n  const b: i64 = <i64>base;\r\n  if (nn == 0) {\r\n    const zero = new Float64Array(1);\r\n    zero[0] = 0.0;\r\n    return zero;\r\n  }\r\n  let count: i32 = 0;\r\n  let m: i64 = nn;\r\n  while (m > 0) {\r\n    count++;\r\n    m /= b;\r\n  }\r\n  const out = new Float64Array(count);\r\n  m = nn;\r\n  let idx: i32 = count - 1;\r\n  while (m > 0) {\r\n    out[idx--] = <f64>(m % b);\r\n    m /= b;\r\n  }\r\n  return out;\r\n}\r\n\r\nfunction modInverse(a: i64, m: i64): i64 {\r\n  let oldR: i64 = a;\r\n  let r: i64 = m;\r\n  let oldS: i64 = 1;\r\n  let s: i64 = 0;\r\n  while (r != 0) {\r\n    const q: i64 = oldR / r;\r\n    const nr: i64 = oldR - q * r;\r\n    oldR = r;\r\n    r = nr;\r\n    const ns: i64 = oldS - q * s;\r\n    oldS = s;\r\n    s = ns;\r\n  }\r\n  if (oldR != 1) return -1;\r\n  return ((oldS % m) + m) % m;\r\n}\r\n\r\n/** Chinese Remainder Theorem solver — moduli must be pairwise coprime. */\r\nexport function chineseRemainder(rem: Float64Array, mods: Float64Array): f64 {\r\n  const n: i32 = rem.length;\r\n  if (n == 0 || mods.length != n) return NaN;\r\n  let bigM: i64 = 1;\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const mi: f64 = mods[i];\r\n    if (mi < 1.0 || Math.floor(mi) != mi) return NaN;\r\n    bigM *= <i64>mi;\r\n  }\r\n  let x: i64 = 0;\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    if (!isInt(rem[i])) return NaN;\r\n    const modi: i64 = <i64>mods[i];\r\n    const mi: i64 = bigM / modi;\r\n    const yi: i64 = modInverse(((mi % modi) + modi) % modi, modi);\r\n    if (yi == -1) return NaN;\r\n    x += <i64>rem[i] * mi * yi;\r\n  }\r\n  return <f64>(((x % bigM) + bigM) % bigM);\r\n}\r\n","/**\r\n * Bessel J/Y, Airy Ai/Bi, lgamma — AssemblyScript parity port.\r\n *\r\n * Mirrors the algorithms in:\r\n *   wasm-rust/crates/mathts-wasm/src/special/functions.rs  (Bessel/lgamma scalars)\r\n *   wasm-rust/crates/mathts-wasm/src/bessel.rs             (array kernels)\r\n *   wasm-rust/crates/mathts-wasm/src/special/functions.rs  (Airy scalars)\r\n *\r\n * All exported functions accept / return Float64Array and use the same\r\n * typed-array calling convention as the other AS kernels (tridiag.ts, poly.ts).\r\n *\r\n * Bessel approximation accuracy:\r\n *   J0/J1:  ~1e-7 relative error (NR §6.5 polynomial, |x| < 8)\r\n *   Y0/Y1:  ~1e-4 relative error near x=1 (larger near the log singularity)\r\n *\r\n * Airy approximation accuracy:\r\n *   |x| ≤ 4.5 (power series):  ~1e-10 relative error\r\n *   |x| > 4.5 (asymptotic):    ~1e-7 relative error\r\n *\r\n * Slice 4.9 — companion to Slice 3.10c-1.\r\n * Slice 5.8 — adds lgamma array kernel.\r\n */\r\n\r\n// ===========================================================================\r\n// Log-gamma function (Slice 5.8)\r\n//\r\n// Lanczos approximation: g = 7, 9 coefficients.\r\n// Handles x ≤ 0 (non-positive integers) → +∞.\r\n// Negative non-integer x: reflection formula  lgamma(x) = ln(π/|sin(πx)|) − lgamma(1−x).\r\n//\r\n// Reference: Numerical Recipes §6.1; matches Rust implementation in\r\n//   wasm-rust/crates/mathts-wasm/src/special/functions.rs :: lgamma.\r\n// ===========================================================================\r\n\r\nconst _LGAMMA_G: f64 = 7.0;\r\nconst _LGAMMA_C0: f64 = 0.99999999999980993;\r\nconst _LGAMMA_C1: f64 = 676.5203681218851;\r\nconst _LGAMMA_C2: f64 = -1259.1392167224028;\r\nconst _LGAMMA_C3: f64 = 771.32342877765313;\r\nconst _LGAMMA_C4: f64 = -176.61502916214059;\r\nconst _LGAMMA_C5: f64 = 12.507343278686905;\r\nconst _LGAMMA_C6: f64 = -0.13857109526572012;\r\nconst _LGAMMA_C7: f64 = 9.9843695780195716e-6;\r\nconst _LGAMMA_C8: f64 = 1.5056327351493116e-7;\r\n\r\nfunction _lgamma(x: f64): f64 {\r\n  // Poles at 0 and negative integers\r\n  if (x <= 0.0 && x == Math.floor(x)) return Infinity;\r\n  if (x < 0.5) {\r\n    // Reflection: lgamma(x) = ln(π/|sin(πx)|) − lgamma(1−x)\r\n    const sinPiX: f64 = Math.abs(Math.sin(Math.PI * x));\r\n    if (sinPiX == 0.0) return Infinity;\r\n    return Math.log(Math.PI / sinPiX) - _lgamma(1.0 - x);\r\n  }\r\n  const xm1: f64 = x - 1.0;\r\n  let a: f64 =\r\n    _LGAMMA_C0 +\r\n    _LGAMMA_C1 / (xm1 + 1.0) +\r\n    _LGAMMA_C2 / (xm1 + 2.0) +\r\n    _LGAMMA_C3 / (xm1 + 3.0) +\r\n    _LGAMMA_C4 / (xm1 + 4.0) +\r\n    _LGAMMA_C5 / (xm1 + 5.0) +\r\n    _LGAMMA_C6 / (xm1 + 6.0) +\r\n    _LGAMMA_C7 / (xm1 + 7.0) +\r\n    _LGAMMA_C8 / (xm1 + 8.0);\r\n  const t: f64 = xm1 + _LGAMMA_G + 0.5;\r\n  return 0.5 * Math.log(2.0 * Math.PI) + (xm1 + 0.5) * Math.log(t) - t + Math.log(a);\r\n}\r\n\r\n// ===========================================================================\r\n// Array export — lgamma (Slice 5.8)\r\n// ===========================================================================\r\n\r\n/** Apply lgamma(x) element-wise.  Poles → +∞. */\r\nexport function lgamma_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _lgamma(xs[i]);\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel J0 scalar\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselJ0(x: f64): f64 {\r\n  const ax: f64 = Math.abs(x);\r\n  if (ax < 8.0) {\r\n    const y: f64 = ax * ax;\r\n    const ans1: f64 =\r\n      57568490574.0 +\r\n      y *\r\n        (-13362590354.0 +\r\n          y * (651619640.7 + y * (-11214424.18 + y * (77392.33017 + y * -184.9052456))));\r\n    const ans2: f64 =\r\n      57568490411.0 +\r\n      y * (1029532985.0 + y * (9494680.718 + y * (59272.64853 + y * (267.8532712 + y))));\r\n    return ans1 / ans2;\r\n  }\r\n  const z: f64 = 8.0 / ax;\r\n  const y: f64 = z * z;\r\n  const xx: f64 = ax - 0.785398164;\r\n  const ans1: f64 =\r\n    1.0 +\r\n    y *\r\n      (-0.001098628627 +\r\n        y * (0.00002734510407 + y * (-0.000002073370639 + y * 0.0000002093887211)));\r\n  const ans2: f64 =\r\n    -0.01562499995 +\r\n    y *\r\n      (0.0001430488765 +\r\n        y * (-0.000006911147651 + y * (0.0000007621095161 - y * 0.0000000934935152)));\r\n  return Math.sqrt(0.636619772 / ax) * (Math.cos(xx) * ans1 - z * Math.sin(xx) * ans2);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel J1 scalar\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselJ1(x: f64): f64 {\r\n  const sign: f64 = x < 0.0 ? -1.0 : 1.0;\r\n  const ax: f64 = Math.abs(x);\r\n  if (ax < 8.0) {\r\n    const y: f64 = ax * ax;\r\n    const ans1: f64 =\r\n      ax *\r\n      (72362614232.0 +\r\n        y *\r\n          (-7895059235.0 +\r\n            y * (242396853.1 + y * (-2972611.439 + y * (15704.4826 + y * -30.16036606)))));\r\n    const ans2: f64 =\r\n      144725228442.0 +\r\n      y * (2300535178.0 + y * (18583304.74 + y * (99447.43394 + y * (376.9991397 + y))));\r\n    return (sign * ans1) / ans2;\r\n  }\r\n  const z: f64 = 8.0 / ax;\r\n  const y: f64 = z * z;\r\n  const xx: f64 = ax - 2.356194491;\r\n  const ans1: f64 =\r\n    1.0 +\r\n    y * (0.00183105 + y * (-0.00003516396496 + y * (0.000002457520174 - y * 0.0000002404127372)));\r\n  const ans2: f64 =\r\n    0.04687499995 +\r\n    y *\r\n      (-0.0002002690873 +\r\n        y * (0.000008449199096 + y * (-0.0000008820898866 + y * 0.0000001057874125)));\r\n  return sign * Math.sqrt(0.636619772 / ax) * (Math.cos(xx) * ans1 - z * Math.sin(xx) * ans2);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel Y0 scalar (x > 0)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselY0(x: f64): f64 {\r\n  if (x <= 0.0) return NaN;\r\n  if (x < 8.0) {\r\n    const y: f64 = x * x;\r\n    const ans1: f64 =\r\n      -2957821389.0 +\r\n      y *\r\n        (7062834065.0 +\r\n          y * (-512359803.6 + y * (10879881.29 + y * (-86327.92757 + y * 228.4622733))));\r\n    const ans2: f64 =\r\n      40076544269.0 +\r\n      y * (745249964.8 + y * (7189466.438 + y * (47447.2647 + y * (226.1030244 + y))));\r\n    return ans1 / ans2 + 0.636619772 * _besselJ0(x) * Math.log(x);\r\n  }\r\n  const z: f64 = 8.0 / x;\r\n  const y: f64 = z * z;\r\n  const xx: f64 = x - 0.785398164;\r\n  const ans1: f64 =\r\n    1.0 +\r\n    y *\r\n      (-0.001098628627 +\r\n        y * (0.00002734510407 + y * (-0.000002073370639 + y * 0.0000002093887211)));\r\n  const ans2: f64 =\r\n    -0.01562499995 +\r\n    y *\r\n      (0.0001430488765 +\r\n        y * (-0.000006911147651 + y * (0.0000007621095161 - y * 0.0000000934935152)));\r\n  return Math.sqrt(0.636619772 / x) * (Math.sin(xx) * ans1 + z * Math.cos(xx) * ans2);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel Y1 scalar (x > 0)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselY1(x: f64): f64 {\r\n  if (x <= 0.0) return NaN;\r\n  if (x < 8.0) {\r\n    const y: f64 = x * x;\r\n    const ans1: f64 =\r\n      x *\r\n      (-4900604943000.0 +\r\n        y *\r\n          (1275274390000.0 +\r\n            y * (-51534381390.0 + y * (734926455.1 + y * (-4237922.726 + y * 8511.937935)))));\r\n    const ans2: f64 =\r\n      24909857380000.0 +\r\n      y *\r\n        (424441966400.0 +\r\n          y *\r\n            (3733650367.0 + y * (22459040.02 + y * (102042.605 + y * (354.9632885 + y)))));\r\n    return ans1 / ans2 + 0.636619772 * (_besselJ1(x) * Math.log(x) - 1.0 / x);\r\n  }\r\n  const z: f64 = 8.0 / x;\r\n  const y: f64 = z * z;\r\n  const xx: f64 = x - 2.356194491;\r\n  const ans1: f64 =\r\n    1.0 +\r\n    y * (0.00183105 + y * (-0.00003516396496 + y * (0.000002457520174 - y * 0.0000002404127372)));\r\n  const ans2: f64 =\r\n    0.04687499995 +\r\n    y *\r\n      (-0.0002002690873 +\r\n        y * (0.000008449199096 + y * (-0.0000008820898866 + y * 0.0000001057874125)));\r\n  return Math.sqrt(0.636619772 / x) * (Math.sin(xx) * ans1 + z * Math.cos(xx) * ans2);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel Jn scalar (general integer order, forward/backward recurrence)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselJn(n: i32, x: f64): f64 {\r\n  const ni: i32 = n < 0 ? -n : n;\r\n  const sign: f64 = n < 0 && ni % 2 != 0 ? -1.0 : 1.0;\r\n  if (ni == 0) return sign * _besselJ0(x);\r\n  if (ni == 1) return sign * _besselJ1(x);\r\n  if (Math.abs(x) < 1e-15) return 0.0;\r\n  if (ni <= 20 || Math.abs(x) > <f64>ni) {\r\n    // Forward recurrence\r\n    let jPrev: f64 = _besselJ0(x);\r\n    let jCurr: f64 = _besselJ1(x);\r\n    for (let k: i32 = 1; k < ni; k++) {\r\n      const jNext: f64 = (2.0 * <f64>k / x) * jCurr - jPrev;\r\n      jPrev = jCurr;\r\n      jCurr = jNext;\r\n    }\r\n    return sign * jCurr;\r\n  }\r\n  // Miller backward recurrence\r\n  const isqrt: i32 = <i32>Math.sqrt(40.0 * <f64>ni);\r\n  const extra: i32 = isqrt < 10 ? 10 : isqrt;\r\n  const nStart: i32 = ni + 2 * extra;\r\n  let jNext: f64 = 0.0;\r\n  let jCurr: f64 = 1.0;\r\n  let resultVal: f64 = 0.0;\r\n  let sum: f64 = 0.0;\r\n  for (let k: i32 = nStart; k >= 0; k--) {\r\n    const jPrev: f64 = (2.0 * <f64>(k + 1) / x) * jCurr - jNext;\r\n    jNext = jCurr;\r\n    jCurr = jPrev;\r\n    if (k == ni) resultVal = jNext;\r\n    if (k % 2 == 0) sum += jCurr;\r\n  }\r\n  sum = 2.0 * sum - jCurr;\r\n  return sign * (resultVal / sum);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Bessel Yn scalar (general integer order, forward recurrence; x > 0)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _besselYn(n: i32, x: f64): f64 {\r\n  if (x <= 0.0) return NaN;\r\n  const ni: i32 = n < 0 ? -n : n;\r\n  const sign: f64 = n < 0 && ni % 2 != 0 ? -1.0 : 1.0;\r\n  if (ni == 0) return sign * _besselY0(x);\r\n  if (ni == 1) return sign * _besselY1(x);\r\n  let yPrev: f64 = _besselY0(x);\r\n  let yCurr: f64 = _besselY1(x);\r\n  for (let k: i32 = 1; k < ni; k++) {\r\n    const yNext: f64 = (2.0 * <f64>k / x) * yCurr - yPrev;\r\n    yPrev = yCurr;\r\n    yCurr = yNext;\r\n  }\r\n  return sign * yCurr;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Airy scalars — power series + asymptotic expansion\r\n//\r\n// Algorithm follows wasm-rust/crates/mathts-wasm/src/special/functions.rs.\r\n// c_k coefficients: c_k = Γ(3k+1/2) / (54^k · k! · Γ(k+1/2))  (DLMF §9.7.1)\r\n//\r\n// Ai(0) = c1 ≈ 0.35502805388781724\r\n// −Ai'(0) = c2 ≈ 0.25881940379280680\r\n// ---------------------------------------------------------------------------\r\n\r\nconst AIRY_C0: f64 = 1.0;\r\nconst AIRY_C1: f64 = 5.0 / 72.0;\r\nconst AIRY_C2: f64 = 385.0 / 10368.0;\r\nconst AIRY_C3: f64 = 85085.0 / 2239488.0;\r\nconst AIRY_C4: f64 = 37182145.0 / 644972544.0;\r\nconst AIRY_C5: f64 = 5765760010.25 / 61917364224.0;\r\nconst AIRY_C6: f64 = 1519768071625.0 / 8918845788160.0;\r\n\r\n// Ai(0)\r\nconst AI0: f64 = 0.35502805388781723926;\r\n// −Ai′(0)\r\nconst AI_PRIME0: f64 = 0.25881940379280679841;\r\n// threshold for switching to asymptotic\r\nconst XBIG: f64 = 4.5;\r\n\r\nfunction _airyAiAsymptoteLargePos(x: f64): f64 {\r\n  const xp: f64 = Math.pow(x, 0.25);\r\n  const x32: f64 = x * Math.sqrt(x);\r\n  const zeta: f64 = (2.0 / 3.0) * x32;\r\n  // alternating asymptotic series Σ (-1)^k c_k / ζ^k\r\n  let p: f64 = AIRY_C0;\r\n  let zk: f64 = zeta;\r\n  p -= AIRY_C1 / zk; zk *= zeta;\r\n  p += AIRY_C2 / zk; zk *= zeta;\r\n  p -= AIRY_C3 / zk; zk *= zeta;\r\n  p += AIRY_C4 / zk; zk *= zeta;\r\n  p -= AIRY_C5 / zk; zk *= zeta;\r\n  p += AIRY_C6 / zk;\r\n  return Math.exp(-zeta) * p / (2.0 * Math.sqrt(Math.PI) * xp);\r\n}\r\n\r\nfunction _airyAiAsymptoteLargeNeg(x: f64): f64 {\r\n  const ax: f64 = Math.abs(x);\r\n  const axp: f64 = Math.pow(ax, 0.25);\r\n  const ax32: f64 = ax * Math.sqrt(ax);\r\n  const zeta: f64 = (2.0 / 3.0) * ax32;\r\n  // theta = ζ - π/4 for Ai\r\n  const theta: f64 = zeta - Math.PI / 4.0;\r\n  let p: f64 = AIRY_C0; // even terms\r\n  let q: f64 = 0.0;     // odd terms\r\n  let zk: f64 = zeta;\r\n  // k=1 odd: -c1/ζ\r\n  q -= AIRY_C1 / zk; zk *= zeta;\r\n  // k=2 even: +c2/ζ²\r\n  p += AIRY_C2 / zk; zk *= zeta;\r\n  // k=3 odd: -c3/ζ³\r\n  q -= AIRY_C3 / zk; zk *= zeta;\r\n  // k=4 even: +c4/ζ⁴\r\n  p += AIRY_C4 / zk; zk *= zeta;\r\n  // k=5 odd: -c5/ζ⁵\r\n  q -= AIRY_C5 / zk; zk *= zeta;\r\n  // k=6 even: +c6/ζ⁶\r\n  p += AIRY_C6 / zk;\r\n  return (Math.sin(theta) * p + Math.cos(theta) * q) / (Math.sqrt(Math.PI) * axp);\r\n}\r\n\r\nfunction _airyBiAsymptoteLargePos(x: f64): f64 {\r\n  const xp: f64 = Math.pow(x, 0.25);\r\n  const x32: f64 = x * Math.sqrt(x);\r\n  const zeta: f64 = (2.0 / 3.0) * x32;\r\n  // all-positive series Σ c_k / ζ^k for Bi growing branch\r\n  let p: f64 = AIRY_C0;\r\n  let zk: f64 = zeta;\r\n  p += AIRY_C1 / zk; zk *= zeta;\r\n  p += AIRY_C2 / zk; zk *= zeta;\r\n  p += AIRY_C3 / zk; zk *= zeta;\r\n  p += AIRY_C4 / zk; zk *= zeta;\r\n  p += AIRY_C5 / zk; zk *= zeta;\r\n  p += AIRY_C6 / zk;\r\n  return Math.exp(zeta) * p / (Math.sqrt(Math.PI) * xp);\r\n}\r\n\r\nfunction _airyBiAsymptoteLargeNeg(x: f64): f64 {\r\n  const ax: f64 = Math.abs(x);\r\n  const axp: f64 = Math.pow(ax, 0.25);\r\n  const ax32: f64 = ax * Math.sqrt(ax);\r\n  const zeta: f64 = (2.0 / 3.0) * ax32;\r\n  // theta = ζ + π/4 for Bi (DLMF §9.7.5)\r\n  const theta: f64 = zeta + Math.PI / 4.0;\r\n  let p: f64 = AIRY_C0;\r\n  let q: f64 = 0.0;\r\n  let zk: f64 = zeta;\r\n  q -= AIRY_C1 / zk; zk *= zeta;\r\n  p += AIRY_C2 / zk; zk *= zeta;\r\n  q -= AIRY_C3 / zk; zk *= zeta;\r\n  p += AIRY_C4 / zk; zk *= zeta;\r\n  q -= AIRY_C5 / zk; zk *= zeta;\r\n  p += AIRY_C6 / zk;\r\n  return (Math.cos(theta) * p + Math.sin(theta) * q) / (Math.sqrt(Math.PI) * axp);\r\n}\r\n\r\nfunction _airyAiSeries(x: f64): f64 {\r\n  const x3: f64 = x * x * x;\r\n  let f: f64 = 1.0;\r\n  let g: f64 = x;\r\n  let fTerm: f64 = 1.0;\r\n  let gTerm: f64 = x;\r\n  let factF: f64 = 1.0; // (3k)!\r\n  let factG: f64 = 1.0; // (3k+1)!\r\n  let prodF: f64 = 1.0; // Π(3j-2)\r\n  let prodG: f64 = 1.0; // Π(3j-1)\r\n  for (let k: i32 = 1; k <= 30; k++) {\r\n    const kf: f64 = <f64>k;\r\n    factF *= (3.0 * kf - 2.0) * (3.0 * kf - 1.0) * (3.0 * kf);\r\n    factG *= (3.0 * kf - 1.0) * (3.0 * kf) * (3.0 * kf + 1.0);\r\n    prodF *= 3.0 * kf - 2.0;\r\n    prodG *= 3.0 * kf - 1.0;\r\n    fTerm *= x3;\r\n    gTerm *= x3;\r\n    const df: f64 = fTerm * prodF / factF;\r\n    const dg: f64 = gTerm * prodG / factG;\r\n    f += df;\r\n    g += dg;\r\n    if (Math.abs(df) < Math.abs(f) * 1e-16 && Math.abs(dg) < Math.abs(g) * 1e-16) break;\r\n  }\r\n  return AI0 * f - AI_PRIME0 * g;\r\n}\r\n\r\nfunction _airyBiSeries(x: f64): f64 {\r\n  const x3: f64 = x * x * x;\r\n  let f: f64 = 1.0;\r\n  let g: f64 = x;\r\n  let fTerm: f64 = 1.0;\r\n  let gTerm: f64 = x;\r\n  let factF: f64 = 1.0;\r\n  let factG: f64 = 1.0;\r\n  let prodF: f64 = 1.0;\r\n  let prodG: f64 = 1.0;\r\n  for (let k: i32 = 1; k <= 30; k++) {\r\n    const kf: f64 = <f64>k;\r\n    factF *= (3.0 * kf - 2.0) * (3.0 * kf - 1.0) * (3.0 * kf);\r\n    factG *= (3.0 * kf - 1.0) * (3.0 * kf) * (3.0 * kf + 1.0);\r\n    prodF *= 3.0 * kf - 2.0;\r\n    prodG *= 3.0 * kf - 1.0;\r\n    fTerm *= x3;\r\n    gTerm *= x3;\r\n    const df: f64 = fTerm * prodF / factF;\r\n    const dg: f64 = gTerm * prodG / factG;\r\n    f += df;\r\n    g += dg;\r\n    if (Math.abs(df) < Math.abs(f) * 1e-16 && Math.abs(dg) < Math.abs(g) * 1e-16) break;\r\n  }\r\n  return Math.sqrt(3.0) * (AI0 * f + AI_PRIME0 * g);\r\n}\r\n\r\nfunction _airyAi(x: f64): f64 {\r\n  if (x > XBIG) return _airyAiAsymptoteLargePos(x);\r\n  if (x < -XBIG) return _airyAiAsymptoteLargeNeg(x);\r\n  return _airyAiSeries(x);\r\n}\r\n\r\nfunction _airyBi(x: f64): f64 {\r\n  if (x > XBIG) return _airyBiAsymptoteLargePos(x);\r\n  if (x < -XBIG) return _airyBiAsymptoteLargeNeg(x);\r\n  return _airyBiSeries(x);\r\n}\r\n\r\n// ===========================================================================\r\n// Array exports — Bessel\r\n// ===========================================================================\r\n\r\n/** Apply J0 element-wise.  Returns zero-length array if xs is empty. */\r\nexport function bessel_j0_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselJ0(xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply J1 element-wise. */\r\nexport function bessel_j1_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselJ1(xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply J_n element-wise (fixed integer order n). */\r\nexport function bessel_jn_f64(n: i32, xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselJn(n, xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply Y0 element-wise (NaN for x ≤ 0). */\r\nexport function bessel_y0_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselY0(xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply Y1 element-wise (NaN for x ≤ 0). */\r\nexport function bessel_y1_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselY1(xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply Y_n element-wise (fixed integer order n; NaN for x ≤ 0). */\r\nexport function bessel_yn_f64(n: i32, xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _besselYn(n, xs[i]);\r\n  return out;\r\n}\r\n\r\n// ===========================================================================\r\n// Array exports — Airy\r\n// ===========================================================================\r\n\r\n/** Apply Ai(x) element-wise. */\r\nexport function airy_ai_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _airyAi(xs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply Bi(x) element-wise. */\r\nexport function airy_bi_f64(xs: Float64Array): Float64Array {\r\n  const out = new Float64Array(xs.length);\r\n  for (let i: i32 = 0; i < xs.length; i++) out[i] = _airyBi(xs[i]);\r\n  return out;\r\n}\r\n\r\n// ===========================================================================\r\n// Complete Elliptic Integrals K(m) and E(m) via AGM (Slice 5.3)\r\n//\r\n// K(m) = π / (2 · agm(1, √(1−m)))\r\n//\r\n// E(m) via Carlson-Bulirsch AGM:\r\n//   a₀ = 1, b₀ = √(1−m), c₀ = √m\r\n//   iterate until convergence (quadratic — ~10 steps for f64)\r\n//   E = K · (1 − ½ · Σ 2^k · c_k²)\r\n//\r\n// Domain: m ∈ [0, 1).  K(1) = +∞, E(1) = 1.  m < 0 or m > 1 → NaN.\r\n// ===========================================================================\r\n\r\nfunction _ellipticK(m: f64): f64 {\r\n  if (isNaN(m)) return NaN;\r\n  if (m < 0.0 || m > 1.0) return NaN;\r\n  if (m == 1.0) return Infinity;\r\n  if (m == 0.0) return Math.PI / 2.0;\r\n  let a: f64 = 1.0;\r\n  let b: f64 = Math.sqrt(1.0 - m);\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const aNew: f64 = (a + b) / 2.0;\r\n    const bNew: f64 = Math.sqrt(a * b);\r\n    if (Math.abs(aNew - bNew) < 1e-16 * aNew) {\r\n      a = aNew;\r\n      break;\r\n    }\r\n    a = aNew;\r\n    b = bNew;\r\n  }\r\n  return Math.PI / (2.0 * a);\r\n}\r\n\r\nfunction _ellipticE(m: f64): f64 {\r\n  if (isNaN(m)) return NaN;\r\n  if (m < 0.0 || m > 1.0) return NaN;\r\n  if (m == 0.0) return Math.PI / 2.0;\r\n  if (m == 1.0) return 1.0;\r\n  let a: f64 = 1.0;\r\n  let b: f64 = Math.sqrt(1.0 - m);\r\n  let c: f64 = Math.sqrt(m);\r\n  let sum: f64 = c * c; // 2^0 · c₀²\r\n  let pow2: f64 = 1.0;\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const aNew: f64 = (a + b) / 2.0;\r\n    const bNew: f64 = Math.sqrt(a * b);\r\n    const cNew: f64 = (a - b) / 2.0;\r\n    pow2 *= 2.0;\r\n    sum += pow2 * cNew * cNew;\r\n    if (Math.abs(cNew) < 1e-16 * aNew) {\r\n      a = aNew;\r\n      break;\r\n    }\r\n    a = aNew;\r\n    b = bNew;\r\n    c = cNew;\r\n  }\r\n  const k: f64 = Math.PI / (2.0 * a);\r\n  return k * (1.0 - 0.5 * sum);\r\n}\r\n\r\n// ===========================================================================\r\n// Array exports — Elliptic K / E\r\n// ===========================================================================\r\n\r\n/** Apply K(m) element-wise.  Domain: m ∈ [0,1).  K(1)=+∞.  Out-of-domain → NaN. */\r\nexport function elliptic_k_f64(ms: Float64Array): Float64Array {\r\n  const out = new Float64Array(ms.length);\r\n  for (let i: i32 = 0; i < ms.length; i++) out[i] = _ellipticK(ms[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply E(m) element-wise.  Domain: m ∈ [0,1].  E(1)=1.  Out-of-domain → NaN. */\r\nexport function elliptic_e_f64(ms: Float64Array): Float64Array {\r\n  const out = new Float64Array(ms.length);\r\n  for (let i: i32 = 0; i < ms.length; i++) out[i] = _ellipticE(ms[i]);\r\n  return out;\r\n}\r\n\r\n// ===========================================================================\r\n// Carlson Symmetric Forms — Slice 6.4\r\n//\r\n// Mirrors wasm-rust/crates/mathts-wasm/src/special/functions.rs :: carlson_*.\r\n// Duplication-theorem iterative algorithm (Numerical Recipes §6.11).\r\n// Tolerance 0.0015 per NR; ≤ 30 iterations for f64 precision.\r\n// ===========================================================================\r\n\r\nfunction _carlsonRC(x: f64, y: f64): f64 {\r\n  // RC is RF(x, y, y) — pure duplication, no external sum accumulation.\r\n  // Algorithm: Carlson (1995) §2, duplication theorem for RC.\r\n  // Reference: DLMF §19.20.3 — RC(x, y) = (1/2)∫_0^∞ (t+x)^{-1/2}(t+y)^{-1} dt\r\n  if (x < 0.0 || y <= 0.0) return NaN;\r\n  let xx: f64 = x;\r\n  let yy: f64 = y;\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const lam: f64 = 2.0 * Math.sqrt(xx * yy) + yy;\r\n    xx = (xx + lam) / 4.0;\r\n    yy = (yy + lam) / 4.0;\r\n    const ave: f64 = (xx + 2.0 * yy) / 3.0;\r\n    const dx: f64 = (ave - xx) / ave;\r\n    const dy: f64 = (ave - yy) / ave;\r\n    if (Math.abs(dx) < 1e-10 && Math.abs(dy) < 1e-10) {\r\n      // Taylor series for RC (Carlson 1995, eq. 2.7)\r\n      const s: f64 = dx * dx * (3.0 + dx * (1.0 + dx * (0.75 + dx * (9.0 / 22.0))));\r\n      return (1.0 + s) / Math.sqrt(ave);\r\n    }\r\n  }\r\n  return 1.0 / Math.sqrt(yy);\r\n}\r\n\r\nfunction _carlsonRF(x: f64, y: f64, z: f64): f64 {\r\n  if (x < 0.0 || y < 0.0 || z < 0.0) return NaN;\r\n  let xx: f64 = x;\r\n  let yy: f64 = y;\r\n  let zz: f64 = z;\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const sx: f64 = Math.sqrt(xx);\r\n    const sy: f64 = Math.sqrt(yy);\r\n    const sz: f64 = Math.sqrt(zz);\r\n    const lam: f64 = sx * sy + sy * sz + sz * sx;\r\n    xx = (xx + lam) / 4.0;\r\n    yy = (yy + lam) / 4.0;\r\n    zz = (zz + lam) / 4.0;\r\n    const ave: f64 = (xx + yy + zz) / 3.0;\r\n    const dx: f64 = (ave - xx) / ave;\r\n    const dy: f64 = (ave - yy) / ave;\r\n    const dz: f64 = (ave - zz) / ave;\r\n    if (Math.abs(dx) < 1e-10 && Math.abs(dy) < 1e-10 && Math.abs(dz) < 1e-10) {\r\n      const e2: f64 = dx * dy - dz * dz;\r\n      const e3: f64 = dx * dy * dz;\r\n      return (1.0 + e2 * (-0.1 + e2 * (3.0 / 44.0) - e3 * (9.0 / 52.0)) + e3 / 14.0) /\r\n        Math.sqrt(ave);\r\n    }\r\n  }\r\n  return 1.0 / Math.sqrt(zz);\r\n}\r\n\r\nfunction _carlsonRD(x: f64, y: f64, z: f64): f64 {\r\n  if (x < 0.0 || y < 0.0 || z <= 0.0) return NaN;\r\n  if (x == 0.0 && y == 0.0) return NaN;\r\n  // Degenerate case: x=y=z — algorithm converges prematurely; return exact value.\r\n  if (x == y && y == z) return Math.pow(x, -1.5);\r\n  let xx: f64 = x;\r\n  let yy: f64 = y;\r\n  let zz: f64 = z;\r\n  let sum: f64 = 0.0;\r\n  let fac: f64 = 1.0;\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const sx: f64 = Math.sqrt(xx);\r\n    const sy: f64 = Math.sqrt(yy);\r\n    const sz: f64 = Math.sqrt(zz);\r\n    const lam: f64 = sx * sy + sy * sz + sz * sx;\r\n    sum += fac / (sz * (zz + lam));\r\n    fac /= 4.0;\r\n    xx = (xx + lam) / 4.0;\r\n    yy = (yy + lam) / 4.0;\r\n    zz = (zz + lam) / 4.0;\r\n    const ave: f64 = (xx + yy + 3.0 * zz) / 5.0;\r\n    const dx: f64 = (ave - xx) / ave;\r\n    const dy: f64 = (ave - yy) / ave;\r\n    const dz: f64 = (ave - zz) / ave;\r\n    if (Math.abs(dx) < 1e-10 && Math.abs(dy) < 1e-10 && Math.abs(dz) < 1e-10) {\r\n      const xy: f64 = dx * dy;\r\n      const xz: f64 = dx * dz;\r\n      const yz: f64 = dy * dz;\r\n      const z2: f64 = dz * dz;\r\n      const e2: f64 = xy - xz - yz - z2;\r\n      const e3: f64 = xy * dz + dz * (xz + yz);\r\n      const e4: f64 = xy * z2;\r\n      const e5: f64 = dz * z2 * dz;\r\n      return 3.0 * sum +\r\n        fac * (1.0 + e2 * (-3.0 / 14.0) + e3 / 6.0 + e2 * e2 * (9.0 / 88.0) +\r\n          e4 * (-45.0 / 132.0) - e5 * (5.0 / 44.0) + e3 * e2 * (-3.0 / 44.0)) /\r\n        (ave * ave * Math.sqrt(ave));\r\n    }\r\n  }\r\n  return 3.0 * sum + fac / (zz * zz * Math.sqrt(zz));\r\n}\r\n\r\nfunction _carlsonRJ(x: f64, y: f64, z: f64, p: f64): f64 {\r\n  if (x < 0.0 || y < 0.0 || z < 0.0 || p == 0.0) return NaN;\r\n  let xx: f64 = x;\r\n  let yy: f64 = y;\r\n  let zz: f64 = z;\r\n  let pp: f64 = p;\r\n  let sum: f64 = 0.0;\r\n  let fac: f64 = 1.0;\r\n  for (let i: i32 = 0; i < 50; i++) {\r\n    const sx: f64 = Math.sqrt(xx);\r\n    const sy: f64 = Math.sqrt(yy);\r\n    const sz: f64 = Math.sqrt(zz);\r\n    const lam: f64 = sx * sy + sy * sz + sz * sx;\r\n    const alpha: f64 = pp * (sx + sy + sz) + sx * sy * sz;\r\n    const alpha2: f64 = alpha * alpha;\r\n    const beta: f64 = pp * (pp + lam) * (pp + lam);\r\n    sum += fac * _carlsonRC(alpha2, beta);\r\n    fac /= 4.0;\r\n    xx = (xx + lam) / 4.0;\r\n    yy = (yy + lam) / 4.0;\r\n    zz = (zz + lam) / 4.0;\r\n    pp = (pp + lam) / 4.0;\r\n    const ave: f64 = (xx + yy + zz + pp + pp) / 5.0;\r\n    const dx: f64 = (ave - xx) / ave;\r\n    const dy: f64 = (ave - yy) / ave;\r\n    const dz: f64 = (ave - zz) / ave;\r\n    const dp: f64 = (ave - pp) / ave;\r\n    if (Math.abs(dx) < 1e-10 && Math.abs(dy) < 1e-10 &&\r\n        Math.abs(dz) < 1e-10 && Math.abs(dp) < 1e-10) {\r\n      const xyz: f64 = dx * dy + dy * dz + dz * dx;\r\n      const p2: f64 = dp * dp;\r\n      const e2: f64 = xyz - 3.0 * p2;\r\n      const e3: f64 = dx * dy * dz + 2.0 * xyz * dp - 3.0 * p2 * dp;\r\n      const e4: f64 = (2.0 * dx * dy * dz + xyz * dp + 3.0 * p2 * dp) * dp;\r\n      const e5: f64 = dx * dy * dz * p2;\r\n      return 3.0 * sum +\r\n        fac * (1.0 + e2 * (-3.0 / 14.0) + e3 / 6.0 + e2 * e2 * (9.0 / 88.0) -\r\n          e4 * (45.0 / 132.0) + e5 * (-5.0 / 44.0) + e3 * e2 * (-3.0 / 44.0)) /\r\n        (ave * ave * Math.sqrt(ave));\r\n    }\r\n  }\r\n  return 3.0 * sum + fac / (pp * pp * Math.sqrt(pp));\r\n}\r\n\r\n// ===========================================================================\r\n// Incomplete elliptic integrals via Carlson forms (Slice 6.4)\r\n//\r\n// DLMF §19.25 Legendre–Carlson identities:\r\n//   F(φ, m) = sin(φ) · RF(cos²φ, 1−m·sin²φ, 1)\r\n//   E(φ, m) = sin(φ) · RF(c², 1−m·s², 1) − (m/3)·s³ · RD(c², 1−m·s², 1)\r\n//   Π(n,φ,m) = sin(φ) · RF(c², 1−m·s², 1) + (n/3)·s³ · RJ(c², 1−m·s², 1, 1−n·s²)\r\n// ===========================================================================\r\n\r\nfunction _ellipticFIncomplete(phi: f64, m: f64): f64 {\r\n  if (phi == 0.0) return 0.0;\r\n  const s: f64 = Math.sin(phi);\r\n  const c: f64 = Math.cos(phi);\r\n  const s2: f64 = s * s;\r\n  const y: f64 = 1.0 - m * s2;\r\n  if (y < 0.0) return NaN;\r\n  return s * _carlsonRF(c * c, y, 1.0);\r\n}\r\n\r\nfunction _ellipticEIncomplete(phi: f64, m: f64): f64 {\r\n  if (phi == 0.0) return 0.0;\r\n  const s: f64 = Math.sin(phi);\r\n  const c: f64 = Math.cos(phi);\r\n  const s2: f64 = s * s;\r\n  const c2: f64 = c * c;\r\n  const y: f64 = 1.0 - m * s2;\r\n  if (y < 0.0) return NaN;\r\n  return s * _carlsonRF(c2, y, 1.0) - (m / 3.0) * s * s2 * _carlsonRD(c2, y, 1.0);\r\n}\r\n\r\nfunction _ellipticPiIncomplete(n: f64, phi: f64, m: f64): f64 {\r\n  if (phi == 0.0) return 0.0;\r\n  const s: f64 = Math.sin(phi);\r\n  const c: f64 = Math.cos(phi);\r\n  const s2: f64 = s * s;\r\n  const c2: f64 = c * c;\r\n  const y: f64 = 1.0 - m * s2;\r\n  const q: f64 = 1.0 - n * s2;\r\n  if (y < 0.0 || q <= 0.0) return NaN;\r\n  return s * _carlsonRF(c2, y, 1.0) + (n / 3.0) * s * s2 * _carlsonRJ(c2, y, 1.0, q);\r\n}\r\n\r\n// ===========================================================================\r\n// Array exports — Carlson forms (Slice 6.4)\r\n// Typed-array calling convention: all input arrays must have the same length.\r\n// ===========================================================================\r\n\r\n/** Apply RC(x, y) element-wise. */\r\nexport function carlson_rc_f64(xs: Float64Array, ys: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _carlsonRC(xs[i], ys[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply RF(x, y, z) element-wise. */\r\nexport function carlson_rf_f64(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _carlsonRF(xs[i], ys[i], zs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply RD(x, y, z) element-wise. */\r\nexport function carlson_rd_f64(xs: Float64Array, ys: Float64Array, zs: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _carlsonRD(xs[i], ys[i], zs[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply RJ(x, y, z, p) element-wise. */\r\nexport function carlson_rj_f64(xs: Float64Array, ys: Float64Array, zs: Float64Array, ps: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _carlsonRJ(xs[i], ys[i], zs[i], ps[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply F(φ, m) element-wise. */\r\nexport function elliptic_f_incomplete_f64(phis: Float64Array, ms: Float64Array): Float64Array {\r\n  const n: i32 = phis.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _ellipticFIncomplete(phis[i], ms[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply E(φ, m) (incomplete) element-wise. */\r\nexport function elliptic_e_incomplete_f64(phis: Float64Array, ms: Float64Array): Float64Array {\r\n  const n: i32 = phis.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _ellipticEIncomplete(phis[i], ms[i]);\r\n  return out;\r\n}\r\n\r\n/** Apply Π(n, φ, m) element-wise. */\r\nexport function elliptic_pi_incomplete_f64(ns: Float64Array, phis: Float64Array, ms: Float64Array): Float64Array {\r\n  const n: i32 = ns.length;\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) out[i] = _ellipticPiIncomplete(ns[i], phis[i], ms[i]);\r\n  return out;\r\n}\r\n","//\n// Lookup data for exp2f\n//\n\n// @ts-ignore: decorator\n@inline const EXP2F_TABLE_BITS = 5;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP2F_DATA_TAB = memory.data<u64>([\n  // exp2f_data_tab[i] = uint(2^(i/N)) - (i << 52-BITS)\n  // used for computing 2^(k/N) for an int |k| < 150 N as\n  // double(tab[k%N] + (k << 52-BITS))\n  0x3FF0000000000000, 0x3FEFD9B0D3158574, 0x3FEFB5586CF9890F, 0x3FEF9301D0125B51,\n  0x3FEF72B83C7D517B, 0x3FEF54873168B9AA, 0x3FEF387A6E756238, 0x3FEF1E9DF51FDEE1,\n  0x3FEF06FE0A31B715, 0x3FEEF1A7373AA9CB, 0x3FEEDEA64C123422, 0x3FEECE086061892D,\n  0x3FEEBFDAD5362A27, 0x3FEEB42B569D4F82, 0x3FEEAB07DD485429, 0x3FEEA47EB03A5585,\n  0x3FEEA09E667F3BCD, 0x3FEE9F75E8EC5F74, 0x3FEEA11473EB0187, 0x3FEEA589994CCE13,\n  0x3FEEACE5422AA0DB, 0x3FEEB737B0CDC5E5, 0x3FEEC49182A3F090, 0x3FEED503B23E255D,\n  0x3FEEE89F995AD3AD, 0x3FEEFF76F2FB5E47, 0x3FEF199BDD85529C, 0x3FEF3720DCEF9069,\n  0x3FEF5818DCFBA487, 0x3FEF7C97337B9B5F, 0x3FEFA4AFA2A490DA, 0x3FEFD0765B6E4540\n]);\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-1/64, 1/64] (before rounding.)\n// Wrong count: 168353 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function exp2f_lut(x: f32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N, // 0x1.8p+52\n    Ox127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  let xd = <f64>x;\n  let ix = reinterpret<u32>(x);\n  let ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x430) {\n    // |x| >= 128 or x is nan.\n    if (ix == 0xFF800000) return 0; // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;  // x == Inf/NaN -> Inf/NaN\n    if (x > 0) return x * Ox127f;   // x >     0    -> HugeVal (Owerflow)\n    if (x <= -150) return 0;        // x <= -150    -> 0 (Underflow)\n  }\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)] and int k.\n  let kd = xd + shift;\n  let ki = reinterpret<u64>(kd);\n  let r  = xd - (kd - shift);\n  let t: u64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  y  = C2 * r + 1;\n  y += (C0 * r + C1) * (r  * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n// ULP error: 0.502 (nearest rounding.)\n// Relative error: 1.69 * 2^-34 in [-ln2/64, ln2/64] (before rounding.)\n// Wrong count: 170635 (all nearest rounding wrong results with fma.)\n// @ts-ignore: decorator\n@inline\nexport function expf_lut(x: f32): f32 {\n  const\n    N        = 1 << EXP2F_TABLE_BITS,\n    N_MASK   = N - 1,\n    shift    = reinterpret<f64>(0x4338000000000000),        // 0x1.8p+52\n    InvLn2N  = reinterpret<f64>(0x3FF71547652B82FE) * N,    // 0x1.71547652b82fep+0\n    Ox1p127f = reinterpret<f32>(0x7F000000);\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394) / N / N / N, // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3) / N / N,     // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6) / N;         // 0x1.62e42ff0c52d6p-1\n\n  let xd = <f64>x;\n  let ix = reinterpret<u32>(x);\n  let ux = ix >> 20 & 0x7FF;\n  if (ux >= 0x42B) {\n    // |x| >= 88 or x is nan.\n    if (ix == 0xFF800000) return 0;                            // x == -Inf    -> 0\n    if (ux >= 0x7F8) return x + x;                             // x == Inf/NaN -> Inf/NaN\n    if (x > reinterpret<f32>(0x42B17217)) return x * Ox1p127f; // x > log(0x1p128)  ~=  88.72 -> HugeVal (Owerflow)\n    if (x < reinterpret<f32>(0xC2CFF1B4)) return 0;            // x < log(0x1p-150) ~= -103.97 -> 0 (Underflow)\n  }\n\n  // x*N/Ln2 = k + r with r in [-1/2, 1/2] and int k.\n  let z = InvLn2N * xd;\n\n  // Round and convert z to int, the result is in [-150*N, 128*N] and\n  // ideally ties-to-even rule is used, otherwise the magnitude of r\n  // can be bigger which gives larger approximation error.\n  let kd = <f64>(z + shift);\n  let ki = reinterpret<u64>(kd);\n  let r  = z - (kd - shift);\n  let s: f64, y: f64, t: u64;\n\n  // exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += ki << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for log2f\n//\n\n// @ts-ignore: decorator\n@inline const LOG2F_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2F_DATA_TAB = memory.data<u64>([\n  0x3FF661EC79F8F3BE, 0xBFDEFEC65B963019, // 0x1.661ec79f8f3bep+0, -0x1.efec65b963019p-2,\n  0x3FF571ED4AAF883D, 0xBFDB0B6832D4FCA4, // 0x1.571ed4aaf883dp+0, -0x1.b0b6832d4fca4p-2,\n  0x3FF49539F0F010B0, 0xBFD7418B0A1FB77B, // 0x1.49539f0f010bp+0 , -0x1.7418b0a1fb77bp-2,\n  0x3FF3C995B0B80385, 0xBFD39DE91A6DCF7B, // 0x1.3c995b0b80385p+0, -0x1.39de91a6dcf7bp-2,\n  0x3FF30D190C8864A5, 0xBFD01D9BF3F2B631, // 0x1.30d190c8864a5p+0, -0x1.01d9bf3f2b631p-2,\n  0x3FF25E227B0B8EA0, 0xBFC97C1D1B3B7AF0, // 0x1.25e227b0b8eap+0 , -0x1.97c1d1b3b7afp-3 ,\n  0x3FF1BB4A4A1A343F, 0xBFC2F9E393AF3C9F, // 0x1.1bb4a4a1a343fp+0, -0x1.2f9e393af3c9fp-3,\n  0x3FF12358F08AE5BA, 0xBFB960CBBF788D5C, // 0x1.12358f08ae5bap+0, -0x1.960cbbf788d5cp-4,\n  0x3FF0953F419900A7, 0xBFAA6F9DB6475FCE, // 0x1.0953f419900a7p+0, -0x1.a6f9db6475fcep-5,\n  0x3FF0000000000000, 0,                  // 0x1p+0,                0x0,\n  0x3FEE608CFD9A47AC, 0x3FB338CA9F24F53D, // 0x1.e608cfd9a47acp-1,  0x1.338ca9f24f53dp-4,\n  0x3FECA4B31F026AA0, 0x3FC476A9543891BA, // 0x1.ca4b31f026aap-1 ,  0x1.476a9543891bap-3,\n  0x3FEB2036576AFCE6, 0x3FCE840B4AC4E4D2, // 0x1.b2036576afce6p-1,  0x1.e840b4ac4e4d2p-3,\n  0x3FE9C2D163A1AA2D, 0x3FD40645F0C6651C, // 0x1.9c2d163a1aa2dp-1,  0x1.40645f0c6651cp-2,\n  0x3FE886E6037841ED, 0x3FD88E9C2C1B9FF8, // 0x1.886e6037841edp-1,  0x1.88e9c2c1b9ff8p-2,\n  0x3FE767DCF5534862, 0x3FDCE0A44EB17BCC  // 0x1.767dcf5534862p-1,  0x1.ce0a44eb17bccp-2\n]);\n\n// ULP error: 0.752 (nearest rounding.)\n// Relative error: 1.9 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function log2f_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOG2F_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    A0 = reinterpret<f64>(0xBFD712B6F70A7E4D), // -0x1.712b6f70a7e4dp-2\n    A1 = reinterpret<f64>(0x3FDECABF496832E0), //  0x1.ecabf496832ep-2\n    A2 = reinterpret<f64>(0xBFE715479FFAE3DE), // -0x1.715479ffae3dep-1\n    A3 = reinterpret<f64>(0x3FF715475F35C8B8); //  0x1.715475f35c8b8p0\n\n  let ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && predict_false(ix == 0x3f800000)) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if (ux * 2 == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log2(inf) == inf.\n    if ((ux >> 31) || ux * 2 >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ux - 0x3F330000;\n  let i    = (tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK;\n  let top  = tmp & 0xFF800000;\n  let iz   = ux - top;\n  let k    = <i32>tmp >> 23;\n\n  let invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  let z    = <f64>reinterpret<f32>(iz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  let r  = z * invc - 1;\n  let y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  let y  = A1 * r + A2;\n  let p  = A3 * r + y0;\n  let r2 = r * r;\n  y += A0 * r2;\n  y  = y * r2 + p;\n\n  return <f32>y;\n}\n\n//\n// Lookup data for logf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/logf.c\n//\n\n// @ts-ignore: decorator\n@inline const LOGF_TABLE_BITS = 4;\n\n// @ts-ignore: decorator\n@lazy @inline const LOGF_DATA_TAB = memory.data<u64>([\n  0x3FF661EC79F8F3BE, 0xBFD57BF7808CAADE, // 0x1.661ec79f8f3bep+0, -0x1.57bf7808caadep-2,\n  0x3FF571ED4AAF883D, 0xBFD2BEF0A7C06DDB, // 0x1.571ed4aaf883dp+0, -0x1.2bef0a7c06ddbp-2,\n  0x3FF49539F0F010B0, 0xBFD01EAE7F513A67, // 0x1.49539f0f010bp+0 , -0x1.01eae7f513a67p-2,\n  0x3FF3C995B0B80385, 0xBFCB31D8A68224E9, // 0x1.3c995b0b80385p+0, -0x1.b31d8a68224e9p-3,\n  0x3FF30D190C8864A5, 0xBFC6574F0AC07758, // 0x1.30d190c8864a5p+0, -0x1.6574f0ac07758p-3,\n  0x3FF25E227B0B8EA0, 0xBFC1AA2BC79C8100, // 0x1.25e227b0b8eap+0 , -0x1.1aa2bc79c81p-3  ,\n  0x3FF1BB4A4A1A343F, 0xBFBA4E76CE8C0E5E, // 0x1.1bb4a4a1a343fp+0, -0x1.a4e76ce8c0e5ep-4,\n  0x3FF12358F08AE5BA, 0xBFB1973C5A611CCC, // 0x1.12358f08ae5bap+0, -0x1.1973c5a611cccp-4,\n  0x3FF0953F419900A7, 0xBFA252F438E10C1E, // 0x1.0953f419900a7p+0, -0x1.252f438e10c1ep-5,\n  0x3FF0000000000000, 0,                  // 0x1p+0,                0,\n  0x3FEE608CFD9A47AC, 0x3FAAA5AA5DF25984, // 0x1.e608cfd9a47acp-1,  0x1.aa5aa5df25984p-5,\n  0x3FECA4B31F026AA0, 0x3FBC5E53AA362EB4, // 0x1.ca4b31f026aap-1 ,  0x1.c5e53aa362eb4p-4,\n  0x3FEB2036576AFCE6, 0x3FC526E57720DB08, // 0x1.b2036576afce6p-1,  0x1.526e57720db08p-3,\n  0x3FE9C2D163A1AA2D, 0x3FCBC2860D224770, // 0x1.9c2d163a1aa2dp-1,  0x1.bc2860d22477p-3 ,\n  0x3FE886E6037841ED, 0x3FD1058BC8A07EE1, // 0x1.886e6037841edp-1,  0x1.1058bc8a07ee1p-2,\n  0x3FE767DCF5534862, 0x3FD4043057B6EE09  // 0x1.767dcf5534862p-1,  0x1.4043057b6ee09p-2\n]);\n\n// ULP error: 0.818 (nearest rounding.)\n// Relative error: 1.957 * 2^-26 (before rounding.)\n// @ts-ignore: decorator\n@inline\nexport function logf_lut(x: f32): f32 {\n  const\n    N_MASK  = (1 << LOGF_TABLE_BITS) - 1,\n    Ox1p23f = reinterpret<f32>(0x4B000000); // 0x1p23f\n\n  const\n    Ln2 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1;\n    A0  = reinterpret<f64>(0xBFD00EA348B88334), // -0x1.00ea348b88334p-2\n    A1  = reinterpret<f64>(0x3FD5575B0BE00B6A), //  0x1.5575b0be00b6ap-2\n    A2  = reinterpret<f64>(0xBFDFFFFEF20A4123); // -0x1.ffffef20a4123p-2\n\n  let ux = reinterpret<u32>(x);\n  // Fix sign of zero with downward rounding when x==1.\n  // if (WANT_ROUNDING && ux == 0x3f800000) return 0;\n  if (ux - 0x00800000 >= 0x7F800000 - 0x00800000) {\n    // x < 0x1p-126 or inf or nan.\n    if ((ux << 1) == 0) return -Infinity;\n    if (ux == 0x7F800000) return x; // log(inf) == inf.\n    if ((ux >> 31) || (ux << 1) >= 0xFF000000) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ux = reinterpret<u32>(x * Ox1p23f);\n    ux -= 23 << 23;\n  }\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp = ux - 0x3F330000;\n  let i   = (tmp >> (23 - LOGF_TABLE_BITS)) & N_MASK;\n  let k   = <i32>tmp >> 23;\n  let iz  = ux - (tmp & 0x1FF << 23);\n\n  let invc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOGF_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n\n  let z = <f64>reinterpret<f32>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2\n  let r = z * invc - 1;\n  let y0 = logc + <f64>k * Ln2;\n\n  // Pipelined polynomial evaluation to approximate log1p(r).\n  let r2 = r * r;\n  let y  = A1 * r + A2;\n  y += A0 * r2;\n  y = y * r2 + (y0 + r);\n\n  return <f32>y;\n}\n\n//\n// Lookup data for powf. See: https://git.musl-libc.org/cgit/musl/tree/src/math/powf.c\n//\n\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnanf(ux: u32): bool {\n  return (ux << 1) - 1 >= (<u32>0x7f800000 << 1) - 1;\n}\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkintf(iy: u32): i32 {\n  let e = iy >> 23 & 0xFF;\n  if (e < 0x7F     ) return 0;\n  if (e > 0x7F + 23) return 2;\n  e = 1 << (0x7F + 23 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// Subnormal input is normalized so ix has negative biased exponent.\n// Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.\n// @ts-ignore: decorator\n@inline\nfunction log2f_inline(ux: u32): f64 {\n  const N_MASK = (1 << LOG2F_TABLE_BITS) - 1;\n\n  const\n    A0 = reinterpret<f64>(0x3FD27616C9496E0B), //  0x1.27616c9496e0bp-2\n    A1 = reinterpret<f64>(0xBFD71969A075C67A), // -0x1.71969a075c67ap-2\n    A2 = reinterpret<f64>(0x3FDEC70A6CA7BADD), //  0x1.ec70a6ca7baddp-2\n    A3 = reinterpret<f64>(0xBFE7154748BEF6C8), // -0x1.7154748bef6c8p-1\n    A4 = reinterpret<f64>(0x3FF71547652AB82B); //  0x1.71547652ab82bp+0\n\n  // x = 2^k z; where z is in range [OFF,2*OFF] and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ux - 0x3F330000;\n  let i    = usize((tmp >> (23 - LOG2F_TABLE_BITS)) & N_MASK);\n  let top  = tmp & 0xFF800000;\n  let uz   = ux - top;\n  let k    = <i32>top >> 23;\n\n  let invc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 0 << alignof<f64>());\n  let logc = load<f64>(LOG2F_DATA_TAB + (i << (1 + alignof<f64>())), 1 << alignof<f64>());\n  let z    = <f64>reinterpret<f32>(uz);\n\n  // log2(x) = log1p(z/c-1)/ln2 + log2(c) + k\n  let r  = z * invc - 1;\n  let y0 = logc + <f64>k;\n\n  // Pipelined polynomial evaluation to approximate log1p(r)/ln2.\n  let y = A0 * r + A1;\n  let p = A2 * r + A3;\n  let q = A4 * r + y0;\n\n  r *= r;\n  q += p * r;\n  y  = y * (r * r) + q;\n\n  return y;\n}\n\n// The output of log2 and thus the input of exp2 is either scaled by N\n// (in case of fast toint intrinsics) or not.  The unscaled xd must be\n// in [-1021,1023], sign_bias sets the sign of the result.\n// @ts-ignore: decorator\n@inline\nfunction exp2f_inline(xd: f64, signBias: u32): f32 {\n  const\n    N      = 1 << EXP2F_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p+52\n\n  const\n    C0 = reinterpret<f64>(0x3FAC6AF84B912394), // 0x1.c6af84b912394p-5\n    C1 = reinterpret<f64>(0x3FCEBFCE50FAC4F3), // 0x1.ebfce50fac4f3p-3\n    C2 = reinterpret<f64>(0x3FE62E42FF0C52D6); // 0x1.62e42ff0c52d6p-1\n\n  // x = k/N + r with r in [-1/(2N), 1/(2N)]\n  let kd = <f64>(xd + shift);\n  let ki = reinterpret<u64>(kd);\n  let r  = xd - (kd - shift);\n  let t: u64, z: f64, y: f64, s: f64;\n\n  // exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1)\n  t  = load<u64>(EXP2F_DATA_TAB + ((<usize>ki & N_MASK) << alignof<u64>()));\n  t += (ki + signBias) << (52 - EXP2F_TABLE_BITS);\n  s  = reinterpret<f64>(t);\n  z  = C0 * r + C1;\n  y  = C2 * r + 1;\n  y += z * (r * r);\n  y *= s;\n  return <f32>y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflowf(sign: u32, y: f32): f32 {\n  return select<f32>(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x70000000)); // 0x1p97f\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflowf(sign: u32): f32 {\n  return xflowf(sign, reinterpret<f32>(0x10000000)); // 0x1p-95f\n}\n\n// @ts-ignore: decorator\n@inline\nexport function powf_lut(x: f32, y: f32): f32 {\n  const\n    Ox1p23f     = reinterpret<f32>(0x4B000000), // 0x1p23f\n    UPPER_LIMIT = reinterpret<f64>(0x405FFFFFFFD1D571), // 0x1.fffffffd1d571p+6\n    LOWER_LIMIT = -150.0,\n    SIGN_BIAS   = 1 << (EXP2F_TABLE_BITS + 11);\n\n  let signBias: u32 = 0;\n  let ix = reinterpret<u32>(x);\n  let iy = reinterpret<u32>(y);\n  let ny = 0;\n\n  if (i32(ix - 0x00800000 >= 0x7f800000 - 0x00800000) | (ny = i32(zeroinfnanf(iy)))) {\n    // Either (x < 0x1p-126 or inf or nan) or (y is 0 or inf or nan).\n    if (ny) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3F800000) return NaN; // original: 1.0\n      if ((ix << 1) > (<u32>0x7F800000 << 1) || (iy << 1) > (<u32>0x7F800000 << 1)) return x + y;\n      if ((ix << 1) == (0x3F800000 << 1)) return NaN; // original: 1.0\n      if (((ix << 1) < (0x3F800000 << 1)) == !(iy >> 31)) return 0; // |x| < 1 && y==inf or |x| > 1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnanf(ix)) {\n      let x2 = x * x;\n      if ((ix >> 31) && checkintf(iy) == 1) x2 = -x2;\n      return <i32>iy < 0 ? 1 / x2 : x2;\n    }\n    // x and y are non-zero finite.\n    if (<i32>ix < 0) {\n      // Finite x < 0.\n      let yint = checkintf(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) signBias = SIGN_BIAS;\n      ix &= 0x7FFFFFFF;\n    }\n    if (ix < 0x00800000) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u32>(x * Ox1p23f);\n      ix &= 0x7FFFFFFF;\n      ix -= 23 << 23;\n    }\n  }\n  let logx = log2f_inline(ix);\n  let ylogx = y * logx; // cannot overflow, y is single prec.\n  if ((reinterpret<u64>(ylogx) >> 47 & 0xFFFF) >= 0x80BF) { // reinterpret<u64>(126.0) >> 47\n    // |y * log(x)| >= 126\n    if (ylogx  > UPPER_LIMIT) return oflowf(signBias); // overflow\n    if (ylogx <= LOWER_LIMIT) return uflowf(signBias); // underflow\n  }\n  return exp2f_inline(ylogx, signBias);\n}\n\n//\n// Lookup data for exp. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c\n//\n\n// @ts-ignore: decorator\n@inline const EXP_TABLE_BITS = 7;\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_DATA_TAB = memory.data<u64>([\n  0x0000000000000000, 0x3FF0000000000000,\n  0x3C9B3B4F1A88BF6E, 0x3FEFF63DA9FB3335,\n  0xBC7160139CD8DC5D, 0x3FEFEC9A3E778061,\n  0xBC905E7A108766D1, 0x3FEFE315E86E7F85,\n  0x3C8CD2523567F613, 0x3FEFD9B0D3158574,\n  0xBC8BCE8023F98EFA, 0x3FEFD06B29DDF6DE,\n  0x3C60F74E61E6C861, 0x3FEFC74518759BC8,\n  0x3C90A3E45B33D399, 0x3FEFBE3ECAC6F383,\n  0x3C979AA65D837B6D, 0x3FEFB5586CF9890F,\n  0x3C8EB51A92FDEFFC, 0x3FEFAC922B7247F7,\n  0x3C3EBE3D702F9CD1, 0x3FEFA3EC32D3D1A2,\n  0xBC6A033489906E0B, 0x3FEF9B66AFFED31B,\n  0xBC9556522A2FBD0E, 0x3FEF9301D0125B51,\n  0xBC5080EF8C4EEA55, 0x3FEF8ABDC06C31CC,\n  0xBC91C923B9D5F416, 0x3FEF829AAEA92DE0,\n  0x3C80D3E3E95C55AF, 0x3FEF7A98C8A58E51,\n  0xBC801B15EAA59348, 0x3FEF72B83C7D517B,\n  0xBC8F1FF055DE323D, 0x3FEF6AF9388C8DEA,\n  0x3C8B898C3F1353BF, 0x3FEF635BEB6FCB75,\n  0xBC96D99C7611EB26, 0x3FEF5BE084045CD4,\n  0x3C9AECF73E3A2F60, 0x3FEF54873168B9AA,\n  0xBC8FE782CB86389D, 0x3FEF4D5022FCD91D,\n  0x3C8A6F4144A6C38D, 0x3FEF463B88628CD6,\n  0x3C807A05B0E4047D, 0x3FEF3F49917DDC96,\n  0x3C968EFDE3A8A894, 0x3FEF387A6E756238,\n  0x3C875E18F274487D, 0x3FEF31CE4FB2A63F,\n  0x3C80472B981FE7F2, 0x3FEF2B4565E27CDD,\n  0xBC96B87B3F71085E, 0x3FEF24DFE1F56381,\n  0x3C82F7E16D09AB31, 0x3FEF1E9DF51FDEE1,\n  0xBC3D219B1A6FBFFA, 0x3FEF187FD0DAD990,\n  0x3C8B3782720C0AB4, 0x3FEF1285A6E4030B,\n  0x3C6E149289CECB8F, 0x3FEF0CAFA93E2F56,\n  0x3C834D754DB0ABB6, 0x3FEF06FE0A31B715,\n  0x3C864201E2AC744C, 0x3FEF0170FC4CD831,\n  0x3C8FDD395DD3F84A, 0x3FEEFC08B26416FF,\n  0xBC86A3803B8E5B04, 0x3FEEF6C55F929FF1,\n  0xBC924AEDCC4B5068, 0x3FEEF1A7373AA9CB,\n  0xBC9907F81B512D8E, 0x3FEEECAE6D05D866,\n  0xBC71D1E83E9436D2, 0x3FEEE7DB34E59FF7,\n  0xBC991919B3CE1B15, 0x3FEEE32DC313A8E5,\n  0x3C859F48A72A4C6D, 0x3FEEDEA64C123422,\n  0xBC9312607A28698A, 0x3FEEDA4504AC801C,\n  0xBC58A78F4817895B, 0x3FEED60A21F72E2A,\n  0xBC7C2C9B67499A1B, 0x3FEED1F5D950A897,\n  0x3C4363ED60C2AC11, 0x3FEECE086061892D,\n  0x3C9666093B0664EF, 0x3FEECA41ED1D0057,\n  0x3C6ECCE1DAA10379, 0x3FEEC6A2B5C13CD0,\n  0x3C93FF8E3F0F1230, 0x3FEEC32AF0D7D3DE,\n  0x3C7690CEBB7AAFB0, 0x3FEEBFDAD5362A27,\n  0x3C931DBDEB54E077, 0x3FEEBCB299FDDD0D,\n  0xBC8F94340071A38E, 0x3FEEB9B2769D2CA7,\n  0xBC87DECCDC93A349, 0x3FEEB6DAA2CF6642,\n  0xBC78DEC6BD0F385F, 0x3FEEB42B569D4F82,\n  0xBC861246EC7B5CF6, 0x3FEEB1A4CA5D920F,\n  0x3C93350518FDD78E, 0x3FEEAF4736B527DA,\n  0x3C7B98B72F8A9B05, 0x3FEEAD12D497C7FD,\n  0x3C9063E1E21C5409, 0x3FEEAB07DD485429,\n  0x3C34C7855019C6EA, 0x3FEEA9268A5946B7,\n  0x3C9432E62B64C035, 0x3FEEA76F15AD2148,\n  0xBC8CE44A6199769F, 0x3FEEA5E1B976DC09,\n  0xBC8C33C53BEF4DA8, 0x3FEEA47EB03A5585,\n  0xBC845378892BE9AE, 0x3FEEA34634CCC320,\n  0xBC93CEDD78565858, 0x3FEEA23882552225,\n  0x3C5710AA807E1964, 0x3FEEA155D44CA973,\n  0xBC93B3EFBF5E2228, 0x3FEEA09E667F3BCD,\n  0xBC6A12AD8734B982, 0x3FEEA012750BDABF,\n  0xBC6367EFB86DA9EE, 0x3FEE9FB23C651A2F,\n  0xBC80DC3D54E08851, 0x3FEE9F7DF9519484,\n  0xBC781F647E5A3ECF, 0x3FEE9F75E8EC5F74,\n  0xBC86EE4AC08B7DB0, 0x3FEE9F9A48A58174,\n  0xBC8619321E55E68A, 0x3FEE9FEB564267C9,\n  0x3C909CCB5E09D4D3, 0x3FEEA0694FDE5D3F,\n  0xBC7B32DCB94DA51D, 0x3FEEA11473EB0187,\n  0x3C94ECFD5467C06B, 0x3FEEA1ED0130C132,\n  0x3C65EBE1ABD66C55, 0x3FEEA2F336CF4E62,\n  0xBC88A1C52FB3CF42, 0x3FEEA427543E1A12,\n  0xBC9369B6F13B3734, 0x3FEEA589994CCE13,\n  0xBC805E843A19FF1E, 0x3FEEA71A4623C7AD,\n  0xBC94D450D872576E, 0x3FEEA8D99B4492ED,\n  0x3C90AD675B0E8A00, 0x3FEEAAC7D98A6699,\n  0x3C8DB72FC1F0EAB4, 0x3FEEACE5422AA0DB,\n  0xBC65B6609CC5E7FF, 0x3FEEAF3216B5448C,\n  0x3C7BF68359F35F44, 0x3FEEB1AE99157736,\n  0xBC93091FA71E3D83, 0x3FEEB45B0B91FFC6,\n  0xBC5DA9B88B6C1E29, 0x3FEEB737B0CDC5E5,\n  0xBC6C23F97C90B959, 0x3FEEBA44CBC8520F,\n  0xBC92434322F4F9AA, 0x3FEEBD829FDE4E50,\n  0xBC85CA6CD7668E4B, 0x3FEEC0F170CA07BA,\n  0x3C71AFFC2B91CE27, 0x3FEEC49182A3F090,\n  0x3C6DD235E10A73BB, 0x3FEEC86319E32323,\n  0xBC87C50422622263, 0x3FEECC667B5DE565,\n  0x3C8B1C86E3E231D5, 0x3FEED09BEC4A2D33,\n  0xBC91BBD1D3BCBB15, 0x3FEED503B23E255D,\n  0x3C90CC319CEE31D2, 0x3FEED99E1330B358,\n  0x3C8469846E735AB3, 0x3FEEDE6B5579FDBF,\n  0xBC82DFCD978E9DB4, 0x3FEEE36BBFD3F37A,\n  0x3C8C1A7792CB3387, 0x3FEEE89F995AD3AD,\n  0xBC907B8F4AD1D9FA, 0x3FEEEE07298DB666,\n  0xBC55C3D956DCAEBA, 0x3FEEF3A2B84F15FB,\n  0xBC90A40E3DA6F640, 0x3FEEF9728DE5593A,\n  0xBC68D6F438AD9334, 0x3FEEFF76F2FB5E47,\n  0xBC91EEE26B588A35, 0x3FEF05B030A1064A,\n  0x3C74FFD70A5FDDCD, 0x3FEF0C1E904BC1D2,\n  0xBC91BDFBFA9298AC, 0x3FEF12C25BD71E09,\n  0x3C736EAE30AF0CB3, 0x3FEF199BDD85529C,\n  0x3C8EE3325C9FFD94, 0x3FEF20AB5FFFD07A,\n  0x3C84E08FD10959AC, 0x3FEF27F12E57D14B,\n  0x3C63CDAF384E1A67, 0x3FEF2F6D9406E7B5,\n  0x3C676B2C6C921968, 0x3FEF3720DCEF9069,\n  0xBC808A1883CCB5D2, 0x3FEF3F0B555DC3FA,\n  0xBC8FAD5D3FFFFA6F, 0x3FEF472D4A07897C,\n  0xBC900DAE3875A949, 0x3FEF4F87080D89F2,\n  0x3C74A385A63D07A7, 0x3FEF5818DCFBA487,\n  0xBC82919E2040220F, 0x3FEF60E316C98398,\n  0x3C8E5A50D5C192AC, 0x3FEF69E603DB3285,\n  0x3C843A59AC016B4B, 0x3FEF7321F301B460,\n  0xBC82D52107B43E1F, 0x3FEF7C97337B9B5F,\n  0xBC892AB93B470DC9, 0x3FEF864614F5A129,\n  0x3C74B604603A88D3, 0x3FEF902EE78B3FF6,\n  0x3C83C5EC519D7271, 0x3FEF9A51FBC74C83,\n  0xBC8FF7128FD391F0, 0x3FEFA4AFA2A490DA,\n  0xBC8DAE98E223747D, 0x3FEFAF482D8E67F1,\n  0x3C8EC3BC41AA2008, 0x3FEFBA1BEE615A27,\n  0x3C842B94C3A9EB32, 0x3FEFC52B376BBA97,\n  0x3C8A64A931D185EE, 0x3FEFD0765B6E4540,\n  0xBC8E37BAE43BE3ED, 0x3FEFDBFDAD9CBE14,\n  0x3C77893B4D91CD9D, 0x3FEFE7C1819E90D8,\n  0x3C5305C14160CC89, 0x3FEFF3C22B8F71F1\n]);\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding. The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase(tmp: f64, sbits: u64, ki: u64): f64 {\n  const\n    Ox1p_1022 = reinterpret<f64>(0x0010000000000000), // 0x1p-1022\n    Ox1p1009  = reinterpret<f64>(0x7F00000000000000); // 0x1p1009\n\n  let scale: f64;\n  if (!(ki & 0x80000000)) {\n    // k > 0, the exponent of scale might have overflowed by <= 460.\n    sbits -= u64(1009) << 52;\n    scale = reinterpret<f64>(sbits);\n    return Ox1p1009 * (scale + scale * tmp); // 0x1p1009\n  }\n  // k < 0, need special care in the subnormal range.\n  sbits += u64(1022) << 52;\n  // Note: sbits is signed scale.\n  scale = reinterpret<f64>(sbits);\n  let y = scale + scale * tmp;\n  if (abs(y) < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range.  So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let one = copysign(1.0, y);\n    let lo = scale - y + scale * tmp;\n    let hi = one + y;\n    lo = one - hi + y + lo;\n    y  = (hi + lo) - one;\n    // Fix the sign of 0.\n    if (y == 0.0) y = reinterpret<f64>(sbits & 0x8000000000000000);\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52;\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  let ux = reinterpret<u64>(x);\n  let abstop = u32(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) {\n        return 1.0 + x;\n      } else {\n        return select<f64>(0, Infinity, <i64>ux < 0);\n      }\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)]\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N]\n  let z = InvLn2N * x;\n  // #if TOINT_INTRINSICS\n  // \tkd = roundtoint(z);\n  // \tki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  // \t// z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  // let kd = z + shift;\n  // let ki = reinterpret<u64>(kd) >> 16;\n  // let kd = <f64><i32>ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes.\n  let kd = z + shift;\n  let ki = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  let r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // 2^(k/N) ~= scale * (1 + tail).\n  let idx = usize((ki & N_MASK) << 1);\n  let top = ki << (52 - EXP_TABLE_BITS);\n\n  let tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()))); // T[idx]\n  // This is only a valid scale when -1023*N < k < 1024*N\n  let sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  let r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp.\n  let tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  let scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n//\n// Lookup data for exp2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/exp2.c\n//\n\n// Handle cases that may overflow or underflow when computing the result that\n// is scale*(1+TMP) without intermediate rounding.  The bit representation of\n// scale is in SBITS, however it has a computed exponent that may have\n// overflown into the sign bit so that needs to be adjusted before using it as\n// a double.  (int32_t)KI is the k used in the argument reduction and exponent\n// adjustment of scale, positive k here means the result may overflow and\n// negative k means the result may underflow.\n// @ts-ignore: decorator\n@inline\nfunction specialcase2(tmp: f64, sbits: u64, ki: u64): f64 {\n  const Ox1p_1022 = reinterpret<f64>(0x10000000000000); // 0x1p-1022\n  let scale: f64;\n  if ((ki & 0x80000000) == 0) {\n    // k > 0, the exponent of scale might have overflowed by 1\n    sbits -= u64(1) << 52;\n    scale = reinterpret<f64>(sbits);\n    return 2 * (scale * tmp + scale);\n  }\n  // k < 0, need special care in the subnormal range\n  sbits += u64(1022) << 52;\n  scale = reinterpret<f64>(sbits);\n  let y = scale * tmp + scale;\n  if (y < 1.0) {\n    // Round y to the right precision before scaling it into the subnormal\n    // range to avoid double rounding that can cause 0.5+E/2 ulp error where\n    // E is the worst-case ulp error outside the subnormal range. So this\n    // is only useful if the goal is better than 1 ulp worst-case error.\n    let hi: f64, lo: f64;\n    lo = scale - y + scale * tmp;\n    hi = 1.0 + y;\n    lo = 1.0 - hi + y + lo;\n    y = (hi + lo) - 1.0;\n  }\n  return y * Ox1p_1022;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function exp2_lut(x: f64): f64 {\n  const\n    N      = 1 << EXP_TABLE_BITS,\n    N_MASK = N - 1,\n    shift  = reinterpret<f64>(0x4338000000000000) / N; // 0x1.8p52\n\n  const\n    C1 = reinterpret<f64>(0x3FE62E42FEFA39EF), // 0x1.62e42fefa39efp-1\n    C2 = reinterpret<f64>(0x3FCEBFBDFF82C424), // 0x1.ebfbdff82c424p-3\n    C3 = reinterpret<f64>(0x3FAC6B08D70CF4B5), // 0x1.c6b08d70cf4b5p-5\n    C4 = reinterpret<f64>(0x3F83B2ABD24650CC), // 0x1.3b2abd24650ccp-7\n    C5 = reinterpret<f64>(0x3F55D7E09B4E3A84); // 0x1.5d7e09b4e3a84p-10\n\n  let ux = reinterpret<u64>(x);\n  let abstop = u32(ux >> 52) & 0x7ff;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) return 1.0;\n    if (abstop >= 0x409) {\n      if (ux == 0xFFF0000000000000) return 0;\n      if (abstop >= 0x7FF) return 1.0 + x;\n      if (<i64>ux >= 0) return Infinity;\n      else if (ux >= 0xC090CC0000000000) return 0;\n    }\n    if ((ux << 1) > 0x811A000000000000) abstop = 0; // Large x is special cased below.\n  }\n\n  // exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)].\n  // x = k/N + r, with int k and r in [-1/2N, 1/2N]\n  let kd = x + shift;\n  let ki = reinterpret<u64>(kd);\n  kd -= shift; // k/N for int k\n  let r = x - kd;\n  // 2^(k/N) ~= scale * (1 + tail)\n  let idx = usize((ki & N_MASK) << 1);\n  let top = ki << (52 - EXP_TABLE_BITS);\n\n  let tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 0 << alignof<u64>())); // T[idx])\n  // This is only a valid scale when -1023*N < k < 1024*N\n  let sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top; // T[idx + 1]\n  // exp2(x) = 2^(k/N) * 2^r ~= scale + scale * (tail + 2^r - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution\n  let r2 = r * r;\n  // Without fma the worst case error is 0.5/N ulp larger.\n  // Worst case error is less than 0.5+0.86/N+(abs poly error * 2^53) ulp.\n  let tmp = tail + r * C1 + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase2(tmp, sbits, ki);\n  let scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-65 and scale > 2^-928, so there\n  // is no spurious underflow here even without fma.\n  return scale * tmp + scale;\n}\n\n//\n// Lookup data for log2. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log2.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG2_TABLE_BITS = 6;\n\n/* Algorithm:\n\n  x = 2^k z\n  log2(x) = k + log2(c) + log2(z/c)\n  log2(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log2(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p10 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-64 and\n  3) the rounding error in (double)log2(c) is minimized (< 0x1p-68).\n\nNote: 1) ensures that k + logc can be computed without rounding error, 2)\nensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to a\nsingle rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log2(x)| < 0x1p-4, this is not enough so that is special cased. */\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB1 = memory.data<u64>([\n  //     invc       ,        logc\n  0x3FF724286BB1ACF8, 0xBFE1095FEECDB000,\n  0x3FF6E1F766D2CCA1, 0xBFE08494BD76D000,\n  0x3FF6A13D0E30D48A, 0xBFE00143AEE8F800,\n  0x3FF661EC32D06C85, 0xBFDEFEC5360B4000,\n  0x3FF623FA951198F8, 0xBFDDFDD91AB7E000,\n  0x3FF5E75BA4CF026C, 0xBFDCFFAE0CC79000,\n  0x3FF5AC055A214FB8, 0xBFDC043811FDA000,\n  0x3FF571ED0F166E1E, 0xBFDB0B67323AE000,\n  0x3FF53909590BF835, 0xBFDA152F5A2DB000,\n  0x3FF5014FED61ADDD, 0xBFD9217F5AF86000,\n  0x3FF4CAB88E487BD0, 0xBFD8304DB0719000,\n  0x3FF49539B4334FEE, 0xBFD74189F9A9E000,\n  0x3FF460CBDFAFD569, 0xBFD6552BB5199000,\n  0x3FF42D664EE4B953, 0xBFD56B23A29B1000,\n  0x3FF3FB01111DD8A6, 0xBFD483650F5FA000,\n  0x3FF3C995B70C5836, 0xBFD39DE937F6A000,\n  0x3FF3991C4AB6FD4A, 0xBFD2BAA1538D6000,\n  0x3FF3698E0CE099B5, 0xBFD1D98340CA4000,\n  0x3FF33AE48213E7B2, 0xBFD0FA853A40E000,\n  0x3FF30D191985BDB1, 0xBFD01D9C32E73000,\n  0x3FF2E025CAB271D7, 0xBFCE857DA2FA6000,\n  0x3FF2B404CF13CD82, 0xBFCCD3C8633D8000,\n  0x3FF288B02C7CCB50, 0xBFCB26034C14A000,\n  0x3FF25E2263944DE5, 0xBFC97C1C2F4FE000,\n  0x3FF234563D8615B1, 0xBFC7D6023F800000,\n  0x3FF20B46E33EAF38, 0xBFC633A71A05E000,\n  0x3FF1E2EEFDCDA3DD, 0xBFC494F5E9570000,\n  0x3FF1BB4A580B3930, 0xBFC2F9E424E0A000,\n  0x3FF19453847F2200, 0xBFC162595AFDC000,\n  0x3FF16E06C0D5D73C, 0xBFBF9C9A75BD8000,\n  0x3FF1485F47B7E4C2, 0xBFBC7B575BF9C000,\n  0x3FF12358AD0085D1, 0xBFB960C60FF48000,\n  0x3FF0FEF00F532227, 0xBFB64CE247B60000,\n  0x3FF0DB2077D03A8F, 0xBFB33F78B2014000,\n  0x3FF0B7E6D65980D9, 0xBFB0387D1A42C000,\n  0x3FF0953EFE7B408D, 0xBFAA6F9208B50000,\n  0x3FF07325CAC53B83, 0xBFA47A954F770000,\n  0x3FF05197E40D1B5C, 0xBF9D23A8C50C0000,\n  0x3FF03091C1208EA2, 0xBF916A2629780000,\n  0x3FF0101025B37E21, 0xBF7720F8D8E80000,\n  0x3FEFC07EF9CAA76B, 0x3F86FE53B1500000,\n  0x3FEF4465D3F6F184, 0x3FA11CCCE10F8000,\n  0x3FEECC079F84107F, 0x3FAC4DFC8C8B8000,\n  0x3FEE573A99975AE8, 0x3FB3AA321E574000,\n  0x3FEDE5D6F0BD3DE6, 0x3FB918A0D08B8000,\n  0x3FED77B681FF38B3, 0x3FBE72E9DA044000,\n  0x3FED0CB5724DE943, 0x3FC1DCD2507F6000,\n  0x3FECA4B2DC0E7563, 0x3FC476AB03DEA000,\n  0x3FEC3F8EE8D6CB51, 0x3FC7074377E22000,\n  0x3FEBDD2B4F020C4C, 0x3FC98EDE8BA94000,\n  0x3FEB7D6C006015CA, 0x3FCC0DB86AD2E000,\n  0x3FEB20366E2E338F, 0x3FCE840AAFCEE000,\n  0x3FEAC57026295039, 0x3FD0790AB4678000,\n  0x3FEA6D01BC2731DD, 0x3FD1AC056801C000,\n  0x3FEA16D3BC3FF18B, 0x3FD2DB11D4FEE000,\n  0x3FE9C2D14967FEAD, 0x3FD406464EC58000,\n  0x3FE970E4F47C9902, 0x3FD52DBE093AF000,\n  0x3FE920FB3982BCF2, 0x3FD651902050D000,\n  0x3FE8D30187F759F1, 0x3FD771D2CDEAF000,\n  0x3FE886E5EBB9F66D, 0x3FD88E9C857D9000,\n  0x3FE83C97B658B994, 0x3FD9A80155E16000,\n  0x3FE7F405FFC61022, 0x3FDABE186ED3D000,\n  0x3FE7AD22181415CA, 0x3FDBD0F2AEA0E000,\n  0x3FE767DCF99EFF8C, 0x3FDCE0A43DBF4000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG2_DATA_TAB2 = memory.data<u64>([\n  //      chi       ,         clo\n  0x3FE6200012B90A8E, 0x3C8904AB0644B605,\n  0x3FE66000045734A6, 0x3C61FF9BEA62F7A9,\n  0x3FE69FFFC325F2C5, 0x3C827ECFCB3C90BA,\n  0x3FE6E00038B95A04, 0x3C88FF8856739326,\n  0x3FE71FFFE09994E3, 0x3C8AFD40275F82B1,\n  0x3FE7600015590E10, 0xBC72FD75B4238341,\n  0x3FE7A00012655BD5, 0x3C7808E67C242B76,\n  0x3FE7E0003259E9A6, 0xBC6208E426F622B7,\n  0x3FE81FFFEDB4B2D2, 0xBC8402461EA5C92F,\n  0x3FE860002DFAFCC3, 0x3C6DF7F4A2F29A1F,\n  0x3FE89FFFF78C6B50, 0xBC8E0453094995FD,\n  0x3FE8E00039671566, 0xBC8A04F3BEC77B45,\n  0x3FE91FFFE2BF1745, 0xBC77FA34400E203C,\n  0x3FE95FFFCC5C9FD1, 0xBC76FF8005A0695D,\n  0x3FE9A0003BBA4767, 0x3C70F8C4C4EC7E03,\n  0x3FE9DFFFE7B92DA5, 0x3C8E7FD9478C4602,\n  0x3FEA1FFFD72EFDAF, 0xBC6A0C554DCDAE7E,\n  0x3FEA5FFFDE04FF95, 0x3C867DA98CE9B26B,\n  0x3FEA9FFFCA5E8D2B, 0xBC8284C9B54C13DE,\n  0x3FEADFFFDDAD03EA, 0x3C5812C8EA602E3C,\n  0x3FEB1FFFF10D3D4D, 0xBC8EFADDAD27789C,\n  0x3FEB5FFFCE21165A, 0x3C53CB1719C61237,\n  0x3FEB9FFFD950E674, 0x3C73F7D94194CE00,\n  0x3FEBE000139CA8AF, 0x3C750AC4215D9BC0,\n  0x3FEC20005B46DF99, 0x3C6BEEA653E9C1C9,\n  0x3FEC600040B9F7AE, 0xBC7C079F274A70D6,\n  0x3FECA0006255FD8A, 0xBC7A0B4076E84C1F,\n  0x3FECDFFFD94C095D, 0x3C88F933F99AB5D7,\n  0x3FED1FFFF975D6CF, 0xBC582C08665FE1BE,\n  0x3FED5FFFA2561C93, 0xBC7B04289BD295F3,\n  0x3FED9FFF9D228B0C, 0x3C870251340FA236,\n  0x3FEDE00065BC7E16, 0xBC75011E16A4D80C,\n  0x3FEE200002F64791, 0x3C89802F09EF62E0,\n  0x3FEE600057D7A6D8, 0xBC7E0B75580CF7FA,\n  0x3FEEA00027EDC00C, 0xBC8C848309459811,\n  0x3FEEE0006CF5CB7C, 0xBC8F8027951576F4,\n  0x3FEF2000782B7DCC, 0xBC8F81D97274538F,\n  0x3FEF6000260C450A, 0xBC4071002727FFDC,\n  0x3FEF9FFFE88CD533, 0xBC581BDCE1FDA8B0,\n  0x3FEFDFFFD50F8689, 0x3C87F91ACB918E6E,\n  0x3FF0200004292367, 0x3C9B7FF365324681,\n  0x3FF05FFFE3E3D668, 0x3C86FA08DDAE957B,\n  0x3FF0A0000A85A757, 0xBC57E2DE80D3FB91,\n  0x3FF0E0001A5F3FCC, 0xBC91823305C5F014,\n  0x3FF11FFFF8AFBAF5, 0xBC8BFABB6680BAC2,\n  0x3FF15FFFE54D91AD, 0xBC9D7F121737E7EF,\n  0x3FF1A00011AC36E1, 0x3C9C000A0516F5FF,\n  0x3FF1E00019C84248, 0xBC9082FBE4DA5DA0,\n  0x3FF220000FFE5E6E, 0xBC88FDD04C9CFB43,\n  0x3FF26000269FD891, 0x3C8CFE2A7994D182,\n  0x3FF2A00029A6E6DA, 0xBC700273715E8BC5,\n  0x3FF2DFFFE0293E39, 0x3C9B7C39DAB2A6F9,\n  0x3FF31FFFF7DCF082, 0x3C7DF1336EDC5254,\n  0x3FF35FFFF05A8B60, 0xBC9E03564CCD31EB,\n  0x3FF3A0002E0EAECC, 0x3C75F0E74BD3A477,\n  0x3FF3E000043BB236, 0x3C9C7DCB149D8833,\n  0x3FF4200002D187FF, 0x3C7E08AFCF2D3D28,\n  0x3FF460000D387CB1, 0x3C820837856599A6,\n  0x3FF4A00004569F89, 0xBC89FA5C904FBCD2,\n  0x3FF4E000043543F3, 0xBC781125ED175329,\n  0x3FF51FFFCC027F0F, 0x3C9883D8847754DC,\n  0x3FF55FFFFD87B36F, 0xBC8709E731D02807,\n  0x3FF59FFFF21DF7BA, 0x3C87F79F68727B02,\n  0x3FF5DFFFEBFC3481, 0xBC9180902E30E93E\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log2_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG2_TABLE_BITS) - 1;\n\n  const\n    LO: u64 = 0x3FEEA4AF00000000, // reinterpret<u64>(1.0 - 0x1.5b51p-5)\n    HI: u64 = 0x3FF0B55900000000; // reinterpret<u64>(1.0 + 0x1.6ab2p-5)\n\n  const\n    InvLn2hi = reinterpret<f64>(0x3FF7154765200000), // 0x1.7154765200000p+0\n    InvLn2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 0x1.705fc2eefa200p-33\n    Ox1p52   = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  const\n    B0 = reinterpret<f64>(0xBFE71547652B82FE), // -0x1.71547652b82fep-1\n    B1 = reinterpret<f64>(0x3FDEC709DC3A03F7), //  0x1.ec709dc3a03f7p-2\n    B2 = reinterpret<f64>(0xBFD71547652B7C3F), // -0x1.71547652b7c3fp-2\n    B3 = reinterpret<f64>(0x3FD2776C50F05BE4), //  0x1.2776c50f05be4p-2\n    B4 = reinterpret<f64>(0xBFCEC709DD768FE5), // -0x1.ec709dd768fe5p-3\n    B5 = reinterpret<f64>(0x3FCA61761EC4E736), //  0x1.a61761ec4e736p-3\n    B6 = reinterpret<f64>(0xBFC7153FBC64A79B), // -0x1.7153fbc64a79bp-3\n    B7 = reinterpret<f64>(0x3FC484D154F01B4A), //  0x1.484d154f01b4ap-3\n    B8 = reinterpret<f64>(0xBFC289E4A72C383C), // -0x1.289e4a72c383cp-3\n    B9 = reinterpret<f64>(0x3FC0B32F285AEE66); //  0x1.0b32f285aee66p-3\n\n  const\n    A0 = reinterpret<f64>(0xBFE71547652B8339), // -0x1.71547652b8339p-1\n    A1 = reinterpret<f64>(0x3FDEC709DC3A04BE), //  0x1.ec709dc3a04bep-2\n    A2 = reinterpret<f64>(0xBFD7154764702FFB), // -0x1.7154764702ffbp-2\n    A3 = reinterpret<f64>(0x3FD2776C50034C48), //  0x1.2776c50034c48p-2\n    A4 = reinterpret<f64>(0xBFCEC7B328EA92BC), // -0x1.ec7b328ea92bcp-3\n    A5 = reinterpret<f64>(0x3FCA6225E117F92E); //  0x1.a6225e117f92ep-3\n\n  let ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r = x - 1.0;\n    // #if __FP_FAST_FMA\n    //     hi = r * InvLn2hi;\n    //     lo = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -hi);\n    // #else\n    let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n    let rlo = r - rhi;\n    let hi  = rhi * InvLn2hi;\n    let lo  = rlo * InvLn2hi + r * InvLn2lo;\n    // #endif\n    let r2 = r * r; // rounding error: 0x1p-62\n    let r4 = r2 * r2;\n    // Worst-case error is less than 0.54 ULP (0.55 ULP without fma)\n    let p = r2 * (B0 + r * B1);\n    let y = hi + p;\n    lo += hi - y + p;\n    lo += r4 * (B2 + r * B3 + r2 * (B4 + r * B5) +\n          r4 * (B6 + r * B7 + r2 * (B8 + r * B9)));\n    return y + lo;\n  }\n  let top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7ff0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan.\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == 0x7FF0000000000000) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it.\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ix - 0x3FE6000000000000;\n  let i    = <usize>((tmp >> (52 - LOG2_TABLE_BITS)) & N_MASK);\n  let k    = <i64>tmp >> 52;\n  let iz   = ix - (tmp & 0xFFF0000000000000);\n\n  let invc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  let logc = load<f64>(LOG2_DATA_TAB1  + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  let z    = reinterpret<f64>(iz);\n  let kd   = <f64>k;\n\n  // log2(x) = log2(z/c) + log2(c) + k.\n  // r ~= z/c - 1, |r| < 1/(2*N).\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N.\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // \tt1 = r * InvLn2hi;\n  // \tt2 = r * InvLn2lo + __builtin_fma(r, InvLn2hi, -t1);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-65.\n  let chi = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].chi;\n  let clo = load<f64>(LOG2_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].clo;\n\n  let r   = (z - chi - clo) * invc;\n  let rhi = reinterpret<f64>(reinterpret<u64>(r) & 0xFFFFFFFF00000000);\n  let rlo = r - rhi;\n  let t1  = rhi * InvLn2hi;\n  let t2  = rlo * InvLn2hi + r * InvLn2lo;\n  // #endif\n\n  // hi + lo = r/ln2 + log2(c) + k\n  let t3 = kd + logc;\n  let hi = t3 + t1;\n  let lo = t3 - hi + t1 + t2;\n\n  // log2(r+1) = r/ln2 + r^2*poly(r)\n  // Evaluation is optimized assuming superscalar pipelined execution\n  let r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst-case error if |y| > 0x1p-4: 0.547 ULP (0.550 ULP without fma).\n  // ~ 0.5 + 2/N/ln2 + abs-poly-error*0x1p56 ULP (+ 0.003 ULP without fma).\n  let p = A0 + r * A1 + r2 * (A2 + r * A3) + (r2 * r2) * (A4 + r * A5);\n  return lo + r2 * p + hi;\n}\n\n//\n// Lookup data for log. See: https://git.musl-libc.org/cgit/musl/tree/src/math/log.c\n//\n\n// @ts-ignore: decorator\n@inline const LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [1.6p-1; 1.6p0] which is split into N subintervals and z falls\ninto the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = (double)log(c)\n  tab2[i].chi = (double)c\n  tab2[i].clo = (double)(c - (double)c)\n\nwhere c is near the center of the subinterval and is chosen by trying +-2^29\nfloating point invc candidates around 1/center and selecting one for which\n\n  1) the rounding error in 0x1.8p9 + logc is 0,\n  2) the rounding error in z - chi - clo is < 0x1p-66 and\n  3) the rounding error in (double)log(c) is minimized (< 0x1p-66).\n\nNote: 1) ensures that k*ln2hi + logc can be computed without rounding error,\n2) ensures that z/c - 1 can be computed as (z - chi - clo)*invc with close to\na single rounding error when there is no fast fma for z*invc - 1, 3) ensures\nthat logc + poly(z/c - 1) has small error, however near x == 1 when\n|log(x)| < 0x1p-4, this is not enough so that is special cased.*/\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB1 = memory.data<u64>([\n  //      invc      ,        logc\n  0x3FF734F0C3E0DE9F, 0xBFD7CC7F79E69000,\n  0x3FF713786A2CE91F, 0xBFD76FEEC20D0000,\n  0x3FF6F26008FAB5A0, 0xBFD713E31351E000,\n  0x3FF6D1A61F138C7D, 0xBFD6B85B38287800,\n  0x3FF6B1490BC5B4D1, 0xBFD65D5590807800,\n  0x3FF69147332F0CBA, 0xBFD602D076180000,\n  0x3FF6719F18224223, 0xBFD5A8CA86909000,\n  0x3FF6524F99A51ED9, 0xBFD54F4356035000,\n  0x3FF63356AA8F24C4, 0xBFD4F637C36B4000,\n  0x3FF614B36B9DDC14, 0xBFD49DA7FDA85000,\n  0x3FF5F66452C65C4C, 0xBFD445923989A800,\n  0x3FF5D867B5912C4F, 0xBFD3EDF439B0B800,\n  0x3FF5BABCCB5B90DE, 0xBFD396CE448F7000,\n  0x3FF59D61F2D91A78, 0xBFD3401E17BDA000,\n  0x3FF5805612465687, 0xBFD2E9E2EF468000,\n  0x3FF56397CEE76BD3, 0xBFD2941B3830E000,\n  0x3FF54725E2A77F93, 0xBFD23EC58CDA8800,\n  0x3FF52AFF42064583, 0xBFD1E9E129279000,\n  0x3FF50F22DBB2BDDF, 0xBFD1956D2B48F800,\n  0x3FF4F38F4734DED7, 0xBFD141679AB9F800,\n  0x3FF4D843CFDE2840, 0xBFD0EDD094EF9800,\n  0x3FF4BD3EC078A3C8, 0xBFD09AA518DB1000,\n  0x3FF4A27FC3E0258A, 0xBFD047E65263B800,\n  0x3FF4880524D48434, 0xBFCFEB224586F000,\n  0x3FF46DCE1B192D0B, 0xBFCF474A7517B000,\n  0x3FF453D9D3391854, 0xBFCEA4443D103000,\n  0x3FF43A2744B4845A, 0xBFCE020D44E9B000,\n  0x3FF420B54115F8FB, 0xBFCD60A22977F000,\n  0x3FF40782DA3EF4B1, 0xBFCCC00104959000,\n  0x3FF3EE8F5D57FE8F, 0xBFCC202956891000,\n  0x3FF3D5D9A00B4CE9, 0xBFCB81178D811000,\n  0x3FF3BD60C010C12B, 0xBFCAE2C9CCD3D000,\n  0x3FF3A5242B75DAB8, 0xBFCA45402E129000,\n  0x3FF38D22CD9FD002, 0xBFC9A877681DF000,\n  0x3FF3755BC5847A1C, 0xBFC90C6D69483000,\n  0x3FF35DCE49AD36E2, 0xBFC87120A645C000,\n  0x3FF34679984DD440, 0xBFC7D68FB4143000,\n  0x3FF32F5CCEFFCB24, 0xBFC73CB83C627000,\n  0x3FF3187775A10D49, 0xBFC6A39A9B376000,\n  0x3FF301C8373E3990, 0xBFC60B3154B7A000,\n  0x3FF2EB4EBB95F841, 0xBFC5737D76243000,\n  0x3FF2D50A0219A9D1, 0xBFC4DC7B8FC23000,\n  0x3FF2BEF9A8B7FD2A, 0xBFC4462C51D20000,\n  0x3FF2A91C7A0C1BAB, 0xBFC3B08ABC830000,\n  0x3FF293726014B530, 0xBFC31B996B490000,\n  0x3FF27DFA5757A1F5, 0xBFC2875490A44000,\n  0x3FF268B39B1D3BBF, 0xBFC1F3B9F879A000,\n  0x3FF2539D838FF5BD, 0xBFC160C8252CA000,\n  0x3FF23EB7AAC9083B, 0xBFC0CE7F57F72000,\n  0x3FF22A012BA940B6, 0xBFC03CDC49FEA000,\n  0x3FF2157996CC4132, 0xBFBF57BDBC4B8000,\n  0x3FF201201DD2FC9B, 0xBFBE370896404000,\n  0x3FF1ECF4494D480B, 0xBFBD17983EF94000,\n  0x3FF1D8F5528F6569, 0xBFBBF9674ED8A000,\n  0x3FF1C52311577E7C, 0xBFBADC79202F6000,\n  0x3FF1B17C74CB26E9, 0xBFB9C0C3E7288000,\n  0x3FF19E010C2C1AB6, 0xBFB8A646B372C000,\n  0x3FF18AB07BB670BD, 0xBFB78D01B3AC0000,\n  0x3FF1778A25EFBCB6, 0xBFB674F145380000,\n  0x3FF1648D354C31DA, 0xBFB55E0E6D878000,\n  0x3FF151B990275FDD, 0xBFB4485CDEA1E000,\n  0x3FF13F0EA432D24C, 0xBFB333D94D6AA000,\n  0x3FF12C8B7210F9DA, 0xBFB22079F8C56000,\n  0x3FF11A3028ECB531, 0xBFB10E4698622000,\n  0x3FF107FBDA8434AF, 0xBFAFFA6C6AD20000,\n  0x3FF0F5EE0F4E6BB3, 0xBFADDA8D4A774000,\n  0x3FF0E4065D2A9FCE, 0xBFABBCECE4850000,\n  0x3FF0D244632CA521, 0xBFA9A1894012C000,\n  0x3FF0C0A77CE2981A, 0xBFA788583302C000,\n  0x3FF0AF2F83C636D1, 0xBFA5715E67D68000,\n  0x3FF09DDB98A01339, 0xBFA35C8A49658000,\n  0x3FF08CABAF52E7DF, 0xBFA149E364154000,\n  0x3FF07B9F2F4E28FB, 0xBF9E72C082EB8000,\n  0x3FF06AB58C358F19, 0xBF9A55F152528000,\n  0x3FF059EEA5ECF92C, 0xBF963D62CF818000,\n  0x3FF04949CDD12C90, 0xBF9228FB8CAA0000,\n  0x3FF038C6C6F0ADA9, 0xBF8C317B20F90000,\n  0x3FF02865137932A9, 0xBF8419355DAA0000,\n  0x3FF0182427EA7348, 0xBF781203C2EC0000,\n  0x3FF008040614B195, 0xBF60040979240000,\n  0x3FEFE01FF726FA1A, 0x3F6FEFF384900000,\n  0x3FEFA11CC261EA74, 0x3F87DC41353D0000,\n  0x3FEF6310B081992E, 0x3F93CEA3C4C28000,\n  0x3FEF25F63CEEADCD, 0x3F9B9FC114890000,\n  0x3FEEE9C8039113E7, 0x3FA1B0D8CE110000,\n  0x3FEEAE8078CBB1AB, 0x3FA58A5BD001C000,\n  0x3FEE741AA29D0C9B, 0x3FA95C8340D88000,\n  0x3FEE3A91830A99B5, 0x3FAD276AEF578000,\n  0x3FEE01E009609A56, 0x3FB07598E598C000,\n  0x3FEDCA01E577BB98, 0x3FB253F5E30D2000,\n  0x3FED92F20B7C9103, 0x3FB42EDD8B380000,\n  0x3FED5CAC66FB5CCE, 0x3FB606598757C000,\n  0x3FED272CAA5EDE9D, 0x3FB7DA76356A0000,\n  0x3FECF26E3E6B2CCD, 0x3FB9AB434E1C6000,\n  0x3FECBE6DA2A77902, 0x3FBB78C7BB0D6000,\n  0x3FEC8B266D37086D, 0x3FBD431332E72000,\n  0x3FEC5894BD5D5804, 0x3FBF0A3171DE6000,\n  0x3FEC26B533BB9F8C, 0x3FC067152B914000,\n  0x3FEBF583EEECE73F, 0x3FC147858292B000,\n  0x3FEBC4FD75DB96C1, 0x3FC2266ECDCA3000,\n  0x3FEB951E0C864A28, 0x3FC303D7A6C55000,\n  0x3FEB65E2C5EF3E2C, 0x3FC3DFC33C331000,\n  0x3FEB374867C9888B, 0x3FC4BA366B7A8000,\n  0x3FEB094B211D304A, 0x3FC5933928D1F000,\n  0x3FEADBE885F2EF7E, 0x3FC66ACD2418F000,\n  0x3FEAAF1D31603DA2, 0x3FC740F8EC669000,\n  0x3FEA82E63FD358A7, 0x3FC815C0F51AF000,\n  0x3FEA5740EF09738B, 0x3FC8E92954F68000,\n  0x3FEA2C2A90AB4B27, 0x3FC9BB3602F84000,\n  0x3FEA01A01393F2D1, 0x3FCA8BED1C2C0000,\n  0x3FE9D79F24DB3C1B, 0x3FCB5B515C01D000,\n  0x3FE9AE2505C7B190, 0x3FCC2967CCBCC000,\n  0x3FE9852EF297CE2F, 0x3FCCF635D5486000,\n  0x3FE95CBAEEA44B75, 0x3FCDC1BD3446C000,\n  0x3FE934C69DE74838, 0x3FCE8C01B8CFE000,\n  0x3FE90D4F2F6752E6, 0x3FCF5509C0179000,\n  0x3FE8E6528EFFD79D, 0x3FD00E6C121FB800,\n  0x3FE8BFCE9FCC007C, 0x3FD071B80E93D000,\n  0x3FE899C0DABEC30E, 0x3FD0D46B9E867000,\n  0x3FE87427AA2317FB, 0x3FD13687334BD000,\n  0x3FE84F00ACB39A08, 0x3FD1980D67234800,\n  0x3FE82A49E8653E55, 0x3FD1F8FFE0CC8000,\n  0x3FE8060195F40260, 0x3FD2595FD7636800,\n  0x3FE7E22563E0A329, 0x3FD2B9300914A800,\n  0x3FE7BEB377DCB5AD, 0x3FD3187210436000,\n  0x3FE79BAA679725C2, 0x3FD377266DEC1800,\n  0x3FE77907F2170657, 0x3FD3D54FFBAF3000,\n  0x3FE756CADBD6130C, 0x3FD432EEE32FE000\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOG_DATA_TAB2 = memory.data<u64>([\n  //      chi       ,         clo\n  0x3FE61000014FB66B, 0x3C7E026C91425B3C,\n  0x3FE63000034DB495, 0x3C8DBFEA48005D41,\n  0x3FE650000D94D478, 0x3C8E7FA786D6A5B7,\n  0x3FE67000074E6FAD, 0x3C61FCEA6B54254C,\n  0x3FE68FFFFEDF0FAE, 0xBC7C7E274C590EFD,\n  0x3FE6B0000763C5BC, 0xBC8AC16848DCDA01,\n  0x3FE6D0001E5CC1F6, 0x3C833F1C9D499311,\n  0x3FE6EFFFEB05F63E, 0xBC7E80041AE22D53,\n  0x3FE710000E869780, 0x3C7BFF6671097952,\n  0x3FE72FFFFC67E912, 0x3C8C00E226BD8724,\n  0x3FE74FFFDF81116A, 0xBC6E02916EF101D2,\n  0x3FE770000F679C90, 0xBC67FC71CD549C74,\n  0x3FE78FFFFA7EC835, 0x3C81BEC19EF50483,\n  0x3FE7AFFFFE20C2E6, 0xBC707E1729CC6465,\n  0x3FE7CFFFED3FC900, 0xBC808072087B8B1C,\n  0x3FE7EFFFE9261A76, 0x3C8DC0286D9DF9AE,\n  0x3FE81000049CA3E8, 0x3C897FD251E54C33,\n  0x3FE8300017932C8F, 0xBC8AFEE9B630F381,\n  0x3FE850000633739C, 0x3C89BFBF6B6535BC,\n  0x3FE87000204289C6, 0xBC8BBF65F3117B75,\n  0x3FE88FFFEBF57904, 0xBC89006EA23DCB57,\n  0x3FE8B00022BC04DF, 0xBC7D00DF38E04B0A,\n  0x3FE8CFFFE50C1B8A, 0xBC88007146FF9F05,\n  0x3FE8EFFFFC918E43, 0x3C83817BD07A7038,\n  0x3FE910001EFA5FC7, 0x3C893E9176DFB403,\n  0x3FE9300013467BB9, 0x3C7F804E4B980276,\n  0x3FE94FFFE6EE076F, 0xBC8F7EF0D9FF622E,\n  0x3FE96FFFDE3C12D1, 0xBC7082AA962638BA,\n  0x3FE98FFFF4458A0D, 0xBC87801B9164A8EF,\n  0x3FE9AFFFDD982E3E, 0xBC8740E08A5A9337,\n  0x3FE9CFFFED49FB66, 0x3C3FCE08C19BE000,\n  0x3FE9F00020F19C51, 0xBC8A3FAA27885B0A,\n  0x3FEA10001145B006, 0x3C74FF489958DA56,\n  0x3FEA300007BBF6FA, 0x3C8CBEAB8A2B6D18,\n  0x3FEA500010971D79, 0x3C88FECADD787930,\n  0x3FEA70001DF52E48, 0xBC8F41763DD8ABDB,\n  0x3FEA90001C593352, 0xBC8EBF0284C27612,\n  0x3FEAB0002A4F3E4B, 0xBC69FD043CFF3F5F,\n  0x3FEACFFFD7AE1ED1, 0xBC823EE7129070B4,\n  0x3FEAEFFFEE510478, 0x3C6A063EE00EDEA3,\n  0x3FEB0FFFDB650D5B, 0x3C5A06C8381F0AB9,\n  0x3FEB2FFFFEAACA57, 0xBC79011E74233C1D,\n  0x3FEB4FFFD995BADC, 0xBC79FF1068862A9F,\n  0x3FEB7000249E659C, 0x3C8AFF45D0864F3E,\n  0x3FEB8FFFF9871640, 0x3C7CFE7796C2C3F9,\n  0x3FEBAFFFD204CB4F, 0xBC63FF27EEF22BC4,\n  0x3FEBCFFFD2415C45, 0xBC6CFFB7EE3BEA21,\n  0x3FEBEFFFF86309DF, 0xBC814103972E0B5C,\n  0x3FEC0FFFE1B57653, 0x3C8BC16494B76A19,\n  0x3FEC2FFFF1FA57E3, 0xBC64FEEF8D30C6ED,\n  0x3FEC4FFFDCBFE424, 0xBC843F68BCEC4775,\n  0x3FEC6FFFED54B9F7, 0x3C847EA3F053E0EC,\n  0x3FEC8FFFEB998FD5, 0x3C7383068DF992F1,\n  0x3FECB0002125219A, 0xBC68FD8E64180E04,\n  0x3FECCFFFDD94469C, 0x3C8E7EBE1CC7EA72,\n  0x3FECEFFFEAFDC476, 0x3C8EBE39AD9F88FE,\n  0x3FED1000169AF82B, 0x3C757D91A8B95A71,\n  0x3FED30000D0FF71D, 0x3C89C1906970C7DA,\n  0x3FED4FFFEA790FC4, 0xBC580E37C558FE0C,\n  0x3FED70002EDC87E5, 0xBC7F80D64DC10F44,\n  0x3FED900021DC82AA, 0xBC747C8F94FD5C5C,\n  0x3FEDAFFFD86B0283, 0x3C8C7F1DC521617E,\n  0x3FEDD000296C4739, 0x3C88019EB2FFB153,\n  0x3FEDEFFFE54490F5, 0x3C6E00D2C652CC89,\n  0x3FEE0FFFCDABF694, 0xBC7F8340202D69D2,\n  0x3FEE2FFFDB52C8DD, 0x3C7B00C1CA1B0864,\n  0x3FEE4FFFF24216EF, 0x3C72FFA8B094AB51,\n  0x3FEE6FFFE88A5E11, 0xBC57F673B1EFBE59,\n  0x3FEE9000119EFF0D, 0xBC84808D5E0BC801,\n  0x3FEEAFFFDFA51744, 0x3C780006D54320B5,\n  0x3FEED0001A127FA1, 0xBC5002F860565C92,\n  0x3FEEF00007BABCC4, 0xBC8540445D35E611,\n  0x3FEF0FFFF57A8D02, 0xBC4FFB3139EF9105,\n  0x3FEF30001EE58AC7, 0x3C8A81ACF2731155,\n  0x3FEF4FFFF5823494, 0x3C8A3F41D4D7C743,\n  0x3FEF6FFFFCA94C6B, 0xBC6202F41C987875,\n  0x3FEF8FFFE1F9C441, 0x3C777DD1F477E74B,\n  0x3FEFAFFFD2E0E37E, 0xBC6F01199A7CA331,\n  0x3FEFD0001C77E49E, 0x3C7181EE4BCEACB1,\n  0x3FEFEFFFF7E0C331, 0xBC6E05370170875A,\n  0x3FF00FFFF465606E, 0xBC8A7EAD491C0ADA,\n  0x3FF02FFFF3867A58, 0xBC977F69C3FCB2E0,\n  0x3FF04FFFFDFC0D17, 0x3C97BFFE34CB945B,\n  0x3FF0700003CD4D82, 0x3C820083C0E456CB,\n  0x3FF08FFFF9F2CBE8, 0xBC6DFFDFBE37751A,\n  0x3FF0B000010CDA65, 0xBC913F7FAEE626EB,\n  0x3FF0D00001A4D338, 0x3C807DFA79489FF7,\n  0x3FF0EFFFFADAFDFD, 0xBC77040570D66BC0,\n  0x3FF110000BBAFD96, 0x3C8E80D4846D0B62,\n  0x3FF12FFFFAE5F45D, 0x3C9DBFFA64FD36EF,\n  0x3FF150000DD59AD9, 0x3C9A0077701250AE,\n  0x3FF170000F21559A, 0x3C8DFDF9E2E3DEEE,\n  0x3FF18FFFFC275426, 0x3C910030DC3B7273,\n  0x3FF1B000123D3C59, 0x3C997F7980030188,\n  0x3FF1CFFFF8299EB7, 0xBC65F932AB9F8C67,\n  0x3FF1EFFFF48AD400, 0x3C937FBF9DA75BEB,\n  0x3FF210000C8B86A4, 0x3C9F806B91FD5B22,\n  0x3FF2300003854303, 0x3C93FFC2EB9FBF33,\n  0x3FF24FFFFFBCF684, 0x3C7601E77E2E2E72,\n  0x3FF26FFFF52921D9, 0x3C7FFCBB767F0C61,\n  0x3FF2900014933A3C, 0xBC7202CA3C02412B,\n  0x3FF2B00014556313, 0xBC92808233F21F02,\n  0x3FF2CFFFEBFE523B, 0xBC88FF7E384FDCF2,\n  0x3FF2F0000BB8AD96, 0xBC85FF51503041C5,\n  0x3FF30FFFFB7AE2AF, 0xBC810071885E289D,\n  0x3FF32FFFFEAC5F7F, 0xBC91FF5D3FB7B715,\n  0x3FF350000CA66756, 0x3C957F82228B82BD,\n  0x3FF3700011FBF721, 0x3C8000BAC40DD5CC,\n  0x3FF38FFFF9592FB9, 0xBC943F9D2DB2A751,\n  0x3FF3B00004DDD242, 0x3C857F6B707638E1,\n  0x3FF3CFFFF5B2C957, 0x3C7A023A10BF1231,\n  0x3FF3EFFFEAB0B418, 0x3C987F6D66B152B0,\n  0x3FF410001532AFF4, 0x3C67F8375F198524,\n  0x3FF4300017478B29, 0x3C8301E672DC5143,\n  0x3FF44FFFE795B463, 0x3C89FF69B8B2895A,\n  0x3FF46FFFE80475E0, 0xBC95C0B19BC2F254,\n  0x3FF48FFFEF6FC1E7, 0x3C9B4009F23A2A72,\n  0x3FF4AFFFE5BEA704, 0xBC94FFB7BF0D7D45,\n  0x3FF4D000171027DE, 0xBC99C06471DC6A3D,\n  0x3FF4F0000FF03EE2, 0x3C977F890B85531C,\n  0x3FF5100012DC4BD1, 0x3C6004657166A436,\n  0x3FF530001605277A, 0xBC96BFCECE233209,\n  0x3FF54FFFECDB704C, 0xBC8902720505A1D7,\n  0x3FF56FFFEF5F54A9, 0x3C9BBFE60EC96412,\n  0x3FF5900017E61012, 0x3C887EC581AFEF90,\n  0x3FF5B00003C93E92, 0xBC9F41080ABF0CC0,\n  0x3FF5D0001D4919BC, 0xBC98812AFB254729,\n  0x3FF5EFFFE7B87A89, 0xBC947EB780ED6904\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function log_lut(x: f64): f64 {\n  const N_MASK = (1 << LOG_TABLE_BITS) - 1;\n\n  const\n    B0  = reinterpret<f64>(0xBFE0000000000000), // -0x1p-1\n    B1  = reinterpret<f64>(0x3FD5555555555577), //  0x1.5555555555577p-2\n    B2  = reinterpret<f64>(0xBFCFFFFFFFFFFDCB), // -0x1.ffffffffffdcbp-3\n    B3  = reinterpret<f64>(0x3FC999999995DD0C), //  0x1.999999995dd0cp-3\n    B4  = reinterpret<f64>(0xBFC55555556745A7), // -0x1.55555556745a7p-3\n    B5  = reinterpret<f64>(0x3FC24924A344DE30), //  0x1.24924a344de3p-3\n    B6  = reinterpret<f64>(0xBFBFFFFFA4423D65), // -0x1.fffffa4423d65p-4\n    B7  = reinterpret<f64>(0x3FBC7184282AD6CA), //  0x1.c7184282ad6cap-4\n    B8  = reinterpret<f64>(0xBFB999EB43B068FF), // -0x1.999eb43b068ffp-4\n    B9  = reinterpret<f64>(0x3FB78182F7AFD085), //  0x1.78182f7afd085p-4\n    B10 = reinterpret<f64>(0xBFB5521375D145CD); // -0x1.5521375d145cdp-4\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000001),  // -0x1.0000000000001p-1\n    A1 = reinterpret<f64>(0x3FD555555551305B),  //  0x1.555555551305bp-2\n    A2 = reinterpret<f64>(0xBFCFFFFFFFEB4590),  // -0x1.fffffffeb459p-3\n    A3 = reinterpret<f64>(0x3FC999B324F10111),  //  0x1.999b324f10111p-3\n    A4 = reinterpret<f64>(0xBFC55575E506C89F);  // -0x1.55575e506c89fp-3\n\n  const\n    LO: u64 = 0x3FEE000000000000,\n    HI: u64 = 0x3FF1090000000000;\n\n  const\n    Ln2hi  = reinterpret<f64>(0x3FE62E42FEFA3800), // 0x1.62e42fefa3800p-1\n    Ln2lo  = reinterpret<f64>(0x3D2EF35793C76730), // 0x1.ef35793c76730p-45\n    Ox1p27 = reinterpret<f64>(0x41A0000000000000), // 0x1p27\n    Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  let ix = reinterpret<u64>(x);\n  if (ix - LO < HI - LO) {\n    let r  = x - 1.0;\n    let r2 = r * r;\n    let r3 = r2 * r;\n    let y =\n      r3 * (B1 + r * B2 + r2 * B3 +\n      r3 * (B4 + r * B5 + r2 * B6 +\n      r3 * (B7 + r * B8 + r2 * B9 + r3 * B10)));\n    // Worst-case error is around 0.507 ULP\n    let w   = r * Ox1p27;\n    let rhi = r + w - w;\n    let rlo = r - rhi;\n    w = rhi * rhi * B0; // B[0] == -0.5\n    let hi = r + w;\n    let lo = r - hi + w;\n    lo += B0 * rlo * (rhi + r);\n    return y + lo + hi;\n  }\n  let top = u32(ix >> 48);\n  if (top - 0x0010 >= 0x7FF0 - 0x0010) {\n    // x < 0x1p-1022 or inf or nan\n    if ((ix << 1) == 0) return -1.0 / (x * x);\n    if (ix == reinterpret<u64>(Infinity)) return x; // log(inf) == inf\n    if ((top & 0x8000) || (top & 0x7FF0) == 0x7FF0) return (x - x) / (x - x);\n    // x is subnormal, normalize it\n    ix = reinterpret<u64>(x * Ox1p52);\n    ix -= u64(52) << 52;\n  }\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp  = ix - 0x3FE6000000000000;\n  let i    = <usize>((tmp >> (52 - LOG_TABLE_BITS)) & N_MASK);\n  let k    = <i64>tmp >> 52;\n  let iz   = ix - (tmp & (u64(0xFFF) << 52));\n\n  let invc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T[i].invc;\n  let logc = load<f64>(LOG_DATA_TAB1 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T[i].logc;\n  let z    = reinterpret<f64>(iz);\n\n  // log(x) = log1p(z/c-1) + log(c) + k*Ln2.\n  // r ~= z/c - 1, |r| < 1/(2*N)\n  // #if __FP_FAST_FMA\n  // \t// rounding error: 0x1p-55/N\n  // \tr = __builtin_fma(z, invc, -1.0);\n  // #else\n  // rounding error: 0x1p-55/N + 0x1p-66\n  const chi = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 0 << alignof<f64>()); // T2[i].chi\n  const clo = load<f64>(LOG_DATA_TAB2 + (i << (1 + alignof<f64>())), 1 << alignof<f64>()); // T2[i].clo\n  let r = (z - chi - clo) * invc;\n  // #endif\n  let kd = <f64>k;\n\n  // hi + lo = r + log(c) + k*Ln2\n  let w  = kd * Ln2hi + logc;\n  let hi = w + r;\n  let lo = w - hi + r + kd * Ln2lo;\n\n  // log(x) = lo + (log1p(r) - r) + hi\n  let r2 = r * r; // rounding error: 0x1p-54/N^2\n  // Worst case error if |y| > 0x1p-5:\n  // 0.5 + 4.13/N + abs-poly-error*2^57 ULP (+ 0.002 ULP without fma)\n  // Worst case error if |y| > 0x1p-4:\n  // 0.5 + 2.06/N + abs-poly-error*2^56 ULP (+ 0.001 ULP without fma).\n  return lo + r2 * A0 + r * r2 * (A1 + r * A2 + r2 * (A3 + r * A4)) + hi;\n}\n\n//\n// Lookup data for pow. See: https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c\n//\n\n// @ts-ignore: decorator\n@inline const POW_LOG_TABLE_BITS = 7;\n\n/* Algorithm:\n\n  x = 2^k z\n  log(x) = k ln2 + log(c) + log(z/c)\n  log(z/c) = poly(z/c - 1)\n\nwhere z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals\nand z falls into the ith one, then table entries are computed as\n\n  tab[i].invc = 1/c\n  tab[i].logc = round(0x1p43*log(c))/0x1p43\n  tab[i].logctail = (double)(log(c) - logc)\n\nwhere c is chosen near the center of the subinterval such that 1/c has only a\nfew precision bits so z/c - 1 is exactly representible as double:\n\n  1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2\n\nNote: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,\nthe last few bits of logc are rounded away so k*ln2hi + logc has no rounding\nerror and the interval for z is selected such that near x == 1, where log(x)\nis tiny, large cancellation error is avoided in logc + poly(z/c - 1). */\n\n// @ts-ignore: decorator\n@lazy @inline const POW_LOG_DATA_TAB = memory.data<u64>([\n  //      invc      ,pad,       logc       ,       logctail\n  0x3FF6A00000000000, 0, 0xBFD62C82F2B9C800, 0x3CFAB42428375680,\n  0x3FF6800000000000, 0, 0xBFD5D1BDBF580800, 0xBD1CA508D8E0F720,\n  0x3FF6600000000000, 0, 0xBFD5767717455800, 0xBD2362A4D5B6506D,\n  0x3FF6400000000000, 0, 0xBFD51AAD872DF800, 0xBCE684E49EB067D5,\n  0x3FF6200000000000, 0, 0xBFD4BE5F95777800, 0xBD041B6993293EE0,\n  0x3FF6000000000000, 0, 0xBFD4618BC21C6000, 0x3D13D82F484C84CC,\n  0x3FF5E00000000000, 0, 0xBFD404308686A800, 0x3CDC42F3ED820B3A,\n  0x3FF5C00000000000, 0, 0xBFD3A64C55694800, 0x3D20B1C686519460,\n  0x3FF5A00000000000, 0, 0xBFD347DD9A988000, 0x3D25594DD4C58092,\n  0x3FF5800000000000, 0, 0xBFD2E8E2BAE12000, 0x3D267B1E99B72BD8,\n  0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n  0x3FF5600000000000, 0, 0xBFD2895A13DE8800, 0x3D15CA14B6CFB03F,\n  0x3FF5400000000000, 0, 0xBFD22941FBCF7800, 0xBD165A242853DA76,\n  0x3FF5200000000000, 0, 0xBFD1C898C1699800, 0xBD1FAFBC68E75404,\n  0x3FF5000000000000, 0, 0xBFD1675CABABA800, 0x3D1F1FC63382A8F0,\n  0x3FF4E00000000000, 0, 0xBFD1058BF9AE4800, 0xBD26A8C4FD055A66,\n  0x3FF4C00000000000, 0, 0xBFD0A324E2739000, 0xBD0C6BEE7EF4030E,\n  0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n  0x3FF4A00000000000, 0, 0xBFD0402594B4D000, 0xBCF036B89EF42D7F,\n  0x3FF4800000000000, 0, 0xBFCFB9186D5E4000, 0x3D0D572AAB993C87,\n  0x3FF4600000000000, 0, 0xBFCEF0ADCBDC6000, 0x3D2B26B79C86AF24,\n  0x3FF4400000000000, 0, 0xBFCE27076E2AF000, 0xBD172F4F543FFF10,\n  0x3FF4200000000000, 0, 0xBFCD5C216B4FC000, 0x3D21BA91BBCA681B,\n  0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n  0x3FF4000000000000, 0, 0xBFCC8FF7C79AA000, 0x3D27794F689F8434,\n  0x3FF3E00000000000, 0, 0xBFCBC286742D9000, 0x3D194EB0318BB78F,\n  0x3FF3C00000000000, 0, 0xBFCAF3C94E80C000, 0x3CBA4E633FCD9066,\n  0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n  0x3FF3A00000000000, 0, 0xBFCA23BC1FE2B000, 0xBD258C64DC46C1EA,\n  0x3FF3800000000000, 0, 0xBFC9525A9CF45000, 0xBD2AD1D904C1D4E3,\n  0x3FF3600000000000, 0, 0xBFC87FA06520D000, 0x3D2BBDBF7FDBFA09,\n  0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n  0x3FF3400000000000, 0, 0xBFC7AB890210E000, 0x3D2BDB9072534A58,\n  0x3FF3200000000000, 0, 0xBFC6D60FE719D000, 0xBD10E46AA3B2E266,\n  0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n  0x3FF3000000000000, 0, 0xBFC5FF3070A79000, 0xBD1E9E439F105039,\n  0x3FF2E00000000000, 0, 0xBFC526E5E3A1B000, 0xBD20DE8B90075B8F,\n  0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n  0x3FF2C00000000000, 0, 0xBFC44D2B6CCB8000, 0x3D170CC16135783C,\n  0x3FF2A00000000000, 0, 0xBFC371FC201E9000, 0x3CF178864D27543A,\n  0x3FF2800000000000, 0, 0xBFC29552F81FF000, 0xBD248D301771C408,\n  0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n  0x3FF2600000000000, 0, 0xBFC1B72AD52F6000, 0xBD2E80A41811A396,\n  0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n  0x3FF2400000000000, 0, 0xBFC0D77E7CD09000, 0x3D0A699688E85BF4,\n  0x3FF2200000000000, 0, 0xBFBFEC9131DBE000, 0xBD2575545CA333F2,\n  0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n  0x3FF2000000000000, 0, 0xBFBE27076E2B0000, 0x3D2A342C2AF0003C,\n  0x3FF1E00000000000, 0, 0xBFBC5E548F5BC000, 0xBD1D0C57585FBE06,\n  0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n  0x3FF1C00000000000, 0, 0xBFBA926D3A4AE000, 0x3D253935E85BAAC8,\n  0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n  0x3FF1A00000000000, 0, 0xBFB8C345D631A000, 0x3D137C294D2F5668,\n  0x3FF1800000000000, 0, 0xBFB6F0D28AE56000, 0xBD269737C93373DA,\n  0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n  0x3FF1600000000000, 0, 0xBFB51B073F062000, 0x3D1F025B61C65E57,\n  0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n  0x3FF1400000000000, 0, 0xBFB341D7961BE000, 0x3D2C5EDACCF913DF,\n  0x3FF1200000000000, 0, 0xBFB16536EEA38000, 0x3D147C5E768FA309,\n  0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n  0x3FF1000000000000, 0, 0xBFAF0A30C0118000, 0x3D2D599E83368E91,\n  0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n  0x3FF0E00000000000, 0, 0xBFAB42DD71198000, 0x3D1C827AE5D6704C,\n  0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n  0x3FF0C00000000000, 0, 0xBFA77458F632C000, 0xBD2CFC4634F2A1EE,\n  0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n  0x3FF0A00000000000, 0, 0xBFA39E87B9FEC000, 0x3CF502B7F526FEAA,\n  0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n  0x3FF0800000000000, 0, 0xBF9F829B0E780000, 0xBD2980267C7E09E4,\n  0x3FF0600000000000, 0, 0xBF97B91B07D58000, 0xBD288D5493FAA639,\n  0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n  0x3FF0400000000000, 0, 0xBF8FC0A8B0FC0000, 0xBCDF1E7CF6D3A69C,\n  0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n  0x3FF0200000000000, 0, 0xBF7FE02A6B100000, 0xBD19E23F0DDA40E4,\n  0x3FF0000000000000, 0, 0, 0,\n  0x3FF0000000000000, 0, 0, 0,\n  0x3FEFC00000000000, 0, 0x3F80101575890000, 0xBD10C76B999D2BE8,\n  0x3FEF800000000000, 0, 0x3F90205658938000, 0xBD23DC5B06E2F7D2,\n  0x3FEF400000000000, 0, 0x3F98492528C90000, 0xBD2AA0BA325A0C34,\n  0x3FEF000000000000, 0, 0x3FA0415D89E74000, 0x3D0111C05CF1D753,\n  0x3FEEC00000000000, 0, 0x3FA466AED42E0000, 0xBD2C167375BDFD28,\n  0x3FEE800000000000, 0, 0x3FA894AA149FC000, 0xBD197995D05A267D,\n  0x3FEE400000000000, 0, 0x3FACCB73CDDDC000, 0xBD1A68F247D82807,\n  0x3FEE200000000000, 0, 0x3FAEEA31C006C000, 0xBD0E113E4FC93B7B,\n  0x3FEDE00000000000, 0, 0x3FB1973BD1466000, 0xBD25325D560D9E9B,\n  0x3FEDA00000000000, 0, 0x3FB3BDF5A7D1E000, 0x3D2CC85EA5DB4ED7,\n  0x3FED600000000000, 0, 0x3FB5E95A4D97A000, 0xBD2C69063C5D1D1E,\n  0x3FED400000000000, 0, 0x3FB700D30AEAC000, 0x3CEC1E8DA99DED32,\n  0x3FED000000000000, 0, 0x3FB9335E5D594000, 0x3D23115C3ABD47DA,\n  0x3FECC00000000000, 0, 0x3FBB6AC88DAD6000, 0xBD1390802BF768E5,\n  0x3FECA00000000000, 0, 0x3FBC885801BC4000, 0x3D2646D1C65AACD3,\n  0x3FEC600000000000, 0, 0x3FBEC739830A2000, 0xBD2DC068AFE645E0,\n  0x3FEC400000000000, 0, 0x3FBFE89139DBE000, 0xBD2534D64FA10AFD,\n  0x3FEC000000000000, 0, 0x3FC1178E8227E000, 0x3D21EF78CE2D07F2,\n  0x3FEBE00000000000, 0, 0x3FC1AA2B7E23F000, 0x3D2CA78E44389934,\n  0x3FEBA00000000000, 0, 0x3FC2D1610C868000, 0x3D039D6CCB81B4A1,\n  0x3FEB800000000000, 0, 0x3FC365FCB0159000, 0x3CC62FA8234B7289,\n  0x3FEB400000000000, 0, 0x3FC4913D8333B000, 0x3D25837954FDB678,\n  0x3FEB200000000000, 0, 0x3FC527E5E4A1B000, 0x3D2633E8E5697DC7,\n  0x3FEAE00000000000, 0, 0x3FC6574EBE8C1000, 0x3D19CF8B2C3C2E78,\n  0x3FEAC00000000000, 0, 0x3FC6F0128B757000, 0xBD25118DE59C21E1,\n  0x3FEAA00000000000, 0, 0x3FC7898D85445000, 0xBD1C661070914305,\n  0x3FEA600000000000, 0, 0x3FC8BEAFEB390000, 0xBD073D54AAE92CD1,\n  0x3FEA400000000000, 0, 0x3FC95A5ADCF70000, 0x3D07F22858A0FF6F,\n  0x3FEA000000000000, 0, 0x3FCA93ED3C8AE000, 0xBD28724350562169,\n  0x3FE9E00000000000, 0, 0x3FCB31D8575BD000, 0xBD0C358D4EACE1AA,\n  0x3FE9C00000000000, 0, 0x3FCBD087383BE000, 0xBD2D4BC4595412B6,\n  0x3FE9A00000000000, 0, 0x3FCC6FFBC6F01000, 0xBCF1EC72C5962BD2,\n  0x3FE9600000000000, 0, 0x3FCDB13DB0D49000, 0xBD2AFF2AF715B035,\n  0x3FE9400000000000, 0, 0x3FCE530EFFE71000, 0x3CC212276041F430,\n  0x3FE9200000000000, 0, 0x3FCEF5ADE4DD0000, 0xBCCA211565BB8E11,\n  0x3FE9000000000000, 0, 0x3FCF991C6CB3B000, 0x3D1BCBECCA0CDF30,\n  0x3FE8C00000000000, 0, 0x3FD07138604D5800, 0x3CF89CDB16ED4E91,\n  0x3FE8A00000000000, 0, 0x3FD0C42D67616000, 0x3D27188B163CEAE9,\n  0x3FE8800000000000, 0, 0x3FD1178E8227E800, 0xBD2C210E63A5F01C,\n  0x3FE8600000000000, 0, 0x3FD16B5CCBACF800, 0x3D2B9ACDF7A51681,\n  0x3FE8400000000000, 0, 0x3FD1BF99635A6800, 0x3D2CA6ED5147BDB7,\n  0x3FE8200000000000, 0, 0x3FD214456D0EB800, 0x3D0A87DEBA46BAEA,\n  0x3FE7E00000000000, 0, 0x3FD2BEF07CDC9000, 0x3D2A9CFA4A5004F4,\n  0x3FE7C00000000000, 0, 0x3FD314F1E1D36000, 0xBD28E27AD3213CB8,\n  0x3FE7A00000000000, 0, 0x3FD36B6776BE1000, 0x3D116ECDB0F177C8,\n  0x3FE7800000000000, 0, 0x3FD3C25277333000, 0x3D183B54B606BD5C,\n  0x3FE7600000000000, 0, 0x3FD419B423D5E800, 0x3D08E436EC90E09D,\n  0x3FE7400000000000, 0, 0x3FD4718DC271C800, 0xBD2F27CE0967D675,\n  0x3FE7200000000000, 0, 0x3FD4C9E09E173000, 0xBD2E20891B0AD8A4,\n  0x3FE7000000000000, 0, 0x3FD522AE0738A000, 0x3D2EBE708164C759,\n  0x3FE6E00000000000, 0, 0x3FD57BF753C8D000, 0x3D1FADEDEE5D40EF,\n  0x3FE6C00000000000, 0, 0x3FD5D5BDDF596000, 0xBD0A0B2A08A465DC\n]);\n\n// Returns 0 if not int, 1 if odd int, 2 if even int. The argument is\n// the bit representation of a non-zero finite floating-point value.\n// @ts-ignore: decorator\n@inline\nfunction checkint(iy: u64): i32 {\n  let e = iy >> 52 & 0x7FF;\n  if (e < 0x3FF     ) return 0;\n  if (e > 0x3FF + 52) return 2;\n  e = u64(1) << (0x3FF + 52 - e);\n  if (iy & (e - 1)) return 0;\n  if (iy &  e     ) return 1;\n  return 2;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction xflow(sign: u32, y: f64): f64 {\n  return select(-y, y, sign) * y;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction uflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x1000000000000000)); // 0x1p-767\n}\n\n// @ts-ignore: decorator\n@inline\nfunction oflow(sign: u32): f64 {\n  return xflow(sign, reinterpret<f64>(0x7000000000000000)); // 0x1p769\n}\n\n// Returns 1 if input is the bit representation of 0, infinity or nan.\n// @ts-ignore: decorator\n@inline\nfunction zeroinfnan(u: u64): bool {\n  return (u << 1) - 1 >= 0xFFE0000000000000 - 1;\n}\n\n// @ts-ignore: decorator\n@lazy let log_tail: f64 = 0;\n\n// Compute y+TAIL = log(x) where the rounded result is y and TAIL has about\n// additional 15 bits precision. IX is the bit representation of x, but\n// normalized in the subnormal range using the sign bit for the exponent.\n// @ts-ignore: decorator\n@inline\nfunction log_inline(ix: u64): f64 {\n  const N = 1 << POW_LOG_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    Ln2hi = reinterpret<f64>(0x3FE62E42FEFA3800),\n    Ln2lo = reinterpret<f64>(0x3D2EF35793C76730);\n\n  const\n    A0 = reinterpret<f64>(0xBFE0000000000000),\n    A1 = reinterpret<f64>(0xBFE5555555555560),\n    A2 = reinterpret<f64>(0x3FE0000000000006),\n    A3 = reinterpret<f64>(0x3FE999999959554E),\n    A4 = reinterpret<f64>(0xBFE555555529A47A),\n    A5 = reinterpret<f64>(0xBFF2495B9B4845E9),\n    A6 = reinterpret<f64>(0x3FF0002B8B263FC3);\n\n  // x = 2^k z; where z is in range [OFF,2*OFF) and exact.\n  // The range is split into N subintervals.\n  // The ith subinterval contains z and c is near its center.\n  let tmp = ix - 0x3fE6955500000000;\n  let i   = usize((tmp >> (52 - POW_LOG_TABLE_BITS)) & N_MASK);\n  let k   = <i64>tmp >> 52;\n  let iz  = ix - (tmp & u64(0xFFF) << 52);\n  let z   = reinterpret<f64>(iz);\n  let kd  = <f64>k;\n\n  // log(x) = k*Ln2 + log(c) + log1p(z/c-1).\n  let invc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 0 << alignof<f64>()); // tab[i].invc\n  let logc     = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 2 << alignof<f64>()); // tab[i].logc\n  let logctail = load<f64>(POW_LOG_DATA_TAB + (i << (2 + alignof<f64>())), 3 << alignof<f64>()); // tab[i].logctail\n\n  // Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and\n  // |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.\n  // Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.\n  let zhi = reinterpret<f64>((iz + u64(0x80000000)) & 0xFFFFFFFF00000000);\n  let zlo = z - zhi;\n  let rhi = zhi * invc - 1.0;\n  let rlo = zlo * invc;\n  let r   = rhi + rlo;\n\n  // k * Ln2 + log(c) + r.\n  let t1  = kd * Ln2hi + logc;\n  let t2  = t1 + r;\n  let lo1 = kd * Ln2lo + logctail;\n  let lo2 = t1 - t2 + r;\n\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  let ar  = A0 * r; // A[0] = -0.5\n  let ar2 = r * ar;\n  let ar3 = r * ar2;\n  // k * Ln2 + log(c) + r + A[0] * r * r.\n  let arhi  = A0  * rhi;\n  let arhi2 = rhi * arhi;\n  let hi    = t2  + arhi2;\n  let lo3   = rlo * (ar + arhi);\n  let lo4   = t2 - hi + arhi2;\n\n  // p = log1p(r) - r - A[0] * r * r.\n  let p  = ar3 * (A1 + r * A2 + ar2 * (A3 + r * A4 + ar2 * (A5 + r * A6)));\n  let lo = lo1 + lo2 + lo3 + lo4 + p;\n  let y  = hi + lo;\n  log_tail = hi - y + lo;\n\n  return y;\n}\n\n// @ts-ignore: decorator\n@inline const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;\n\n// Computes sign*exp(x+xtail) where |xtail| < 2^-8/N and |xtail| <= |x|.\n// The sign_bias argument is SIGN_BIAS or 0 and sets the sign to -1 or 1.\n// @ts-ignore: decorator\n@inline\nfunction exp_inline(x: f64, xtail: f64, sign_bias: u32): f64 {\n  const N      = 1 << EXP_TABLE_BITS;\n  const N_MASK = N - 1;\n\n  const\n    InvLn2N   = reinterpret<f64>(0x3FF71547652B82FE) * N, // 0x1.71547652b82fep0\n    NegLn2hiN = reinterpret<f64>(0xBF762E42FEFA0000),     // -0x1.62e42fefa0000p-8\n    NegLn2loN = reinterpret<f64>(0xBD0CF79ABC9E3B3A),     // -0x1.cf79abc9e3b3ap-47\n    shift     = reinterpret<f64>(0x4338000000000000);     // 0x1.8p52\n\n  const\n    C2 = reinterpret<f64>(0x3FDFFFFFFFFFFDBD), // __exp_data.poly[0] (0x1.ffffffffffdbdp-2)\n    C3 = reinterpret<f64>(0x3FC555555555543C), // __exp_data.poly[1] (0x1.555555555543cp-3)\n    C4 = reinterpret<f64>(0x3FA55555CF172B91), // __exp_data.poly[2] (0x1.55555cf172b91p-5)\n    C5 = reinterpret<f64>(0x3F81111167A4D017); // __exp_data.poly[3] (0x1.1111167a4d017p-7)\n\n  let abstop: u32;\n  let ki: u64, top: u64, sbits: u64;\n  let idx: usize;\n  // double_t for better performance on targets with FLT_EVAL_METHOD==2.\n  let kd: f64, z: f64, r: f64, r2: f64, scale: f64, tail: f64, tmp: f64;\n\n  let ux = reinterpret<u64>(x);\n  abstop = u32(ux >> 52) & 0x7FF;\n  if (abstop - 0x3C9 >= 0x03F) {\n    if (abstop - 0x3C9 >= 0x80000000) {\n      // Avoid spurious underflow for tiny x.\n      // Note: 0 is common input.\n      return select(-1.0, 1.0, sign_bias);\n    }\n    if (abstop >= 0x409) { // top12(1024.0)\n      // Note: inf and nan are already handled.\n      return <i64>ux < 0\n        ? uflow(sign_bias)\n        : oflow(sign_bias);\n    }\n    // Large x is special cased below.\n    abstop = 0;\n  }\n\n  // exp(x) = 2^(k/N) * exp(r), with exp(r) in [2^(-1/2N),2^(1/2N)].\n  // x = ln2/N*k + r, with int k and r in [-ln2/2N, ln2/2N].\n  z = InvLn2N * x;\n\n  // #if TOINT_INTRINSICS\n  //   kd = roundtoint(z);\n  //   ki = converttoint(z);\n  // #elif EXP_USE_TOINT_NARROW\n  //   // z - kd is in [-0.5-2^-16, 0.5] in all rounding modes.\n  //   kd = eval_as_double(z + shift);\n  //   ki = asuint64(kd) >> 16;\n  //   kd = (double_t)(int32_t)ki;\n  // #else\n  // z - kd is in [-1, 1] in non-nearest rounding modes\n  kd  = z + shift;\n  ki  = reinterpret<u64>(kd);\n  kd -= shift;\n  // #endif\n  r = x + kd * NegLn2hiN + kd * NegLn2loN;\n  // The code assumes 2^-200 < |xtail| < 2^-8/N\n  r += xtail;\n  // 2^(k/N) ~= scale * (1 + tail)\n  idx = usize((ki & N_MASK) << 1);\n  top = (ki + sign_bias) << (52 - EXP_TABLE_BITS);\n\n  tail = reinterpret<f64>(load<u64>(EXP_DATA_TAB + (idx << alignof<u64>())));\n  // This is only a valid scale when -1023*N < k < 1024*N\n  sbits = load<u64>(EXP_DATA_TAB + (idx << alignof<u64>()), 1 << alignof<u64>()) + top;\n  // exp(x) = 2^(k/N) * exp(r) ~= scale + scale * (tail + exp(r) - 1).\n  // Evaluation is optimized assuming superscalar pipelined execution.\n  r2 = r * r;\n  // Without fma the worst case error is 0.25/N ulp larger.\n  // Worst case error is less than 0.5+1.11/N+(abs poly error * 2^53) ulp\n  tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);\n  if (abstop == 0) return specialcase(tmp, sbits, ki);\n  scale = reinterpret<f64>(sbits);\n  // Note: tmp == 0 or |tmp| > 2^-200 and scale > 2^-739, so there\n  // is no spurious underflow here even without fma.\n  return scale + scale * tmp;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function pow_lut(x: f64, y: f64): f64 {\n  const Ox1p52 = reinterpret<f64>(0x4330000000000000); // 0x1p52\n\n  let sign_bias: u32 = 0;\n  let ix = reinterpret<u64>(x);\n  let iy = reinterpret<u64>(y);\n  let topx = ix >> 52;\n  let topy = iy >> 52;\n\n  if (topx - 0x001 >= 0x7FF - 0x001 || (topy & 0x7FF) - 0x3BE >= 0x43e - 0x3BE) {\n    // Note: if |y| > 1075 * ln2 * 2^53 ~= 0x1.749p62 then pow(x,y) = inf/0\n    // and if |y| < 2^-54 / 1075 ~= 0x1.e7b6p-65 then pow(x,y) = +-1.\n    // Special cases: (x < 0x1p-126 or inf or nan) or\n    // (|y| < 0x1p-65 or |y| >= 0x1p63 or nan).\n    if (zeroinfnan(iy)) {\n      if ((iy << 1) == 0) return 1.0;\n      if (ix == 0x3FF0000000000000) return NaN; // original: 1.0\n      if ((ix << 1) > 0xFFE0000000000000 || (iy << 1) > 0xFFE0000000000000) return x + y;\n      if ((ix << 1) == 0x7FE0000000000000) return NaN; // original: 1.0\n      if (((ix << 1) < 0x7FE0000000000000) == !(iy >> 63)) return 0; // |x|<1 && y==inf or |x|>1 && y==-inf.\n      return y * y;\n    }\n    if (zeroinfnan(ix)) {\n      let x2 = x * x;\n      if (i32(ix >> 63) && checkint(iy) == 1) x2 = -x2;\n      return <i64>iy < 0 ? 1 / x2 : x2;\n    }\n    // Here x and y are non-zero finite\n    if (<i64>ix < 0) {\n      // Finite x < 0\n      let yint = checkint(iy);\n      if (yint == 0) return (x - x) / (x - x);\n      if (yint == 1) sign_bias = SIGN_BIAS;\n      ix   &= 0x7FFFFFFFFFFFFFFF;\n      topx &= 0x7FF;\n    }\n    if ((topy & 0x7FF) - 0x3BE >= 0x43E - 0x3BE) {\n      // Note: sign_bias == 0 here because y is not odd.\n      if (ix == 0x3FF0000000000000) return 1;\n      if ((topy & 0x7FF) < 0x3BE)   return 1; // |y| < 2^-65, x^y ~= 1 + y*log(x).\n      return (ix > 0x3FF0000000000000) == (topy < 0x800) ? Infinity : 0;\n    }\n    if (topx == 0) {\n      // Normalize subnormal x so exponent becomes negative.\n      ix = reinterpret<u64>(x * Ox1p52);\n      ix &= 0x7FFFFFFFFFFFFFFF;\n      ix -= u64(52) << 52;\n    }\n  }\n\n  let hi = log_inline(ix);\n  let lo = log_tail;\n  let ehi: f64, elo: f64;\n  // #if __FP_FAST_FMA\n  //   ehi = y * hi;\n  //   elo = y * lo + __builtin_fma(y, hi, -ehi);\n  // #else\n  let yhi = reinterpret<f64>(iy & 0xFFFFFFFFF8000000);\n  let ylo = y - yhi;\n  let lhi = reinterpret<f64>(reinterpret<u64>(hi) & 0xFFFFFFFFF8000000);\n  let llo = hi - lhi + lo;\n  ehi = yhi * lhi;\n  elo = ylo * lhi + y * llo; // |elo| < |ehi| * 2^-25.\n  // #endif\n  return exp_inline(ehi, elo, sign_bias);\n}\n","/// <reference path=\"../rt/index.d.ts\" />\n\nimport { idof } from \"../builtins\";\nimport { CharCode } from \"./string\";\n\n// @ts-ignore: decorator\n@inline\nexport const MAX_DOUBLE_LENGTH = 28;\n\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<u32>([\n  1,\n  10,\n  100,\n  1000,\n  10000,\n  100000,\n  1000000,\n  10000000,\n  100000000,\n  1000000000\n]);\n\n/*\n  Lookup table for pairwise char codes in range [0-99]\n\n  \"00\", \"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\",\n  \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\", \"17\", \"18\", \"19\",\n  \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\",\n  \"30\", \"31\", \"32\", \"33\", \"34\", \"35\", \"36\", \"37\", \"38\", \"39\",\n  \"40\", \"41\", \"42\", \"43\", \"44\", \"45\", \"46\", \"47\", \"48\", \"49\",\n  \"50\", \"51\", \"52\", \"53\", \"54\", \"55\", \"56\", \"57\", \"58\", \"59\",\n  \"60\", \"61\", \"62\", \"63\", \"64\", \"65\", \"66\", \"67\", \"68\", \"69\",\n  \"70\", \"71\", \"72\", \"73\", \"74\", \"75\", \"76\", \"77\", \"78\", \"79\",\n  \"80\", \"81\", \"82\", \"83\", \"84\", \"85\", \"86\", \"87\", \"88\", \"89\",\n  \"90\", \"91\", \"92\", \"93\", \"94\", \"95\", \"96\", \"97\", \"98\", \"99\"\n*/\n// @ts-ignore: decorator\n@lazy @inline const DIGITS = memory.data<u32>([\n  0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,\n  0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,\n  0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031,\n  0x00350031, 0x00360031, 0x00370031, 0x00380031, 0x00390031,\n  0x00300032, 0x00310032, 0x00320032, 0x00330032, 0x00340032,\n  0x00350032, 0x00360032, 0x00370032, 0x00380032, 0x00390032,\n  0x00300033, 0x00310033, 0x00320033, 0x00330033, 0x00340033,\n  0x00350033, 0x00360033, 0x00370033, 0x00380033, 0x00390033,\n  0x00300034, 0x00310034, 0x00320034, 0x00330034, 0x00340034,\n  0x00350034, 0x00360034, 0x00370034, 0x00380034, 0x00390034,\n  0x00300035, 0x00310035, 0x00320035, 0x00330035, 0x00340035,\n  0x00350035, 0x00360035, 0x00370035, 0x00380035, 0x00390035,\n  0x00300036, 0x00310036, 0x00320036, 0x00330036, 0x00340036,\n  0x00350036, 0x00360036, 0x00370036, 0x00380036, 0x00390036,\n  0x00300037, 0x00310037, 0x00320037, 0x00330037, 0x00340037,\n  0x00350037, 0x00360037, 0x00370037, 0x00380037, 0x00390037,\n  0x00300038, 0x00310038, 0x00320038, 0x00330038, 0x00340038,\n  0x00350038, 0x00360038, 0x00370038, 0x00380038, 0x00390038,\n  0x00300039, 0x00310039, 0x00320039, 0x00330039, 0x00340039,\n  0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039\n]);\n\n// Lookup table for pairwise char codes in range [0x00-0xFF]\n// @ts-ignore: decorator\n@lazy @inline const HEX_DIGITS =\n\"000102030405060708090a0b0c0d0e0f\\\n101112131415161718191a1b1c1d1e1f\\\n202122232425262728292a2b2c2d2e2f\\\n303132333435363738393a3b3c3d3e3f\\\n404142434445464748494a4b4c4d4e4f\\\n505152535455565758595a5b5c5d5e5f\\\n606162636465666768696a6b6c6d6e6f\\\n707172737475767778797a7b7c7d7e7f\\\n808182838485868788898a8b8c8d8e8f\\\n909192939495969798999a9b9c9d9e9f\\\na0a1a2a3a4a5a6a7a8a9aaabacadaeaf\\\nb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\\\nc0c1c2c3c4c5c6c7c8c9cacbcccdcecf\\\nd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\\\ne0e1e2e3e4e5e6e7e8e9eaebecedeeef\\\nf0f1f2f3f4f5f6f7f8f9fafbfcfdfeff\";\n\n// @ts-ignore: decorator\n@lazy @inline const ANY_DIGITS = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\n// @ts-ignore: decorator\n@lazy @inline const EXP_POWERS = memory.data<i16>([/* eslint-disable indent */\n  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,\n   -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,\n   -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,\n   -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,\n   -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,\n    109,   136,   162,   189,   216,   242,   269,   295,   322,   348,\n    375,   402,   428,   455,   481,   508,   534,   561,   588,   614,\n    641,   667,   694,   720,   747,   774,   800,   827,   853,   880,\n    907,   933,   960,   986,  1013,  1039,  1066\n/* eslint-enable indent */]);\n\n// 1e-348, 1e-340, ..., 1e340\n// @ts-ignore: decorator\n@lazy @inline const FRC_POWERS = memory.data<u64>([\n  0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,\n  0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,\n  0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5,\n  0xEA9C227723EE8BCB, 0xAECC49914078536D, 0x823C12795DB6CE57, 0xC21094364DFB5637,\n  0x9096EA6F3848984F, 0xD77485CB25823AC7, 0xA086CFCD97BF97F4, 0xEF340A98172AACE5,\n  0xB23867FB2A35B28E, 0x84C8D4DFD2C63F3B, 0xC5DD44271AD3CDBA, 0x936B9FCEBB25C996,\n  0xDBAC6C247D62A584, 0xA3AB66580D5FDAF6, 0xF3E2F893DEC3F126, 0xB5B5ADA8AAFF80B8,\n  0x87625F056C7C4A8B, 0xC9BCFF6034C13053, 0x964E858C91BA2655, 0xDFF9772470297EBD,\n  0xA6DFBD9FB8E5B88F, 0xF8A95FCF88747D94, 0xB94470938FA89BCF, 0x8A08F0F8BF0F156B,\n  0xCDB02555653131B6, 0x993FE2C6D07B7FAC, 0xE45C10C42A2B3B06, 0xAA242499697392D3,\n  0xFD87B5F28300CA0E, 0xBCE5086492111AEB, 0x8CBCCC096F5088CC, 0xD1B71758E219652C,\n  0x9C40000000000000, 0xE8D4A51000000000, 0xAD78EBC5AC620000, 0x813F3978F8940984,\n  0xC097CE7BC90715B3, 0x8F7E32CE7BEA5C70, 0xD5D238A4ABE98068, 0x9F4F2726179A2245,\n  0xED63A231D4C4FB27, 0xB0DE65388CC8ADA8, 0x83C7088E1AAB65DB, 0xC45D1DF942711D9A,\n  0x924D692CA61BE758, 0xDA01EE641A708DEA, 0xA26DA3999AEF774A, 0xF209787BB47D6B85,\n  0xB454E4A179DD1877, 0x865B86925B9BC5C2, 0xC83553C5C8965D3D, 0x952AB45CFA97A0B3,\n  0xDE469FBD99A05FE3, 0xA59BC234DB398C25, 0xF6C69A72A3989F5C, 0xB7DCBF5354E9BECE,\n  0x88FCF317F22241E2, 0xCC20CE9BD35C78A5, 0x98165AF37B2153DF, 0xE2A0B5DC971F303A,\n  0xA8D9D1535CE3B396, 0xFB9B7CD9A4A7443C, 0xBB764C4CA7A44410, 0x8BAB8EEFB6409C1A,\n  0xD01FEF10A657842C, 0x9B10A4E5E9913129, 0xE7109BFBA19C0C9D, 0xAC2820D9623BF429,\n  0x80444B5E7AA7CF85, 0xBF21E44003ACDD2D, 0x8E679C2F5E44FF8F, 0xD433179D9C8CB841,\n  0x9E19DB92B4E31BA9, 0xEB96BF6EBADF77D9, 0xAF87023B9BF0EE6B\n]);\n\n// @ts-ignore: decorator\n@inline\nexport function isPowerOf2<T extends number>(value: T): bool {\n  return popcnt<T>(value) == 1;\n}\n\n// Count number of decimals for u32 values\n// In our case input value always non-zero so we can simplify some parts\nexport function decimalCount32(value: u32): u32 {\n  if (value < 100000) {\n    if (value < 100) {\n      return 1 + u32(value >= 10);\n    } else {\n      return 3 + u32(value >= 10000) + u32(value >= 1000);\n    }\n  } else {\n    if (value < 10000000) {\n      return 6 + u32(value >= 1000000);\n    } else {\n      return 8 + u32(value >= 1000000000) + u32(value >= 100000000);\n    }\n  }\n}\n\n// Count number of decimals for u64 values\n// In our case input value always greater than 2^32-1 so we can skip some parts\nexport function decimalCount64High(value: u64): u32 {\n  if (value < 1000000000000000) {\n    if (value < 1000000000000) {\n      return 10 + u32(value >= 100000000000) + u32(value >= 10000000000);\n    } else {\n      return 13 + u32(value >= 100000000000000) + u32(value >= 10000000000000);\n    }\n  } else {\n    if (value < 100000000000000000) {\n      return 16 + u32(value >= 10000000000000000);\n    } else {\n      return 18 + u32(value >= 10000000000000000000) + u32(value >= 1000000000000000000);\n    }\n  }\n}\n\nfunction ulog_base(num: u64, base: i32): u32 {\n  if (isPowerOf2(base)) {\n    return (63 - <u32>clz(num)) / (31 - <u32>clz(base)) + 1;\n  }\n  let b64 = u64(base), b = b64, e: u32 = 1;\n  while (num >= b) {\n    num /= b;\n    b *= b;\n    e <<= 1;\n  }\n  while (num >= 1) {\n    num /= b64;\n    e++;\n  }\n  return e - 1;\n}\n\nfunction utoa32_dec_lut(buffer: usize, num: u32, offset: usize): void {\n  while (num >= 10000) {\n    // in most VMs i32/u32 div and modulo by constant can be shared and simplificate\n    let t = num / 10000;\n    let r = num % 10000;\n    num = t;\n\n    let d1 = r / 100;\n    let d2 = r % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>d2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  if (num >= 100) {\n    let t  = num / 100;\n    let d1 = num % 100;\n    num = t;\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>d1 << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  }\n\n  if (num >= 10) {\n    offset -= 2;\n    let digits = load<u32>(DIGITS + (<usize>num << alignof<u32>()));\n    store<u32>(buffer + (offset << 1), digits);\n  } else {\n    offset -= 1;\n    let digit = CharCode._0 + num;\n    store<u16>(buffer + (offset << 1), digit);\n  }\n}\n\nfunction utoa64_dec_lut(buffer: usize, num: u64, offset: usize): void {\n  while (num >= 100000000) {\n    let t = num / 100000000;\n    let r = <usize>(num - t * 100000000);\n    num = t;\n\n    let b = r / 10000;\n    let c = r % 10000;\n\n    let b1 = b / 100;\n    let b2 = b % 100;\n    let c1 = c / 100;\n    let c2 = c % 100;\n\n    let digits1 = <u64>load<u32>(DIGITS + (<usize>c1 << alignof<u32>()));\n    let digits2 = <u64>load<u32>(DIGITS + (<usize>c2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n\n    digits1 = <u64>load<u32>(DIGITS + (<usize>b1 << alignof<u32>()));\n    digits2 = <u64>load<u32>(DIGITS + (<usize>b2 << alignof<u32>()));\n\n    offset -= 4;\n    store<u64>(buffer + (offset << 1), digits1 | (digits2 << 32));\n  }\n\n  utoa32_dec_lut(buffer, <u32>num, offset);\n}\n\nfunction utoa_hex_lut(buffer: usize, num: u64, offset: usize): void {\n  const lut = changetype<usize>(HEX_DIGITS);\n  while (offset >= 2) {\n    offset -= 2;\n    store<u32>(\n      buffer + (offset << 1),\n      load<u32>(lut + ((<usize>num & 0xFF) << alignof<u32>()))\n    );\n    num >>= 8;\n  }\n  if (offset & 1) {\n    store<u16>(buffer, load<u16>(lut + (<usize>num << 6)));\n  }\n}\n\nfunction utoa_dec_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let t = num / 10;\n    let r = <u32>(num % 10);\n    num = changetype<T>(t);\n    offset--;\n    store<u16>(buffer + (offset << 1), CharCode._0 + r);\n  } while (num);\n}\n\nfunction utoa_hex_simple<T extends number>(buffer: usize, num: T, offset: usize): void {\n  do {\n    let d = num & 0x0F | CharCode._0;\n    d += select<T>(<T>0x27, <T>0, d > <T>CharCode._9);\n    offset--;\n    store<u16>(buffer + (offset << 1), d);\n    // @ts-ignore: type\n    num >>= 4;\n  } while (num);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function utoa32_dec_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u32>(buffer, num, offset);\n  } else {\n    utoa32_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa32_hex_core(buffer: usize, num: u32, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u32>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_dec_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_dec_simple<u64>(buffer, num, offset);\n  } else {\n    utoa64_dec_lut(buffer, num, offset);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction utoa64_hex_core(buffer: usize, num: u64, offset: usize): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    utoa_hex_simple<u64>(buffer, num, offset);\n  } else {\n    utoa_hex_lut(buffer, num, offset);\n  }\n}\n\nfunction utoa64_any_core(buffer: usize, num: u64, offset: usize, radix: i32): void {\n  const lut = changetype<usize>(ANY_DIGITS);\n  let base = u64(radix);\n  if ((radix & (radix - 1)) == 0) { // for radix which pow of two\n    let shift = u64(ctz(radix) & 7);\n    let mask = base - 1;\n    do {\n      offset--;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num & mask) << 1)));\n      num >>= shift;\n    } while (num);\n  } else {\n    do {\n      offset--;\n      let q = num / base;\n      store<u16>(buffer + (offset << 1), load<u16>(lut + (usize(num - q * base) << 1)));\n      num = q;\n    } while (num);\n  }\n}\n\nexport function utoa32(value: u32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  let out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out), value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa32(value: i32, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  let sign = (value >>> 31) << 1;\n  if (sign) value = -value;\n  let out: String;\n\n  if (radix == 10) {\n    let decimals = decimalCount32(value);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa32_dec_core(changetype<usize>(out) + sign, value, decimals);\n  } else if (radix == 16) {\n    let decimals = (31 - clz(value) >> 2) + 1;\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa32_hex_core(changetype<usize>(out) + sign, value, decimals);\n  } else {\n    let val32 = u32(value);\n    let decimals = ulog_base(val32, radix);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_any_core(changetype<usize>(out) + sign, val32, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\nexport function utoa64(value: u64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n  let out: String;\n\n  if (radix == 10) {\n    if (value <= u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out), val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = changetype<String>(__new(decimals << 1, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out), value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out), value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new(decimals << 1, idof<String>()));\n    utoa64_any_core(changetype<usize>(out), value, decimals, radix);\n  }\n  return out;\n}\n\nexport function itoa64(value: i64, radix: i32): String {\n  if (radix < 2 || radix > 36) {\n    throw new RangeError(\"toString() radix argument must be between 2 and 36\");\n  }\n  if (!value) return \"0\";\n\n  let sign = u32(value >>> 63) << 1;\n  if (sign) value = -value;\n  let out: String;\n\n  if (radix == 10) {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32    = <u32>value;\n      let decimals = decimalCount32(val32);\n      out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n      utoa32_dec_core(changetype<usize>(out) + sign, val32, decimals);\n    } else {\n      let decimals = decimalCount64High(value);\n      out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n      utoa64_dec_core(changetype<usize>(out) + sign, value, decimals);\n    }\n  } else if (radix == 16) {\n    let decimals = (63 - u32(clz(value)) >> 2) + 1;\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_hex_core(changetype<usize>(out) + sign, value, decimals);\n  } else {\n    let decimals = ulog_base(value, radix);\n    out = changetype<String>(__new((decimals << 1) + sign, idof<String>()));\n    utoa64_any_core(changetype<usize>(out) + sign, value, decimals, radix);\n  }\n  if (sign) store<u16>(changetype<usize>(out), CharCode.MINUS);\n  return out;\n}\n\n// @ts-ignore: decorator\n@lazy let _K: i32 = 0;\n\n// // @ts-ignore: decorator\n// @lazy\n// let _frc: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp: i32 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_minus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_plus: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _frc_pow: u64 = 0;\n\n// @ts-ignore: decorator\n@lazy let _exp_pow: i32 = 0;\n\n// @ts-ignore: decorator\n@inline\nfunction umul64f(u: u64, v: u64): u64 {\n  let u0 = u & 0xFFFFFFFF;\n  let v0 = v & 0xFFFFFFFF;\n\n  let u1 = u >> 32;\n  let v1 = v >> 32;\n\n  let l = u0 * v0;\n  let t = u1 * v0 + (l >> 32);\n  let w = u0 * v1 + (t & 0xFFFFFFFF);\n\n  w += 0x7FFFFFFF; // rounding\n\n  t >>= 32;\n  w >>= 32;\n\n  return u1 * v1 + t + w;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction umul64e(e1: i32, e2: i32): i32 {\n  return e1 + e2 + 64; // where 64 is significand size\n}\n\n// @ts-ignore: decorator\n@inline\nfunction normalizedBoundaries(f: u64, e: i32, isSingle: bool): void {\n  let frc = (f << 1) + 1;\n  let exp = e - 1;\n  let off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  let m = 1 + i32(f == (isSingle ? 0x00800000 : 0x0010000000000000));\n\n  _frc_plus  = frc;\n  _frc_minus = ((f << m) - 1) << e - m - exp;\n  _exp = exp;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisuRound(buffer: usize, len: i32, delta: u64, rest: u64, ten_kappa: u64, wp_w: u64): void {\n  let lastp = buffer + ((len - 1) << 1);\n  let digit = load<u16>(lastp);\n  while (\n    rest < wp_w &&\n    delta - rest >= ten_kappa && (\n      rest + ten_kappa < wp_w ||\n      wp_w - rest > rest + ten_kappa - wp_w\n    )\n  ) {\n    --digit;\n    rest += ten_kappa;\n  }\n  store<u16>(lastp, digit);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction getCachedPower(minExp: i32): void {\n  const c = reinterpret<f64>(0x3FD34413509F79FE); // 1 / lg(10) = 0.30102999566398114\n  let dk = (-61 - minExp) * c + 347;\t            // dk must be positive, so can do ceiling in positive\n  let k = <i32>dk;\n  k += i32(k != dk); // conversion with ceil\n\n  let index = (k >> 3) + 1;\n  _K = 348 - (index << 3);\t// decimal exponent no need lookup table\n  _frc_pow = load<u64>(FRC_POWERS + (<usize>index << alignof<u64>()));\n  _exp_pow = load<i16>(EXP_POWERS + (<usize>index << alignof<i16>()));\n}\n\n// @ts-ignore: decorator\n@inline\nfunction grisu2(value: f64, buffer: usize, sign: i32, isSingle: bool): i32 {\n  let frc: u64;\n  let exp: i32;\n\n  // frexp routine\n  if (isSingle) {\n    let uv = reinterpret<u32>(<f32>value);\n    exp = (uv & 0x7F800000) >>> 23;\n    let sid = uv & 0x007FFFFF;\n    frc = (u64(exp != 0) << 23) + sid;\n    exp = (exp || 1) - (0x7F + 23);\n  } else {\n    let uv = reinterpret<u64>(value);\n    exp = i32((uv & 0x7FF0000000000000) >>> 52);\n    let sid = uv & 0x000FFFFFFFFFFFFF;\n    frc = (u64(exp != 0) << 52) + sid;\n    exp = (exp || 1) - (0x3FF + 52);\n  }\n\n  normalizedBoundaries(frc, exp, isSingle);\n  getCachedPower(_exp);\n\n  // normalize\n  let off = <i32>clz<u64>(frc);\n  frc <<= off;\n  exp  -= off;\n\n  let frc_pow = _frc_pow;\n  let exp_pow = _exp_pow;\n\n  let w_frc = umul64f(frc, frc_pow);\n  let w_exp = umul64e(exp, exp_pow);\n\n  let wp_frc = umul64f(_frc_plus, frc_pow) - 1;\n  let wp_exp = umul64e(_exp, exp_pow);\n\n  let wm_frc = umul64f(_frc_minus, frc_pow) + 1;\n  let delta  = wp_frc - wm_frc;\n\n  return genDigits(buffer, w_frc, w_exp, wp_frc, wp_exp, delta, sign);\n}\n\nfunction genDigits(buffer: usize, w_frc: u64, w_exp: i32, mp_frc: u64, mp_exp: i32, delta: u64, sign: i32): i32 {\n  let one_exp = -mp_exp;\n  let one_frc = (<u64>1) << one_exp;\n  let mask    = one_frc - 1;\n\n  let wp_w_frc = mp_frc - w_frc;\n\n  let p1 = u32(mp_frc >> one_exp);\n  let p2 = mp_frc & mask;\n\n  let kappa = <i32>decimalCount32(p1);\n  let len = sign;\n\n  while (kappa > 0) {\n    let d: u32;\n    switch (kappa) {\n      case 10: { d = p1 / 1000000000; p1 %= 1000000000; break; }\n      case  9: { d = p1 /  100000000; p1 %=  100000000; break; }\n      case  8: { d = p1 /   10000000; p1 %=   10000000; break; }\n      case  7: { d = p1 /    1000000; p1 %=    1000000; break; }\n      case  6: { d = p1 /     100000; p1 %=     100000; break; }\n      case  5: { d = p1 /      10000; p1 %=      10000; break; }\n      case  4: { d = p1 /       1000; p1 %=       1000; break; }\n      case  3: { d = p1 /        100; p1 %=        100; break; }\n      case  2: { d = p1 /         10; p1 %=         10; break; }\n      case  1: { d = p1;              p1 =           0; break; }\n      default: { d = 0; break; }\n    }\n\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    --kappa;\n    let tmp = ((<u64>p1) << one_exp) + p2;\n    if (tmp <= delta) {\n      _K += kappa;\n      grisuRound(buffer, len, delta, tmp, <u64>load<u32>(POWERS10 + (<usize>kappa << alignof<u32>())) << one_exp, wp_w_frc);\n      return len;\n    }\n  }\n\n  while (true) {\n    p2    *= 10;\n    delta *= 10;\n\n    let d = p2 >> one_exp;\n    if (d | len) store<u16>(buffer + (len++ << 1), CharCode._0 + <u16>d);\n\n    p2 &= mask;\n    --kappa;\n    if (p2 < delta) {\n      _K += kappa;\n      wp_w_frc *= <u64>load<u32>(POWERS10 + (<usize>-kappa << alignof<u32>()));\n      grisuRound(buffer, len, delta, p2, one_frc, wp_w_frc);\n      return len;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction genExponent(buffer: usize, k: i32): i32 {\n  let sign = k < 0;\n  if (sign) k = -k;\n  let decimals = decimalCount32(k) + 1;\n  utoa32_dec_core(buffer, k, decimals);\n  store<u16>(buffer, <u16>select<u32>(CharCode.MINUS, CharCode.PLUS, sign));\n  return decimals;\n}\n\nfunction prettify(buffer: usize, length: i32, k: i32): i32 {\n  if (!k) {\n    store<u32>(buffer + (length << 1), CharCode.DOT | (CharCode._0 << 16));\n    return length + 2;\n  }\n\n  let kk = length + k;\n  if (length <= kk && kk <= 21) {\n    // 1234e7 -> 12340000000\n    for (let i = length; i < kk; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    store<u32>(buffer + (kk << 1), CharCode.DOT | (CharCode._0 << 16));\n    return kk + 2;\n  } else if (kk > 0 && kk <= 21) {\n    // 1234e-2 -> 12.34\n    let ptr = buffer + (kk << 1);\n    memory.copy(\n      ptr + 2,\n      ptr,\n      -k << 1\n    );\n    store<u16>(buffer + (kk << 1), CharCode.DOT);\n    return length + 1;\n  } else if (-6 < kk && kk <= 0) {\n    // 1234e-6 -> 0.001234\n    let offset = 2 - kk;\n    memory.copy(\n      buffer + (offset << 1),\n      buffer,\n      length << 1\n    );\n    store<u32>(buffer, CharCode._0 | (CharCode.DOT << 16));\n    for (let i = 2; i < offset; ++i) {\n      store<u16>(buffer + (i << 1), CharCode._0);\n    }\n    return length + offset;\n  } else if (length == 1) {\n    // 1e30\n    store<u16>(buffer, CharCode.e, 2);\n    length = genExponent(buffer + 4, kk - 1);\n    return length + 2;\n  } else {\n    let len = length << 1;\n    memory.copy(\n      buffer + 4,\n      buffer + 2,\n      len - 2\n    );\n    store<u16>(buffer,       CharCode.DOT, 2);\n    store<u16>(buffer + len, CharCode.e,   2);\n    length += genExponent(buffer + len + 4, kk - 1);\n    return length + 2;\n  }\n}\n\nfunction dtoa_core(buffer: usize, value: f64, isSingle: bool): i32 {\n  let sign = i32(value < 0);\n  if (sign) {\n    value = -value;\n    store<u16>(buffer, CharCode.MINUS);\n  }\n  // assert(value > 0 && value <= (isSingle ? f32.MAX_VALUE : f64.MAX_VALUE));\n  let len = grisu2(value, buffer, sign, isSingle);\n  len = prettify(buffer + (sign << 1), len - sign, _K);\n  return len + sign;\n}\n\n// @ts-ignore: decorator\n@lazy @inline const dtoa_buf = memory.data(MAX_DOUBLE_LENGTH << 1);\n\nexport function dtoa<T extends number>(value: T): String {\n  const isSingle = isFloat<T>() && sizeof<T>() == 4;\n  return dtoa_impl(value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_impl(value: f64, isSingle: bool): String {\n  if (value == 0) return \"0.0\";\n  if (!isFinite(value)) {\n    if (isNaN(value)) return \"NaN\";\n    return select<String>(\"-Infinity\", \"Infinity\", value < 0);\n  }\n  let size = dtoa_core(dtoa_buf, value, isSingle) << 1;\n  let result = changetype<String>(__new(size, idof<String>()));\n  memory.copy(changetype<usize>(result), dtoa_buf, size);\n  return result;\n}\n\nexport function itoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  let sign: u32 = 0;\n  if (isSigned<T>()) {\n    sign = u32(value < 0);\n    if (sign) {\n      if (sizeof<T>() == 1) {\n        if (value == -0x80) {\n          // -0x80  ->  -128\n          store<u64>(buffer,\n            <u64>CharCode.MINUS |\n            <u64>(CharCode._0 + 1) << 16 |\n            <u64>(CharCode._0 + 2) << 32 |\n            <u64>(CharCode._0 + 8) << 48\n          );\n          return 4;\n        }\n      }\n      if (sizeof<T>() == 2) {\n        if (value == -0x8000) {\n          // -0x8000  ->  -32768\n          store<u64>(buffer,\n            <u64>CharCode.MINUS |\n            <u64>(CharCode._0 + 3) << 16 |\n            <u64>(CharCode._0 + 2) << 32 |\n            <u64>(CharCode._0 + 7) << 48\n          ); // -327\n          store<u32>(buffer + 8,\n            (CharCode._0 + 6) << 0 |\n            (CharCode._0 + 8) << 16\n          ); // 68\n          return 6;\n        }\n      }\n      store<u16>(buffer, CharCode.MINUS);\n      // @ts-ignore\n      value = -value;\n    }\n  }\n  let dest = buffer + (sign << 1);\n  if (ASC_SHRINK_LEVEL <= 1) {\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        if (<u32>value < 10) {\n          store<u16>(dest, value | CharCode._0);\n          return 1 + sign;\n        }\n      } else {\n        if (<u64>value < 10) {\n          store<u16>(dest, value | CharCode._0);\n          return 1 + sign;\n        }\n      }\n    } else {\n      if (value < 10) {\n        store<u16>(buffer, value | CharCode._0);\n        return 1;\n      }\n    }\n  }\n  let decimals: u32 = 0;\n  if (sizeof<T>() <= 4) {\n    let val32 = <u32>value;\n    decimals = decimalCount32(val32);\n    utoa32_dec_core(dest, val32, decimals);\n  } else {\n    if (<u64>value <= <u64>u32.MAX_VALUE) {\n      let val32 = <u32>value;\n      decimals = decimalCount32(val32);\n      utoa32_dec_core(dest, val32, decimals);\n    } else {\n      let val64 = <u64>value;\n      decimals = decimalCount64High(val64);\n      utoa64_dec_core(dest, val64, decimals);\n    }\n  }\n  return sign + decimals;\n}\n\nexport function dtoa_buffered<T extends number>(buffer: usize, value: T): u32 {\n  const isSingle = isFloat<T>() && sizeof<T>() == 4;\n  return dtoa_buffered_impl(buffer, value, isSingle);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction dtoa_buffered_impl(buffer: usize, value: f64, isSingle: bool): u32 {\n  if (value == 0) {\n    store<u16>(buffer, CharCode._0);\n    store<u16>(buffer, CharCode.DOT, 2);\n    store<u16>(buffer, CharCode._0,  4);\n    return 3;\n  }\n  if (!isFinite(value)) {\n    if (isNaN(value)) {\n      store<u16>(buffer, CharCode.N);\n      store<u16>(buffer, CharCode.a, 2);\n      store<u16>(buffer, CharCode.N, 4);\n      return 3;\n    } else {\n      let sign = value < 0;\n      if (sign) {\n        store<u16>(buffer, CharCode.MINUS); // -\n        buffer += 2;\n      }\n      store<u64>(buffer, 0x690066006E0049, 0); // ifnI\n      store<u64>(buffer, 0x7900740069006E, 8); // ytin\n      return 8 + u32(sign);\n    }\n  }\n  return dtoa_core(buffer, value, isSingle);\n}\n","import {\n  itoa32,\n  utoa32,\n  itoa64,\n  utoa64,\n  dtoa,\n  itoa_buffered,\n  dtoa_buffered,\n  MAX_DOUBLE_LENGTH\n} from \"./number\";\n\nimport {\n  ipow32\n} from \"../math\";\n\n// All tables are stored as two staged lookup tables (static tries)\n// because the full range of Unicode symbols can't be efficiently\n// represented as-is in memory (see Unicode spec ch 5, p.196):\n// https://www.unicode.org/versions/Unicode12.0.0/ch05.pdf\n// Tables have been generated using these forked musl tools:\n// https://github.com/MaxGraey/musl-chartable-tools/tree/case-ignorable\n\n// Lookup table to check if a character is alphanumeric or not\n// See: https://git.musl-libc.org/cgit/musl/tree/src/ctype/alpha.h\n// size: 3904 bytes\n// @ts-ignore\n@inline @lazy const ALPHA_TABLE = memory.data<u8>([\n  18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,\n  41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,\n  68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,\n  93,94,16,95,96,97,98,17,17,17,99,100,101,16,16,16,16,16,16,16,16,16,16,17,17,\n  17,17,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,103,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,17,17,104,105,16,16,106,107,17,17,17,17,17,17,17,17,17,17,17,17,17,\n  17,17,17,17,17,17,17,17,17,17,108,17,17,17,17,109,110,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  17,111,112,16,16,16,16,16,16,16,16,16,113,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,114,115,116,117,16,16,16,16,16,16,16,16,118,\n  119,120,16,16,16,16,16,121,122,16,16,16,16,123,16,16,124,16,16,16,16,16,16,16,\n  16,16,125,16,16,16,\n  16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,\n  255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,\n  251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,\n  255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,\n  255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,\n  31,254,225,255,\n  159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,\n  255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,\n  1,255,7,0,0,0,0,0,0,255,255,223,255,255,0,240,255,248,3,255,255,255,255,255,\n  255,255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,\n  197,227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,\n  94,192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,\n  159,249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,\n  255,195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,\n  207,255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,255,223,\n  253,255,255,255,255,231,223,93,240,128,207,255,0,252,238,255,127,252,255,255,\n  251,47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,\n  0,0,0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,\n  0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,\n  31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,\n  255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,\n  255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,\n  127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,\n  7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,\n  255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,\n  255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,\n  255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,\n  63,\n  0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,\n  255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,\n  127,254,255,31,0,255,3,255,3,128,0,0,128,1,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,\n  255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,\n  255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,\n  128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,\n  255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,\n  224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,\n  0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,\n  255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,\n  255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,\n  255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,\n  255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,255,0,0,0,0,0,0,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,\n  31,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,\n  255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,\n  0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,\n  255,255,255,252,7,0,0,0,0,224,255,191,255,255,255,255,0,0,0,255,255,255,255,\n  255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,\n  255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,\n  255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,\n  255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,\n  126,0,127,127,255,255,255,255,255,247,255,3,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,\n  255,\n  15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,\n  252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,\n  254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,\n  252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,\n  0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,\n  255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,\n  255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,\n  127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,\n  254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,\n  255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,\n  0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,\n  0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  255,27,3,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,31,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,\n  0,192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,\n  255,255,255,255,199,255,240,0,255,255,255,255,71,0,255,255,255,255,255,255,\n  255,255,30,192,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,\n  127,189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,\n  253,237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,187,7,255,131,3,0,0,0,255,255,255,255,255,\n  255,255,255,179,0,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  255,255,255,63,127,0,0,0,63,0,0,0,0,255,255,255,255,255,255,255,127,17,0,255,\n  3,0,0,0,0,255,255,255,255,255,255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,\n  7,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,\n  255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,3,0,128,\n  127,242,111,255,255,255,191,153,7,0,255,3,0,0,0,0,0,0,0,0,255,252,255,255,255,\n  255,255,252,26,0,0,0,255,255,255,255,255,255,231,127,0,0,255,255,255,255,255,\n  255,255,255,255,32,0,0,0,0,255,255,255,255,255,255,255,1,255,253,255,255,255,\n  255,127,127,1,0,255,3,0,0,252,255,255,255,252,255,255,254,127,0,0,0,0,0,0,0,0,\n  0,127,251,255,255,255,255,127,180,203,0,255,3,191,253,255,255,255,127,123,1,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,127,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,255,255,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,\n  0,255,255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,\n  255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,135,\n  255,255,255,255,255,255,255,128,255,255,0,0,0,0,0,0,0,0,11,0,3,0,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,0,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,0,0,\n  255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,\n  127,0,0,0,0,0,0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,255,\n  223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,\n  255,123,95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,63,255,255,255,253,255,255,247,255,255,255,\n  247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,255,253,\n  255,255,255,253,255,255,247,207,255,255,255,255,255,255,127,255,255,249,219,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,31,\n  128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,15,255,\n  3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,143,8,\n  255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,239,255,255,255,150,254,247,10,\n  132,234,150,170,150,247,247,94,255,251,255,15,238,251,255,15,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3\n]);\n\n// size: 1568 bytes (compressed to ~1380 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASED = memory.data<u8>([\n  18,19,20,21,22,23,16,16,16,16,16,16,16,16,16,16,\n  24,16,16,25,16,16,16,16,16,16,16,16,26,27,17,28,\n  29,30,16,16,31,16,16,16,16,16,16,16,32,33,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,34,35,16,16,16,36,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,37,16,16,16,38,\n  16,16,16,16,39,16,16,16,16,16,16,16,40,16,16,16,\n  16,16,16,16,16,16,16,16,41,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,42,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,43,44,45,46,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,47,16,16,16,16,16,16,\n  16,48,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,254,255,255,7,254,255,255,7,0,0,0,0,0,4,32,4,\n  255,255,127,255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,247,240,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,239,255,255,255,255,1,3,0,0,0,31,0,0,0,\n  0,0,0,0,0,0,0,0,32,0,0,0,0,0,207,188,64,215,255,255,251,255,255,255,\n  255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  3,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,254,255,\n  255,255,127,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,\n  191,32,255,255,255,255,255,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,255,255,255,255,255,255,63,63,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,1,255,255,255,255,255,231,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,\n  255,255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,\n  132,252,47,62,80,189,31,242,224,67,0,0,255,255,255,255,24,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,0,255,255,255,255,255,127,255,255,\n  255,255,255,127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,120,12,0,\n  255,255,255,255,191,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,63,0,0,\n  255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,255,255,\n  255,255,255,255,255,255,255,255,255,120,255,255,255,255,255,255,252,7,0,0,0,0,96,7,\n  0,0,0,0,0,0,255,255,255,255,255,247,255,1,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,0,0,0,0,127,0,248,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,7,\n  254,255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,\n  255,255,15,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,7,0,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,\n  255,255,255,223,100,222,255,235,239,255,255,255,255,255,255,255,191,231,223,223,255,255,255,123,\n  95,252,253,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,\n  253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,255,255,127,255,255,\n  255,253,255,255,255,253,255,255,247,15,0,0,0,0,0,0,255,255,255,255,255,255,255,255,\n  15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,255,255,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0\n]);\n\n// size: 2976 bytes (compressed to ~2050 bytes after binaryen)\n// @ts-ignore: decorator\n@lazy @inline const CASE_IGNORABLES = memory.data<u8>([\n  18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,\n  33,16,16,34,16,16,16,35,36,37,38,39,40,41,16,42,\n  43,16,16,16,16,16,16,16,16,16,16,16,44,45,46,16,\n  47,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  48,16,16,16,49,16,50,51,52,53,54,55,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,56,16,16,57,58,\n  16,59,60,61,16,16,16,16,16,16,62,16,16,63,64,65,\n  66,67,68,69,70,71,72,73,74,75,76,16,77,78,79,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,80,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,81,82,16,16,16,83,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,84,16,16,16,\n  16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,\n  16,85,86,16,16,16,16,16,16,16,87,16,16,16,16,16,\n  88,89,90,16,16,16,16,16,91,92,16,16,16,16,16,16,\n  16,16,16,93,16,16,16,16,16,16,16,16,16,16,16,16,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  0,0,0,0,128,64,0,4,0,0,0,64,1,0,0,0,0,0,0,0,0,161,144,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,\n  255,255,255,255,255,255,48,4,176,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,\n  0,0,254,255,255,255,255,191,182,0,0,0,0,0,16,0,63,0,255,23,0,0,0,0,\n  1,248,255,255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,255,61,0,0,\n  0,128,2,0,0,0,255,255,255,7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,\n  0,0,0,0,0,248,63,36,0,0,192,255,255,63,0,0,0,0,0,14,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,255,7,0,0,0,0,0,0,20,\n  254,33,254,0,12,0,2,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,64,\n  6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,\n  190,33,0,0,12,0,0,252,2,0,0,0,0,0,0,144,30,32,96,0,12,0,0,0,\n  4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,0,0,0,0,0,0,192,\n  193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,\n  3,0,0,0,0,0,0,24,30,32,0,0,12,0,0,0,2,0,0,0,0,0,0,0,\n  0,4,92,0,0,0,0,0,0,0,0,0,0,0,242,7,192,127,0,0,0,0,0,0,\n  0,0,0,0,0,0,242,31,64,63,0,0,0,0,0,0,0,0,0,3,0,0,160,2,\n  0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,\n  0,0,0,0,0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,\n  0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,\n  0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,143,32,0,0,0,0,\n  0,120,0,0,0,0,0,0,8,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,9,0,0,0,0,\n  0,0,64,127,229,31,248,159,0,0,0,0,128,0,255,255,1,0,0,0,0,0,0,0,\n  15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,\n  0,0,0,0,64,163,3,0,0,0,0,0,0,240,207,0,0,0,0,0,0,0,0,63,\n  0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,3,0,0,0,0,0,240,255,255,\n  255,255,255,255,255,7,0,1,0,0,0,248,255,255,255,255,255,255,255,255,255,255,255,251,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,\n  3,224,0,224,0,224,0,96,0,248,0,3,144,124,0,0,0,0,0,0,223,255,2,128,\n  0,0,255,31,0,0,0,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,128,0,0,0,0,0,0,0,0,\n  0,0,0,0,255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,60,62,8,\n  0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,0,0,0,0,0,0,112,\n  0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,16,0,0,0,0,0,0,\n  0,0,0,0,0,128,247,191,0,0,0,240,0,0,0,0,0,0,0,0,0,0,3,0,\n  255,255,255,255,3,0,0,0,0,0,0,0,0,0,1,0,0,7,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,3,68,8,0,0,96,16,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,\n  128,255,3,0,0,0,0,0,7,0,0,0,0,0,200,51,0,128,0,0,96,0,0,0,\n  0,0,0,0,0,126,102,0,8,16,0,0,0,0,1,16,0,0,0,0,0,0,157,193,\n  2,0,0,32,0,48,88,0,0,0,0,0,0,0,0,0,0,0,0,248,0,14,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,\n  255,255,8,0,255,255,0,0,0,0,36,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,128,128,64,0,4,0,0,0,64,1,0,0,0,0,0,1,0,\n  0,0,0,192,0,0,0,0,0,0,0,0,8,0,0,14,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,0,0,0,0,135,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,\n  0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  192,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,3,0,0,0,0,0,120,38,\n  0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,\n  3,0,0,0,0,0,192,127,0,158,0,0,0,0,0,0,0,0,0,0,0,128,211,64,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,248,7,0,0,\n  3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,\n  0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,\n  0,0,0,0,0,0,248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,\n  0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,88,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,\n  0,252,127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,\n  0,0,0,0,0,0,0,0,0,0,252,255,255,252,109,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,1,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,15,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,128,0,0,0,0,0,0,0,128,255,255,0,0,0,0,0,0,0,0,27,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,\n  231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  255,255,255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,\n  0,0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,63,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  240,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n  0,0,0,0,0,0,0,248\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const LOWER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  91,92,93,94,95,96,\n  97,98,99,100,101,102,103,104,105,106,107,108,109,\n  110,111,112,113,114,115,116,117,118,119,120,121,122,\n  123,124,125,126,127\n]);\n\n// @ts-ignore: decorator\n@lazy @inline const UPPER127 = memory.data<u8>([\n  0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,\n  16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,\n  32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,\n  48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,\n  64,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  91,92,93,94,95,96,\n  65,66,67,68,69,70,71,72,73,74,75,76,77,\n  78,79,80,81,82,83,84,85,86,87,88,89,90,\n  123,124,125,126,127\n]);\n\n// 23 * 8 = 184 bytes\n// @ts-ignore: decorator\n@lazy @inline const POWERS10 = memory.data<f64>([\n  1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,\n  1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,\n  1e20, 1e21, 1e22\n]);\n\n// @ts-ignore: decorator\n@inline\nexport const enum CharCode {\n  PERCENT = 0x25,\n  PLUS = 0x2B,\n  MINUS = 0x2D,\n  DOT = 0x2E,\n  _0 = 0x30,\n  _1 = 0x31,\n  _2 = 0x32,\n  _3 = 0x33,\n  _4 = 0x34,\n  _5 = 0x35,\n  _6 = 0x36,\n  _7 = 0x37,\n  _8 = 0x38,\n  _9 = 0x39,\n  A = 0x41,\n  B = 0x42,\n  E = 0x45,\n  I = 0x49,\n  N = 0x4E,\n  O = 0x4F,\n  X = 0x58,\n  Z = 0x5A,\n  a = 0x61,\n  b = 0x62,\n  e = 0x65,\n  n = 0x6E,\n  o = 0x6F,\n  u = 0x75,\n  x = 0x78,\n  z = 0x7A\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isAscii(c: u32): bool {\n  return !(c >> 7);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isLower8(c: u32): bool {\n  return c - CharCode.a < 26;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isUpper8(c: u32): bool {\n  return c - CharCode.A < 26;\n}\n\nexport function isSpace(c: u32): bool {\n  if (c < 0x1680) { // < <LS> (1)\n    // <SP>, <TAB>, <LF>, <VT>, <FF>, <CR> and <NBSP>\n    // (c == 0x20 || c == 0xA0) was optimized to (c | 0x80) == 0xA0\n    return ((c | 0x80) == 0xA0) || (c - 0x09 <= 0x0D - 0x09);\n  }\n  if (c - 0x2000 <= 0x200A - 0x2000) return true;\n  switch (c) {\n    case 0x1680: // <LS> (1)\n    case 0x2028: // <LS> (2)\n    case 0x2029: // <PS>\n    case 0x202F: // <NNS>\n    case 0x205F: // <MMSP>\n    case 0x3000: // <IS>\n    case 0xFEFF: return true; // <ZWNBSP>\n  }\n  return false;\n}\n\nexport function isAlpha(c: u32): bool {\n  if (isAscii(c)) return (c | 32) - CharCode.a < 26;\n  if (c < 0x20000) {\n    // @ts-ignore: cast\n    return stagedBinaryLookup(ALPHA_TABLE, c);\n  }\n  return c < 0x2FFFE;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCased(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0x1F18A && stagedBinaryLookup(CASED, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isCaseIgnorable(c: u32): bool {\n  // @ts-ignore: cast\n  return c < 0xE01F0 && stagedBinaryLookup(CASE_IGNORABLES, c);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function isFinalSigma(buffer: usize, index: isize, len: isize): bool {\n  const lookaheadLimit = 30; // max lookahead limit\n  let found = false;\n  let pos = index;\n  let minPos = max(0, pos - lookaheadLimit);\n  while (pos > minPos) {\n    let c = codePointBefore(buffer, pos);\n    if (!isCaseIgnorable(c)) {\n      if (isCased(c)) {\n        found = true;\n      } else {\n        return false;\n      }\n    }\n    pos -= isize(c >= 0x10000) + 1;\n  }\n  if (!found) return false;\n  pos = index + 1;\n  let maxPos = min(pos + lookaheadLimit, len);\n  while (pos < maxPos) {\n    let c = <u32>load<u16>(buffer + (pos << 1));\n    if (u32((c & 0xFC00) == 0xD800) & u32(pos + 1 != len)) {\n      let c1 = <u32>load<u16>(buffer + (pos << 1), 2);\n      if ((c1 & 0xFC00) == 0xDC00) {\n        c = (c - 0xD800 << 10) + (c1 - 0xDC00) + 0x10000;\n      }\n    }\n    if (!isCaseIgnorable(c)) {\n      return !isCased(c);\n    }\n    pos += isize(c >= 0x10000) + 1;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction codePointBefore(buffer: usize, index: isize): i32 {\n  if (index <= 0) return -1;\n  let c = <u32>load<u16>(buffer + (index - 1 << 1));\n  if (u32((c & 0xFC00) == 0xDC00) & u32(index - 2 >= 0)) {\n    let c1 = <u32>load<u16>(buffer + (index - 2 << 1));\n    if ((c1 & 0xFC00) == 0xD800) {\n      return ((c1 & 0x3FF) << 10) + (c & 0x3FF) + 0x10000;\n    }\n  }\n  return (c & 0xF800) == 0xD800 ? 0xFFFD : c;\n}\n\n// Search routine for two-staged lookup tables\nfunction stagedBinaryLookup(table: usize, c: u32): bool {\n  return <bool>((load<u8>(table + (<u32>load<u8>(table + (c >>> 8)) << 5) + ((c & 255) >> 3)) >>> (c & 7)) & 1);\n}\n\nexport function compareImpl(str1: string, index1: usize, str2: string, index2: usize, len: usize): i32 {\n  let ptr1 = changetype<usize>(str1) + (index1 << 1);\n  let ptr2 = changetype<usize>(str2) + (index2 << 1);\n  if (ASC_SHRINK_LEVEL < 2) {\n    if (len >= 4 && !((ptr1 & 7) | (ptr2 & 7))) {\n      do {\n        if (load<u64>(ptr1) != load<u64>(ptr2)) break;\n        ptr1 += 8;\n        ptr2 += 8;\n        len  -= 4;\n      } while (len >= 4);\n    }\n  }\n  while (len--) {\n    let a = <i32>load<u16>(ptr1);\n    let b = <i32>load<u16>(ptr2);\n    if (a != b) return a - b;\n    ptr1 += 2;\n    ptr2 += 2;\n  }\n  return 0;\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toLower8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c | u32(isUpper8(c)) << 5;\n  } else {\n    return <u32>load<u8>(LOWER127 + c);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nexport function toUpper8(c: u32): u32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    return c & ~(u32(isLower8(c)) << 5);\n  } else {\n    return <u32>load<u8>(UPPER127 + c);\n  }\n}\n\n/** Parses a string to an integer (usually), using the specified radix. */\nexport function strtol<T>(str: string, radix: i32 = 0): T {\n  let len = str.length;\n  if (!len) {\n    if (isFloat<T>()) {\n      // @ts-ignore: cast\n      return <T>NaN;\n    } else {\n      // @ts-ignore: cast\n      return <T>0;\n    }\n  }\n\n  let ptr = changetype<usize>(str) /* + HEAD -> offset */;\n  let code = <u32>load<u16>(ptr);\n\n  // trim white spaces\n  while (isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  // determine sign\n  // @ts-ignore\n  let sign: T = 1;\n  if (code == CharCode.MINUS || code == CharCode.PLUS) {\n    if (!--len) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    if (code == CharCode.MINUS) {\n      // @ts-ignore: type\n      sign = -1;\n    }\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // See https://tc39.es/ecma262/#sec-parseint-string-radix\n  if (radix) {\n    if (radix < 2 || radix > 36) {\n      if (isFloat<T>()) {\n        // @ts-ignore: cast\n        return <T>NaN;\n      } else {\n        // @ts-ignore: cast\n        return <T>0;\n      }\n    }\n    // handle case as parseInt(\"0xFF\", 16) by spec\n    if (radix == 16) {\n      if (\n        len > 2 &&\n        code == CharCode._0 &&\n        (<u32>load<u16>(ptr, 2) | 32) == CharCode.x\n      ) {\n        ptr += 4; len -= 2;\n      }\n    }\n  } else {\n    // determine radix by literal prefix\n    if (code == CharCode._0 && len > 2) {\n      switch (<u32>load<u16>(ptr, 2) | 32) {\n        case CharCode.b: {\n          ptr += 4; len -= 2;\n          radix = 2;\n          break;\n        }\n        case CharCode.o: {\n          ptr += 4; len -= 2;\n          radix = 8;\n          break;\n        }\n        case CharCode.x: {\n          ptr += 4; len -= 2;\n          radix = 16;\n          break;\n        }\n      }\n    }\n    if (!radix) radix = 10;\n  }\n\n  // calculate value\n  // @ts-ignore: type\n  let num: T = 0;\n  let initial = len - 1;\n  while (len--) {\n    code = <u32>load<u16>(ptr);\n    if (code - CharCode._0 < 10) {\n      code -= CharCode._0;\n    } else if (code - CharCode.A <= <u32>(CharCode.Z - CharCode.A)) {\n      code -= CharCode.A - 10;\n    } else if (code - CharCode.a <= <u32>(CharCode.z - CharCode.a)) {\n      code -= CharCode.a - 10;\n    }\n    if (code >= <u32>radix) {\n      if (initial == len) {\n        if (isFloat<T>()) {\n          // @ts-ignore: cast\n          return <T>NaN;\n        } else {\n          // @ts-ignore: cast\n          return <T>0;\n        }\n      }\n      break;\n    }\n    // @ts-ignore: type\n    num = num * radix + code;\n    ptr += 2;\n  }\n  // @ts-ignore: type\n  return sign * num;\n}\n\nexport function strtod(str: string): f64 {\n  let len = str.length;\n  if (!len) return NaN;\n\n  let ptr  = changetype<usize>(str);\n  let code = <u32>load<u16>(ptr);\n\n  let sign = 1.0;\n  // skip white spaces\n  while (len && isSpace(code)) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (!len) return NaN;\n\n  // try parse '-' or '+'\n  if (code == CharCode.MINUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return NaN;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  // try parse Infinity\n  if (len >= 8 && code == CharCode.I) {\n    if (\n      load<u64>(ptr, 0) == 0x690066006E0049 && // ifnI\n      load<u64>(ptr, 8) == 0x7900740069006E    // ytin\n    ) {\n      return Infinity * sign;\n    }\n    return NaN;\n  }\n  // validate next symbol\n  if (code != CharCode.DOT && <u32>(code - CharCode._0) >= 10) {\n    return NaN;\n  }\n  let savedPtr = ptr;\n  // skip zeros\n  while (code == CharCode._0) {\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  if (len <= 0) return 0.0 * sign;\n  const capacity = 19; // int(64 * 0.3010)\n  let pointed = false;\n  let consumed = 0;\n  let position = 0;\n  let x: u64 = 0;\n  if (code == CharCode.DOT) {\n    let noDigits = !(savedPtr - ptr);\n    ptr += 2; --len;\n    if (!len && noDigits) return NaN;\n    for (pointed = true; (code = <u32>load<u16>(ptr)) == CharCode._0; --position, ptr += 2) --len;\n    if (len <= 0) return 0.0 * sign;\n    if (!position && noDigits && code - CharCode._0 >= 10) return NaN;\n  }\n  for (let digit = code - CharCode._0; digit < 10 || (code == CharCode.DOT && !pointed); digit = code - CharCode._0) {\n    if (digit < 10) {\n      x = consumed < capacity ? 10 * x + digit : x | u64(!!digit);\n      ++consumed;\n    } else {\n      position = consumed;\n      pointed = true;\n    }\n    if (!--len) break;\n    code = <u32>load<u16>(ptr += 2);\n  }\n\n  if (!pointed) position = consumed;\n  return copysign<f64>(scientific(x, position - min(capacity, consumed) + parseExp(ptr, len)), sign);\n}\n\nexport function strtob(str: string): bool {\n  let size: usize = str.length << 1;\n  let offset: usize = 0;\n  if (size > 8) {\n    // try trim end whitespaces first\n    while (size && isSpace(load<u16>(changetype<usize>(str) + size - 2))) size -= 2;\n    if (size > 8) {\n      // trim start whitespaces\n      while (offset < size && isSpace(load<u16>(changetype<usize>(str) + offset))) offset += 2;\n      size -= offset;\n    }\n  }\n  if (size != 8) return false;\n  // \"true\" represents as \\00\\e\\00\\u\\00\\e\\00\\t (00 65 00 75 00 72 00 74)\n  return load<u64>(changetype<usize>(str) + offset) == 0x0065_0075_0072_0074;\n}\n\nexport function joinBooleanArray(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) return select(\"true\", \"false\", load<bool>(dataStart));\n\n  let sepLen = separator.length;\n  let valueLen = 5; // max possible length of element len(\"false\")\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: bool;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<bool>(dataStart + i);\n    valueLen = 4 + i32(!value);\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(select(\"true\", \"false\", value)),\n      <usize>valueLen << 1\n    );\n    offset += valueLen;\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<bool>(dataStart + <usize>lastIndex);\n  valueLen = 4 + i32(!value);\n  memory.copy(\n    changetype<usize>(result) + (<usize>offset << 1),\n    changetype<usize>(select(\"true\", \"false\", value)),\n    valueLen << 1\n  );\n  offset += valueLen;\n\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinIntegerArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    let value = load<T>(dataStart);\n    if (isSigned<T>()) {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(itoa32(<i32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(itoa64(<i32>value, 10));\n      }\n    } else {\n      if (sizeof<T>() <= 4) {\n        // @ts-ignore: type\n        return changetype<string>(utoa32(<u32>value, 10));\n      } else {\n        // @ts-ignore: type\n        return changetype<string>(utoa64(<u64>value, 10));\n      }\n    }\n  }\n\n  let sepLen = separator.length;\n  const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + i32(isSigned<T>());\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += itoa_buffered<T>(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinFloatArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    return changetype<string>(dtoa(\n      // @ts-ignore: type\n      load<T>(dataStart))\n    );\n  }\n\n  const valueLen = MAX_DOUBLE_LENGTH;\n  let sepLen = separator.length;\n  let estLen = (valueLen + sepLen) * lastIndex + valueLen;\n  let result = changetype<string>(__new(estLen << 1, idof<string>()));\n  let offset = 0;\n  let value: T;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  offset += dtoa_buffered(changetype<usize>(result) + (<usize>offset << 1), value);\n  if (estLen > offset) return result.substring(0, offset);\n  return result;\n}\n\nexport function joinStringArray(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  if (!lastIndex) {\n    // @ts-ignore: type\n    return load<string>(dataStart) || \"\";\n  }\n  let estLen = 0;\n  let value: string;\n  for (let i = 0; i < length; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (changetype<usize>(value) != 0) estLen += value.length;\n  }\n  let offset = 0;\n  let sepLen = separator.length;\n  let result = changetype<string>(__new((estLen + sepLen * lastIndex) << 1, idof<string>()));\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<string>(dataStart + (<usize>i << alignof<string>()));\n    if (changetype<usize>(value) != 0) {\n      let valueLen = value.length;\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(value),\n        <usize>valueLen << 1\n      );\n      offset += valueLen;\n    }\n    if (sepLen) {\n      memory.copy(\n        changetype<usize>(result) + (<usize>offset << 1),\n        changetype<usize>(separator),\n        <usize>sepLen << 1\n      );\n      offset += sepLen;\n    }\n  }\n  value = load<string>(dataStart + (<usize>lastIndex << alignof<string>()));\n  if (changetype<usize>(value) != 0) {\n    memory.copy(\n      changetype<usize>(result) + (<usize>offset << 1),\n      changetype<usize>(value),\n      <usize>value.length << 1\n    );\n  }\n  return result;\n}\n\nexport function joinReferenceArray<T>(dataStart: usize, length: i32, separator: string): string {\n  let lastIndex = length - 1;\n  if (lastIndex < 0) return \"\";\n  let value: T;\n  if (!lastIndex) {\n    value = load<T>(dataStart);\n    // @ts-ignore: type\n    return value != null ? value.toString() : \"\";\n  }\n  let result = \"\";\n  let sepLen = separator.length;\n  for (let i = 0; i < lastIndex; ++i) {\n    value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    // @ts-ignore: type\n    if (value != null) result += value.toString();\n    if (sepLen) result += separator;\n  }\n  value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));\n  // @ts-ignore: type\n  if (value != null) result += value.toString();\n  return result;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction scientific(significand: u64, exp: i32): f64 {\n  if (!significand || exp < -342) return 0;\n  if (exp > 308) return Infinity;\n  // Try use fast path\n  // Use fast path for string-to-double conversion if possible\n  // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion\n  // Simple integer\n  let significandf = <f64>significand;\n  if (!exp) return significandf;\n  if (exp > 22 && exp <= 22 + 15) {\n    significandf *= pow10(exp - 22);\n    exp = 22;\n  }\n  if (significand <= 9007199254740991 && abs(exp) <= 22) {\n    if (exp > 0) return significandf * pow10(exp);\n    return significandf / pow10(-exp);\n  } else if (exp < 0) {\n    return scaledown(significand, exp);\n  } else {\n    return scaleup(significand, exp);\n  }\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaledown(significand: u64, exp: i32): f64 {\n  const denom: u64 = 6103515625; // 1e14 * 0x1p-14\n  const scale = reinterpret<f64>(0x3F06849B86A12B9B); // 1e-14 * 0x1p32\n\n  let shift = clz(significand);\n  significand <<= shift;\n  shift = exp - shift;\n\n  for (; exp <= -14; exp += 14) {\n    let q = significand / denom;\n    let r = significand % denom;\n    let s = clz(q);\n    significand = (q << s) + <u64>nearest(scale * <f64>(r << (s - 18)));\n    shift -= s;\n  }\n  let b = <u64>ipow32(5, -exp);\n  let q = significand / b;\n  let r = significand % b;\n  let s = clz(q);\n  significand = (q << s) + <u64>(reinterpret<f64>(reinterpret<u64>(<f64>r) + (s << 52)) / <f64>b);\n  shift -= s;\n\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction scaleup(significand: u64, exp: i32): f64 {\n  const coeff: u32 = 1220703125; // 1e13 * 0x1p-13;\n  let shift = ctz(significand);\n  significand >>= shift;\n  shift += exp;\n\n  __fixmulShift = shift;\n  for (; exp >= 13; exp -= 13) {\n    significand = fixmul(significand, coeff);\n  }\n  significand = fixmul(significand, <u32>ipow32(5, exp));\n  shift = __fixmulShift;\n  return NativeMath.scalbn(<f64>significand, <i32>shift);\n}\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction parseExp(ptr: usize, len: i32): i32 {\n  let sign = 1, magnitude = 0;\n  let code = <u32>load<u16>(ptr);\n  // check code is 'e' or 'E'\n  if ((code | 32) != CharCode.e) return 0;\n\n  if (!--len) return 0;\n  code = <u32>load<u16>(ptr += 2);\n  if (code == CharCode.MINUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n    sign = -1;\n  } else if (code == CharCode.PLUS) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  // skip zeros\n  while (code == CharCode._0) {\n    if (!--len) return 0;\n    code = <u32>load<u16>(ptr += 2);\n  }\n  for (let digit: u32 = code - CharCode._0; len && digit < 10; digit = code - CharCode._0) {\n    if (magnitude >= 3200) return sign * 3200;\n    magnitude = 10 * magnitude + digit;\n    code = <u32>load<u16>(ptr += 2);\n    --len;\n  }\n  return sign * magnitude;\n}\n\n// @ts-ignore: decorator\n@lazy let __fixmulShift: u64 = 0;\n\n// Adopted from metallic lib:\n// https://github.com/jdh8/metallic/blob/master/src/stdlib/parse/scientific.h\n// @ts-ignore: decorator\n@inline\nfunction fixmul(a: u64, b: u32): u64 {\n  let low  = (a & 0xFFFFFFFF) * b;\n  let high = (a >> 32) * b + (low >> 32);\n  let overflow = <u32>(high >> 32);\n  let space = clz(overflow);\n  let revspace: u64 = 32 - space;\n  __fixmulShift += revspace;\n  return (high << space | (low & 0xFFFFFFFF) >> revspace) + (low << space >> 31 & 1);\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pow10(n: i32): f64 {\n  // argument `n` should bounds in [0, 22] range\n  return load<f64>(POWERS10 + (n << alignof<f64>()));\n}\n","import { Math as JSMath } from \"./bindings/dom\";\nexport { JSMath };\n\nimport {\n  pow_lut, exp_lut, exp2_lut, log_lut, log2_lut,\n  powf_lut, expf_lut, exp2f_lut, logf_lut, log2f_lut\n} from \"./util/math\";\n\nimport {\n  abs as builtin_abs,\n  ceil as builtin_ceil,\n  clz as builtin_clz,\n  copysign as builtin_copysign,\n  floor as builtin_floor,\n  max as builtin_max,\n  min as builtin_min,\n  sqrt as builtin_sqrt,\n  trunc as builtin_trunc\n} from \"./builtins\";\n\n// SUN COPYRIGHT NOTICE\n//\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this software\n// is freely granted, provided that this notice is preserved.\n//\n// Applies to all functions marked with a comment referring here.\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy let rempio2_y0: f64, rempio2_y1: f64, res128_hi: u64;\n\n/** @internal */\n// @ts-ignore: decorator\n@lazy @inline const PIO2_TABLE = memory.data<u64>([\n  0x00000000A2F9836E, 0x4E441529FC2757D1, 0xF534DDC0DB629599, 0x3C439041FE5163AB,\n  0xDEBBC561B7246E3A, 0x424DD2E006492EEA, 0x09D1921CFE1DEB1C, 0xB129A73EE88235F5,\n  0x2EBB4484E99C7026, 0xB45F7E413991D639, 0x835339F49C845F8B, 0xBDF9283B1FF897FF,\n  0xDE05980FEF2F118B, 0x5A0A6D1F6D367ECF, 0x27CB09B74F463F66, 0x9E5FEA2D7527BAC7,\n  0xEBE5F17B3D0739F7, 0x8A5292EA6BFB5FB1, 0x1F8D5D0856033046, 0xFC7B6BABF0CFBC20,\n  0x9AF4361DA9E39161, 0x5EE61B086599855F, 0x14A068408DFFD880, 0x4D73273106061557\n]);\n\n/** @internal */\nfunction R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3\n  const                   // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f64>(0x3FC5555555555555), //  1.66666666666666657415e-01\n    pS1 = reinterpret<f64>(0xBFD4D61203EB6F7D), // -3.25565818622400915405e-01\n    pS2 = reinterpret<f64>(0x3FC9C1550E884455), //  2.01212532134862925881e-01\n    pS3 = reinterpret<f64>(0xBFA48228B5688F3B), // -4.00555345006794114027e-02\n    pS4 = reinterpret<f64>(0x3F49EFE07501B288), //  7.91534994289814532176e-04\n    pS5 = reinterpret<f64>(0x3F023DE10DFDF709), //  3.47933107596021167570e-05\n    qS1 = reinterpret<f64>(0xC0033A271C8A2D4B), // -2.40339491173441421878e+00\n    qS2 = reinterpret<f64>(0x40002AE59C598AC8), //  2.02094576023350569471e+00\n    qS3 = reinterpret<f64>(0xBFE6066C1B8D0159), // -6.88283971605453293030e-01\n    qS4 = reinterpret<f64>(0x3FB3B8C5B12E9282); //  7.70381505559019352791e-02\n\n  let p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));\n  let q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));\n  return p / q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction expo2(x: f64, sign: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                       // see: musl/src/math/__expo2.c\n    k    = <u32>2043,\n    kln2 = reinterpret<f64>(0x40962066151ADD8B); // 0x1.62066151add8bp+10\n  let scale = reinterpret<f64>(<u64>((<u32>0x3FF + k / 2) << 20) << 32);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMath.exp(x - kln2) * (sign * scale) * scale;\n}\n\n/** @internal */\n/* Helper function to eventually get bits of π/2 * |x|\n *\n * y = π/4 * (frac << clz(frac) >> 11)\n * return clz(frac)\n *\n * Right shift 11 bits to make upper half fit in `double`\n */\n// @ts-ignore: decorator\n@inline\nfunction pio2_right(q0: u64, q1: u64): u64 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  // Bits of π/4\n  const p0: u64 = 0xC4C6628B80DC1CD1;\n  const p1: u64 = 0xC90FDAA22168C234;\n\n  const Ox1p_64 = reinterpret<f64>(0x3BF0000000000000); // 0x1p-64\n  const Ox1p_75 = reinterpret<f64>(0x3B40000000000000); // 0x1p-75\n\n  let shift = clz(q1);\n\n  q1 = q1 << shift | q0 >> (64 - shift);\n  q0 <<= shift;\n\n  let lo = umuldi(p1, q1);\n  let hi = res128_hi;\n\n  let ahi = hi >> 11;\n  let alo = lo >> 11 | hi << 53;\n  let blo = <u64>(Ox1p_75 * <f64>p0 * <f64>q1 + Ox1p_75 * <f64>p1 * <f64>q0);\n\n  rempio2_y0 = <f64>(ahi + u64(lo < blo));\n  rempio2_y1 = Ox1p_64 * <f64>(alo + blo);\n\n  return shift;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction umuldi(u: u64, v: u64): u64 {\n  let u1: u64 , v1: u64, w0: u64, w1: u64, t: u64;\n\n  u1 = u & 0xFFFFFFFF;\n  v1 = v & 0xFFFFFFFF;\n\n  u >>= 32;\n  v >>= 32;\n\n  t  = u1 * v1;\n  w0 = t & 0xFFFFFFFF;\n  t  = u * v1 + (t >> 32);\n  w1 = t >> 32;\n  t  = u1 * v + (t & 0xFFFFFFFF);\n\n  res128_hi = u * v + w1 + (t >> 32);\n  return (t << 32) + w0;\n}\n\n/** @internal */\nfunction pio2_large_quot(x: f64, u: i64): i32 { // see: jdh8/metallic/blob/master/src/math/double/rem_pio2.c\n  let magnitude = u & 0x7FFFFFFFFFFFFFFF;\n  let offset = (magnitude >> 52) - 1045;\n  let shift  = offset & 63;\n  let tblPtr = PIO2_TABLE + (<i32>(offset >> 6) << 3);\n  let s0: u64, s1: u64, s2: u64;\n\n  let b0 = load<u64>(tblPtr, 0 << 3);\n  let b1 = load<u64>(tblPtr, 1 << 3);\n  let b2 = load<u64>(tblPtr, 2 << 3);\n\n  // Get 192 bits of 0x1p-31 / π with `offset` bits skipped\n  if (shift) {\n    let rshift = 64 - shift;\n    let b3 = load<u64>(tblPtr, 3 << 3);\n    s0 = b1 >> rshift | b0 << shift;\n    s1 = b2 >> rshift | b1 << shift;\n    s2 = b3 >> rshift | b2 << shift;\n  } else {\n    s0 = b0;\n    s1 = b1;\n    s2 = b2;\n  }\n\n  let significand = (u & 0x000FFFFFFFFFFFFF) | 0x0010000000000000;\n\n  // First 128 bits of fractional part of x/(2π)\n  let blo = umuldi(s1, significand);\n  let bhi = res128_hi;\n\n  let ahi = s0 * significand;\n  let clo = (s2 >> 32) * (significand >> 32);\n  let plo = blo + clo;\n  let phi = ahi + bhi + u64(plo < clo);\n\n  // r: u128 = p << 2\n  let rlo = plo << 2;\n  let rhi = phi << 2 | plo >> 62;\n\n  // s: i128 = r >> 127\n  let slo = <i64>rhi >> 63;\n  let shi = slo >> 1;\n  let q   = (<i64>phi >> 62) - slo;\n\n  let shifter = 0x3CB0000000000000 - (pio2_right(rlo ^ slo, rhi ^ shi) << 52);\n  let signbit = (u ^ rhi) & 0x8000000000000000;\n  let coeff   = reinterpret<f64>(shifter | signbit);\n\n  rempio2_y0 *= coeff;\n  rempio2_y1 *= coeff;\n\n  return <i32>q;\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction rempio2(x: f64, u: u64, sign: i32): i32 {\n  const\n    pio2_1  = reinterpret<f64>(0x3FF921FB54400000), // 1.57079632673412561417e+00\n    pio2_1t = reinterpret<f64>(0x3DD0B4611A626331), // 6.07710050650619224932e-11\n    pio2_2  = reinterpret<f64>(0x3DD0B4611A600000), // 6.07710050630396597660e-11\n    pio2_2t = reinterpret<f64>(0x3BA3198A2E037073), // 2.02226624879595063154e-21\n    pio2_3  = reinterpret<f64>(0x3BA3198A2E000000), // 2.02226624871116645580e-21\n    pio2_3t = reinterpret<f64>(0x397B839A252049C1), // 8.47842766036889956997e-32\n    invpio2 = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  let ix = <u32>(u >> 32) & 0x7FFFFFFF;\n\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (ix < 0x4002D97C) { // |x| < 3pi/4, special case with n=+-1\n      let q = 1, z: f64, y0: f64, y1: f64;\n      if (!sign) {\n        z = x - pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z - pio2_1t;\n          y1 = (z - y0) - pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z -= pio2_2;\n          y0 = z - pio2_2t;\n          y1 = (z - y0) - pio2_2t;\n        }\n      } else { // negative x\n        z = x + pio2_1;\n        if (ix != 0x3FF921FB) { // 33+53 bit pi is good enough\n          y0 = z + pio2_1t;\n          y1 = (z - y0) + pio2_1t;\n        } else { // near pi/2, use 33+33+53 bit pi\n          z += pio2_2;\n          y0 = z + pio2_2t;\n          y1 = (z - y0) + pio2_2t;\n        }\n        q = -1;\n      }\n      rempio2_y0 = y0;\n      rempio2_y1 = y1;\n      return q;\n    }\n  }\n\n  if (ix < 0x413921FB) { // |x| ~< 2^20*pi/2 (1647099)\n    // Use precise Cody Waite scheme\n    let q  = nearest(x * invpio2);\n    let r  = x - q * pio2_1;\n    let w  = q * pio2_1t; // 1st round good to 85 bit\n    let j  = ix >> 20;\n    let y0 = r - w;\n    let hi = <u32>(reinterpret<u64>(y0) >> 32);\n    let i  = j - ((hi >> 20) & 0x7FF);\n\n    if (i > 16) { // 2nd iteration needed, good to 118\n      let t = r;\n      w  = q * pio2_2;\n      r  = t - w;\n      w  = q * pio2_2t - ((t - r) - w);\n      y0 = r - w;\n      hi = <u32>(reinterpret<u64>(y0) >> 32);\n      i = j - ((hi >> 20) & 0x7FF);\n      if (i > 49) { // 3rd iteration need, 151 bits acc\n        let t = r;\n        w  = q * pio2_3;\n        r  = t - w;\n        w  = q * pio2_3t - ((t - r) - w);\n        y0 = r - w;\n      }\n    }\n    let y1 = (r - y0) - w;\n    rempio2_y0 = y0;\n    rempio2_y1 = y1;\n    return <i32>q;\n  }\n  let q = pio2_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction sin_kern(x: f64, y: f64, iy: i32): f64 { // see: musl/tree/src/math/__sin.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555555555549), // -1.66666666666666324348e-01\n    S2 = reinterpret<f64>(0x3F8111111110F8A6), //  8.33333333332248946124e-03\n    S3 = reinterpret<f64>(0xBF2A01A019C161D5), // -1.98412698298579493134e-04\n    S4 = reinterpret<f64>(0x3EC71DE357B1FE7D), //  2.75573137070700676789e-06\n    S5 = reinterpret<f64>(0xBE5AE5E68A2B9CEB), // -2.50507602534068634195e-08\n    S6 = reinterpret<f64>(0x3DE5D93A5ACFD57C); //  1.58969099521155010221e-10\n\n  let z = x * x;\n  let w = z * z;\n  let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n  let v = z * x;\n  if (!iy) {\n    return x + v * (S1 + z * r);\n  } else {\n    return x - ((z * (0.5 * y - v * r) - y) - v * S1);\n  }\n}\n\n/** @internal */\n// @ts-ignore: decorator\n@inline\nfunction cos_kern(x: f64, y: f64): f64 { // see: musl/tree/src/math/__cos.c\n  const\n    C1 = reinterpret<f64>(0x3FA555555555554C), //  4.16666666666666019037e-02\n    C2 = reinterpret<f64>(0xBF56C16C16C15177), // -1.38888888888741095749e-03\n    C3 = reinterpret<f64>(0x3EFA01A019CB1590), //  2.48015872894767294178e-05\n    C4 = reinterpret<f64>(0xBE927E4F809C52AD), // -2.75573143513906633035e-07\n    C5 = reinterpret<f64>(0x3E21EE9EBDB4B1C4), //  2.08757232129817482790e-09\n    C6 = reinterpret<f64>(0xBDA8FAE9BE8838D4); // -1.13596475577881948265e-11\n\n  let z = x * x;\n  let w = z * z;\n  let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n  let hz = 0.5 * z;\n  w = 1.0 - hz;\n  return w + (((1.0 - w) - hz) + (z * r - x * y));\n}\n\n/** @internal */\nfunction tan_kern(x: f64, y: f64, iy: i32): f64 { // see: src/lib/msun/src/k_tan.c\n  const\n    T0  = reinterpret<f64>(0x3FD5555555555563), //  3.33333333333334091986e-01\n    T1  = reinterpret<f64>(0x3FC111111110FE7A), //  1.33333333333201242699e-01\n    T2  = reinterpret<f64>(0x3FABA1BA1BB341FE), //  5.39682539762260521377e-02\n    T3  = reinterpret<f64>(0x3F9664F48406D637), //  2.18694882948595424599e-02\n    T4  = reinterpret<f64>(0x3F8226E3E96E8493), //  8.86323982359930005737e-03\n    T5  = reinterpret<f64>(0x3F6D6D22C9560328), //  3.59207910759131235356e-03\n    T6  = reinterpret<f64>(0x3F57DBC8FEE08315), //  1.45620945432529025516e-03\n    T7  = reinterpret<f64>(0x3F4344D8F2F26501), //  5.88041240820264096874e-04\n    T8  = reinterpret<f64>(0x3F3026F71A8D1068), //  2.46463134818469906812e-04\n    T9  = reinterpret<f64>(0x3F147E88A03792A6), //  7.81794442939557092300e-05\n    T10 = reinterpret<f64>(0x3F12B80F32F0A7E9), //  7.14072491382608190305e-05\n    T11 = reinterpret<f64>(0xBEF375CBDB605373), // -1.85586374855275456654e-05\n    T12 = reinterpret<f64>(0x3EFB2A7074BF7AD4); //  2.59073051863633712884e-05\n\n  const\n    one    = reinterpret<f64>(0x3FF0000000000000), // 1.00000000000000000000e+00\n    pio4   = reinterpret<f64>(0x3FE921FB54442D18), // 7.85398163397448278999e-01\n    pio4lo = reinterpret<f64>(0x3C81A62633145C07); // 3.06161699786838301793e-17\n\n  let z: f64, r: f64, v: f64, w: f64, s: f64;\n  let hx = <i32>(reinterpret<u64>(x) >> 32); // high word of x\n  let ix = hx & 0x7FFFFFFF; // high word of |x|\n  let big = ix >= 0x3FE59428;\n  if (big) { // |x| >= 0.6744\n    if (hx < 0) { x = -x, y = -y; }\n    z = pio4 - x;\n    w = pio4lo - y;\n    x = z + w;\n    y = 0.0;\n  }\n  z = x * x;\n  w = z * z;\n  r = T1 + w * (T3 + w * (T5 + w * (T7 + w * (T9 + w * T11))));\n  v = z * (T2 + w * (T4 + w * (T6 + w * (T8 + w * (T10 + w * T12)))));\n  s = z * x;\n  r = y + z * (s * (r + v) + y);\n  r += T0 * s;\n  w = x + r;\n  if (big) {\n    v = iy;\n    return (1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));\n  }\n  if (iy == 1) return w;\n  let a: f64, t: f64;\n  z = w;\n  z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF00000000);\n  v = r - (z - x);  // z + v = r + x\n  t = a = -one / w; // a = -1.0 / w\n  t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n  s = one + t * z;\n  return t + a * (s + t * v);\n}\n\n/** @internal */\nfunction dtoi32(x: f64): i32 {\n  if (ASC_SHRINK_LEVEL > 0) {\n    const inv32 = 1.0 / 4294967296;\n    return <i32><i64>(x - 4294967296 * floor(x * inv32));\n  } else {\n    let result = 0;\n    let u = reinterpret<u64>(x);\n    let e = (u >> 52) & 0x7FF;\n    if (e <= 1023 + 30) {\n      result = <i32>x;\n    } else if (e <= 1023 + 30 + 53) {\n      let v = (u & ((<u64>1 << 52) - 1)) | (<u64>1 << 52);\n      v = v << e - 1023 - 52 + 32;\n      result = <i32>(v >> 32);\n      result = select<i32>(-result, result, <i64>u < 0);\n    }\n    return result;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy let random_seeded = false;\n\n// @ts-ignore: decorator\n@lazy let random_state0_64: u64, random_state1_64: u64;\n\n// @ts-ignore: decorator\n@lazy let random_state0_32: u32, random_state1_32: u32;\n\nfunction murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche\n  h ^= h >> 33;                     // see: https://github.com/aappleby/smhasher\n  h *= 0xFF51AFD7ED558CCD;\n  h ^= h >> 33;\n  h *= 0xC4CEB9FE1A85EC53;\n  h ^= h >> 33;\n  return h;\n}\n\nfunction splitMix32(h: u32): u32 {\n  h += 0x6D2B79F5;\n  h  = (h ^ (h >> 15)) * (h | 1);\n  h ^= h + (h ^ (h >> 7)) * (h | 61);\n  return h ^ (h >> 14);\n}\n\nexport namespace NativeMath {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_sin: f64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_cos: f64 = 0;\n\n  // @ts-ignore: decorator\n  @inline export function abs(x: f64): f64 {\n    return builtin_abs<f64>(x);\n  }\n\n  export function acos(x: f64): f64 { // see: musl/src/math/acos.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let hx = <u32>(reinterpret<u64>(x) >> 32);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) {\n        if (<i32>hx < 0) return 2 * pio2_hi + Ox1p_120f;\n        return 0;\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix <= 0x3C600000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * R(x * x)));\n    }\n    let s: f64, w: f64, z: f64;\n    if (<i32>hx < 0) {\n      // z = (1.0 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f64>(z);\n      w = R(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1.0 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f64>(z);\n    let df = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n    let c = (z - df * df) / (s + df);\n    w = R(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f64): f64 { // see: musl/src/math/acosh.c\n    const s = reinterpret<f64>(0x3FE62E42FEFA39EF);\n    let u = reinterpret<u64>(x);\n    // Prevent propagation for all input values less than 1.0.\n    // Note musl lib didn't fix this yet.\n    if (<i64>u < 0x3FF0000000000000) return (x - x) / 0.0;\n    let e = u >> 52 & 0x7FF;\n    if (e < 0x3FF + 1) return log1p(x - 1 + builtin_sqrt<f64>((x - 1) * (x - 1) + 2 * (x - 1)));\n    if (e < 0x3FF + 26) return log(2 * x - 1 / (x + builtin_sqrt<f64>(x * x - 1)));\n    return log(x) + s;\n  }\n\n  export function asin(x: f64): f64 { // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f64>(0x3FF921FB54442D18), // 1.57079632679489655800e+00\n      pio2_lo   = reinterpret<f64>(0x3C91A62633145C07), // 6.12323399573676603587e-17\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let hx = <u32>(reinterpret<u64>(x) >> 32);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3FF00000) {\n      let lx = <u32>reinterpret<u64>(x);\n      if ((ix - 0x3FF00000 | lx) == 0) return x * pio2_hi + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (ix < 0x3FE00000) {\n      if (ix < 0x3E500000 && ix >= 0x00100000) return x;\n      return x + x * R(x * x);\n    }\n    // let z = (1.0 - builtin_abs<f64>(x)) * 0.5;\n    let z = 0.5 - builtin_abs<f64>(x) * 0.5;\n    let s = builtin_sqrt<f64>(z);\n    let r = R(z);\n    if (ix >= 0x3FEF3333) x = pio2_hi - (2 * (s + s * r) - pio2_lo);\n    else {\n      let f = reinterpret<f64>(reinterpret<u64>(s) & 0xFFFFFFFF00000000);\n      let c = (z - f * f) / (s + f);\n      x = 0.5 * pio2_hi - (2 * s * r - (pio2_lo - 2 * c) - (0.5 * pio2_hi - 2 * f));\n    }\n    return select(-x, x, <i32>hx < 0);\n  }\n\n  export function asinh(x: f64): f64 { // see: musl/src/math/asinh.c\n    const c = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.693147180559945309417232121458176568\n    let u = reinterpret<u64>(x);\n    let e = u >> 52 & 0x7FF;\n    let y = reinterpret<f64>(u & 0x7FFFFFFFFFFFFFFF);\n    if (e >= 0x3FF + 26) y = log(y) + c;\n    else if (e >= 0x3FF + 1)  y =   log(2 * y + 1 / (builtin_sqrt<f64>(y * y + 1) + y));\n    else if (e >= 0x3FF - 26) y = log1p(y + y * y / (builtin_sqrt<f64>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f64): f64 { // see musl/src/math/atan.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f64>(0x3FDDAC670561BB4F), //  4.63647609000806093515e-01\n      atanhi1   = reinterpret<f64>(0x3FE921FB54442D18), //  7.85398163397448278999e-01\n      atanhi2   = reinterpret<f64>(0x3FEF730BD281F69B), //  9.82793723247329054082e-01\n      atanhi3   = reinterpret<f64>(0x3FF921FB54442D18), //  1.57079632679489655800e+00\n      atanlo0   = reinterpret<f64>(0x3C7A2B7F222F65E2), //  2.26987774529616870924e-17\n      atanlo1   = reinterpret<f64>(0x3C81A62633145C07), //  3.06161699786838301793e-17\n      atanlo2   = reinterpret<f64>(0x3C7007887AF0CBBD), //  1.39033110312309984516e-17\n      atanlo3   = reinterpret<f64>(0x3C91A62633145C07), //  6.12323399573676603587e-17\n      aT0       = reinterpret<f64>(0x3FD555555555550D), //  3.33333333333329318027e-01\n      aT1       = reinterpret<f64>(0xBFC999999998EBC4), // -1.99999999998764832476e-01\n      aT2       = reinterpret<f64>(0x3FC24924920083FF), //  1.42857142725034663711e-01\n      aT3       = reinterpret<f64>(0xBFBC71C6FE231671), // -1.11111104054623557880e-01,\n      aT4       = reinterpret<f64>(0x3FB745CDC54C206E), //  9.09088713343650656196e-02\n      aT5       = reinterpret<f64>(0xBFB3B0F2AF749A6D), // -7.69187620504482999495e-02\n      aT6       = reinterpret<f64>(0x3FB10D66A0D03D51), //  6.66107313738753120669e-02\n      aT7       = reinterpret<f64>(0xBFADDE2D52DEFD9A), // -5.83357013379057348645e-02\n      aT8       = reinterpret<f64>(0x3FA97B4B24760DEB), //  4.97687799461593236017e-02\n      aT9       = reinterpret<f64>(0xBFA2B4442C6A6C2F), // -3.65315727442169155270e-02\n      aT10      = reinterpret<f64>(0x3F90AD3AE322DA11), //  1.62858201153657823623e-02\n      Ox1p_120f = reinterpret<f32>(0x03800000);\n\n    let ix = <u32>(reinterpret<u64>(x) >> 32);\n    let sx = x;\n    ix &= 0x7FFFFFFF;\n    let z: f64;\n    if (ix >= 0x44100000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign<f64>(z, sx);\n    }\n    let id: i32;\n    if (ix < 0x3FDC0000) {\n      if (ix < 0x3E400000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f64>(x);\n      if (ix < 0x3FF30000) {\n        if (ix < 0x3FE60000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x40038000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    let w = z * z;\n    let s1 = z * (aT0 + w * (aT2 + w * (aT4 + w * (aT6 + w * (aT8 + w * aT10)))));\n    let s2 = w * (aT1 + w * (aT3 + w * (aT5 + w * (aT7 + w * aT9))));\n    let s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign<f64>(z, sx);\n  }\n\n  export function atanh(x: f64): f64 { // see: musl/src/math/atanh.c\n    let u = reinterpret<u64>(x);\n    let e = u >> 52 & 0x7FF;\n    let y = builtin_abs(x);\n    if (e < 0x3FF - 1) {\n      if (e >= 0x3FF - 32) y = 0.5 * log1p(2 * y + 2 * y * y / (1 - y));\n    } else {\n      y = 0.5 * log1p(2 * (y / (1 - y)));\n    }\n    return builtin_copysign<f64>(y, x);\n  }\n\n  export function atan2(y: f64, x: f64): f64 { // see: musl/src/math/atan2.c and SUN COPYRIGHT NOTICE above\n    const pi_lo = reinterpret<f64>(0x3CA1A62633145C07); // 1.2246467991473531772E-16\n    if (isNaN(x) || isNaN(y)) return x + y;\n    let u = reinterpret<u64>(x);\n    let ix = <u32>(u >> 32);\n    let lx = <u32>u;\n    u = reinterpret<u64>(y);\n    let iy = <u32>(u >> 32);\n    let ly = <u32>u;\n    if ((ix - 0x3FF00000 | lx) == 0) return atan(y);\n    let m = ((iy >> 31) & 1) | ((ix >> 30) & 2);\n    ix = ix & 0x7FFFFFFF;\n    iy = iy & 0x7FFFFFFF;\n    if ((iy | ly) == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  PI;\n        case 3: return -PI;\n      }\n    }\n    if ((ix | lx) == 0) return m & 1 ? -PI / 2 : PI / 2;\n    if (ix == 0x7FF00000) {\n      if (iy == 0x7FF00000) {\n        let t = m & 2 ? 3 * PI / 4 : PI / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t = m & 2 ? PI : 0;\n        return m & 1 ? -t : t;\n      }\n    }\n    let z: f64;\n    if (ix + (64 << 20) < iy || iy == 0x7FF00000) return m & 1 ? -PI / 2 : PI / 2;\n    if ((m & 2) && iy + (64 << 20) < ix) z = 0;\n    else z = atan(builtin_abs<f64>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return PI - (z - pi_lo);\n      case 3: return (z - pi_lo) - PI;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f64): f64 { // see: musl/src/math/cbrt.c and SUN COPYRIGHT NOTICE above\n    const\n      B1     = <u32>715094163,\n      B2     = <u32>696219795,\n      P0     = reinterpret<f64>(0x3FFE03E60F61E692), //  1.87595182427177009643\n      P1     = reinterpret<f64>(0xBFFE28E092F02420), // -1.88497979543377169875\n      P2     = reinterpret<f64>(0x3FF9F1604A49D6C2), //  1.621429720105354466140\n      P3     = reinterpret<f64>(0xBFE844CBBEE751D9), // -0.758397934778766047437\n      P4     = reinterpret<f64>(0x3FC2B000D4E4EDD7), //  0.145996192886612446982\n      Ox1p54 = reinterpret<f64>(0x4350000000000000); //  0x1p54\n\n    let u = reinterpret<u64>(x);\n    let hx = <u32>(u >> 32) & 0x7FFFFFFF;\n    if (hx >= 0x7FF00000) return x + x;\n    if (hx < 0x00100000) {\n      u = reinterpret<u64>(x * Ox1p54);\n      hx = <u32>(u >> 32) & 0x7FFFFFFF;\n      if (hx == 0) return x;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 1 << 63;\n    u |= <u64>hx << 32;\n    let t = reinterpret<f64>(u);\n    let r = (t * t) * (t / x);\n    t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n    t = reinterpret<f64>((reinterpret<u64>(t) + 0x80000000) & 0xFFFFFFFFC0000000);\n    let s = t * t;\n    r = x / s;\n    r = (r - t) / (2 * t + r);\n    t = t + t * r;\n    return t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f64): f64 {\n    return builtin_ceil<f64>(x);\n  }\n\n  export function clz32(x: f64): f64 {\n    if (!isFinite(x)) return 32;\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    return builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f64): f64 { // see: musl/src/math/cos.c\n    let u  = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E46A09E) {  // |x| < 2**-27 * sqrt(2)\n        return 1.0;\n      }\n      return cos_kern(x, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    let n  = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n\n    x = n & 1 ? sin_kern(y0, y1, 1) : cos_kern(y0, y1);\n    return (n + 1) & 2 ? -x : x;\n  }\n\n  export function cosh(x: f64): f64 { // see: musl/src/math/cosh.c\n    let u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    x = reinterpret<f64>(u);\n    let w = <u32>(u >> 32);\n    let t: f64;\n    if (w < 0x3FE62E42) {\n      if (w < 0x3FF00000 - (26 << 20)) return 1;\n      t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (w < 0x40862E42) {\n      t = exp(x);\n      return 0.5 * (t + 1 / t);\n    }\n    t = expo2(x, 1);\n    return t;\n  }\n\n  export function exp(x: f64): f64 { // see: musl/src/math/exp.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return exp_lut(x);\n    } else {\n      const\n        ln2hi     = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n        ln2lo     = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n        invln2    = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        P1        = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2        = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3        = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4        = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5        = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        overflow  = reinterpret<f64>(0x40862E42FEFA39EF), //  709.782712893383973096\n        underflow = reinterpret<f64>(0xC0874910D52D3051), // -745.13321910194110842\n        Ox1p1023  = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n      let hx = u32(reinterpret<u64>(x) >> 32);\n      let sign = hx >> 31;\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x4086232B) {\n        if (isNaN(x)) return x;\n        if (x > overflow)  return x * Ox1p1023;\n        if (x < underflow) return 0;\n      }\n      let hi: f64, lo: f64 = 0;\n      let k = 0;\n      if (hx > 0x3FD62E42) {\n        if (hx >= 0x3FF0A2B2) {\n          k = i32(invln2 * x + builtin_copysign<f64>(0.5, x));\n        } else {\n          k = 1 - (sign << 1);\n        }\n        hi = x - k * ln2hi;\n        lo = k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x3E300000) {\n        hi = x;\n      } else return 1.0 + x;\n      let xs = x * x;\n      // let c = x - xp2 * (P1 + xp2 * (P2 + xp2 * (P3 + xp2 * (P4 + xp2 * P5))));\n      let xq = xs * xs;\n      let c = x - (xs * P1 + xq * ((P2 + xs * P3) + xq * (P4 + xs * P5)));\n      let y = 1.0 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f64): f64 {\n    return exp2_lut(x);\n  }\n\n  export function expm1(x: f64): f64 { // see: musl/src/math/expm1.c and SUN COPYRIGHT NOTICE above\n    const\n      o_threshold = reinterpret<f64>(0x40862E42FEFA39EF), //  7.09782712893383973096e+02\n      ln2_hi      = reinterpret<f64>(0x3FE62E42FEE00000), //  6.93147180369123816490e-01\n      ln2_lo      = reinterpret<f64>(0x3DEA39EF35793C76), //  1.90821492927058770002e-10\n      invln2      = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n      Q1          = reinterpret<f64>(0xBFA11111111110F4), // -3.33333333333331316428e-02\n      Q2          = reinterpret<f64>(0x3F5A01A019FE5585), //  1.58730158725481460165e-03\n      Q3          = reinterpret<f64>(0xBF14CE199EAADBB7), // -7.93650757867487942473e-05\n      Q4          = reinterpret<f64>(0x3ED0CFCA86E65239), //  4.00821782732936239552e-06\n      Q5          = reinterpret<f64>(0xBE8AFDB76E09C32D), // -2.01099218183624371326e-07\n      Ox1p1023    = reinterpret<f64>(0x7FE0000000000000); //  0x1p1023\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32) & 0x7FFFFFFF;\n    let sign = u32(u >> 63);\n    let k = 0;\n    if (hx >= 0x4043687A) {\n      if (isNaN(x)) return x;\n      if (sign) return -1;\n      if (x > o_threshold) return x * Ox1p1023;\n    }\n    let c = 0.0, t: f64;\n    if (hx > 0x3FD62E42) {\n      k = select<i32>(\n        1 - (sign << 1),\n        i32(invln2 * x + builtin_copysign<f64>(0.5, x)),\n        hx < 0x3FF0A2B2\n      );\n      t = <f64>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x3C900000) return x;\n    let hfx = 0.5 * x;\n    let hxs = x * hfx;\n    // let r1 = 1.0 + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));\n    let hxq = hxs * hxs;\n    let r1 = (1.0 + hxs * Q1) + hxq * ((Q2 + hxs * Q3) + hxq * (Q4 + hxs * Q5));\n    t = 3.0 - r1 * hfx;\n    let e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x3FF + k) << 52;\n    let twopk = reinterpret<f64>(u);\n    let y: f64;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 1024) y = y * 2.0 * Ox1p1023;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x3FF - k) << 52;\n    y = reinterpret<f64>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f64): f64 {\n    return builtin_floor<f64>(x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f64): f64 {\n    return <f32>x;\n  }\n\n  export function hypot(x: f64, y: f64): f64 { // see: musl/src/math/hypot.c\n    const\n      SPLIT    = reinterpret<f64>(0x41A0000000000000) + 1, // 0x1p27 + 1\n      Ox1p700  = reinterpret<f64>(0x6BB0000000000000),\n      Ox1p_700 = reinterpret<f64>(0x1430000000000000);\n\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    ux &= 0x7FFFFFFFFFFFFFFF;\n    uy &= 0x7FFFFFFFFFFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    let ex = i32(ux >> 52);\n    let ey = i32(uy >> 52);\n    y = reinterpret<f64>(uy);\n    if (ey == 0x7FF) return y;\n    x = reinterpret<f64>(ux);\n    if (ex == 0x7FF || uy == 0) return x;\n    if (ex - ey > 64) return x + y;\n    let z = 1.0;\n    if (ex > 0x3FF + 510) {\n      z  = Ox1p700;\n      x *= Ox1p_700;\n      y *= Ox1p_700;\n    } else if (ey < 0x3FF - 450) {\n      z  = Ox1p_700;\n      x *= Ox1p700;\n      y *= Ox1p700;\n    }\n    let c = x * SPLIT;\n    let h = x - c + c;\n    let l = x - h;\n    let hx = x * x;\n    let lx = h * h - hx + (2 * h + l) * l;\n    c = y * SPLIT;\n    h = y - c + c;\n    l = y - h;\n    let hy = y * y;\n    let ly = h * h - hy + (2 * h + l) * l;\n    return z * builtin_sqrt(ly + lx + hy + hx);\n  }\n\n  export function imul(x: f64, y: f64): f64 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return dtoi32(x) * dtoi32(y);\n  }\n\n  export function log(x: f64): f64 { // see: musl/src/math/log.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log_lut(x);\n    } else {\n      const\n        ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n        ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n        Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54 = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = u32(u >> 32);\n      let k = 0;\n      let sign = hx >> 31;\n      if (sign || hx < 0x00100000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = u32(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += (<i32>hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let dk = <f64>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f64): f64 { // see: musl/src/math/log10.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f64>(0x3FDBCB7B15200000), // 4.34294481878168880939e-01\n      ivln10lo  = reinterpret<f64>(0x3DBB9438CA9AADD5), // 2.50829467116452752298e-11\n      log10_2hi = reinterpret<f64>(0x3FD34413509F6000), // 3.01029995663611771306e-01\n      log10_2lo = reinterpret<f64>(0x3D59FEF311F12B36), // 3.69423907715893078616e-13\n      Lg1       = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2       = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3       = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4       = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5       = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6       = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7       = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n      Ox1p54    = reinterpret<f64>(0x4350000000000000); // 0x1p54\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32);\n    let k = 0;\n    let sign = hx >> 31;\n    if (sign || hx < 0x00100000) {\n      if (u << 1 == 0) return -1 / (x * x);\n      if (sign) return (x - x) / 0.0;\n      k -= 54;\n      x *= Ox1p54;\n      u = reinterpret<u64>(x);\n      hx = u32(u >> 32);\n    } else if (hx >= 0x7FF00000) {\n      return x;\n    } else if (hx == 0x3FF00000 && u << 32 == 0) {\n      return 0;\n    }\n    hx += 0x3FF00000 - 0x3FE6A09E;\n    k += i32(hx >> 20) - 0x3FF;\n    hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n    u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n    x = reinterpret<f64>(u);\n    let f = x - 1.0;\n    let hfsq = 0.5 * f * f;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    let r = t2 + t1;\n    let hi = f - hfsq;\n    u = reinterpret<u64>(hi);\n    u &= 0xFFFFFFFF00000000;\n    hi = reinterpret<f64>(u);\n    let lo = f - hi - hfsq + s * (hfsq + r);\n    let val_hi = hi * ivln10hi;\n    let dk = <f64>k;\n    let y = dk * log10_2hi;\n    let val_lo = dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi;\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    return val_lo + w;\n  }\n\n  export function log1p(x: f64): f64 { // see: musl/src/math/log1p.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f64>(0x3FE62E42FEE00000), // 6.93147180369123816490e-01\n      ln2_lo = reinterpret<f64>(0x3DEA39EF35793C76), // 1.90821492927058770002e-10\n      Lg1    = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n      Lg2    = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n      Lg3    = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n      Lg4    = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n      Lg5    = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n      Lg6    = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n      Lg7    = reinterpret<f64>(0x3FC2F112DF3E5244); // 1.479819860511658591e-01\n\n    let u = reinterpret<u64>(x);\n    let hx = u32(u >> 32);\n    let k = 1;\n    let c = 0.0, f = 0.0;\n    if (hx < 0x3FDA827A || bool(hx >> 31)) {\n      if (hx >= 0xBFF00000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (hx << 1 < 0x3CA00000 << 1) return x;\n      if (hx <= 0xBFD2BEC4) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (hx >= 0x7FF00000) return x;\n    if (k) {\n      u = reinterpret<u64>(1 + x);\n      let hu = u32(u >> 32);\n      hu += 0x3FF00000 - 0x3FE6A09E;\n      k = i32(hu >> 20) - 0x3FF;\n      if (k < 54) {\n        let uf = reinterpret<f64>(u);\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      hu = (hu & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hu << 32 | (u & 0xFFFFFFFF);\n      f = reinterpret<f64>(u) - 1;\n    }\n    let hfsq = 0.5 * f * f;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n    let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n    let r = t2 + t1;\n    let dk = <f64>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f64): f64 { // see: musl/src/math/log2.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f64>(0x3FF7154765200000), // 1.44269504072144627571e+00\n        ivln2lo = reinterpret<f64>(0x3DE705FC2EEFA200), // 1.67517131648865118353e-10\n        Lg1     = reinterpret<f64>(0x3FE5555555555593), // 6.666666666666735130e-01\n        Lg2     = reinterpret<f64>(0x3FD999999997FA04), // 3.999999999940941908e-01\n        Lg3     = reinterpret<f64>(0x3FD2492494229359), // 2.857142874366239149e-01\n        Lg4     = reinterpret<f64>(0x3FCC71C51D8E78AF), // 2.222219843214978396e-01\n        Lg5     = reinterpret<f64>(0x3FC7466496CB03DE), // 1.818357216161805012e-01\n        Lg6     = reinterpret<f64>(0x3FC39A09D078C69F), // 1.531383769920937332e-01\n        Lg7     = reinterpret<f64>(0x3FC2F112DF3E5244), // 1.479819860511658591e-01\n        Ox1p54  = reinterpret<f64>(0x4350000000000000); // 1p54\n\n      let u = reinterpret<u64>(x);\n      let hx = u32(u >> 32);\n      let k = 0;\n      let sign = hx >> 31;\n      if (sign || hx < 0x00100000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 54;\n        x *= Ox1p54;\n        u = reinterpret<u64>(x);\n        hx = u32(u >> 32);\n      } else if (hx >= 0x7FF00000) {\n        return x;\n      } else if (hx == 0x3FF00000 && u << 32 == 0) {\n        return 0;\n      }\n      hx += 0x3FF00000 - 0x3FE6A09E;\n      k += i32(hx >> 20) - 0x3FF;\n      hx = (hx & 0x000FFFFF) + 0x3FE6A09E;\n      u = <u64>hx << 32 | (u & 0xFFFFFFFF);\n      x = reinterpret<f64>(u);\n      let f = x - 1.0;\n      let hfsq = 0.5 * f * f;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * (Lg4 + w * Lg6));\n      let t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));\n      let r = t2 + t1;\n      let hi = f - hfsq;\n      u = reinterpret<u64>(hi);\n      u &= 0xFFFFFFFF00000000;\n      hi = reinterpret<f64>(u);\n      let lo = f - hi - hfsq + s * (hfsq + r);\n      let val_hi = hi * ivln2hi;\n      let val_lo = (lo + hi) * ivln2lo + lo * ivln2hi;\n      let y = <f64>k;\n      w = y + val_hi;\n      val_lo += (y - w) + val_hi;\n      val_hi = w;\n      return val_lo + val_hi;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f64, value2: f64): f64 {\n    return builtin_max<f64>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f64, value2: f64): f64 {\n    return builtin_min<f64>(value1, value2);\n  }\n\n  export function pow(x: f64, y: f64): f64 { // see: musl/src/math/pow.c and SUN COPYRIGHT NOTICE above\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f64>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f64>(\n          builtin_abs<f64>(builtin_sqrt<f64>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      return pow_lut(x, y);\n    } else {\n      const\n        dp_h1   = reinterpret<f64>(0x3FE2B80340000000), //  5.84962487220764160156e-01\n        dp_l1   = reinterpret<f64>(0x3E4CFDEB43CFD006), //  1.35003920212974897128e-08\n        two53   = reinterpret<f64>(0x4340000000000000), //  9007199254740992.0\n        huge    = reinterpret<f64>(0x7E37E43C8800759C), //  1e+300\n        tiny    = reinterpret<f64>(0x01A56E1FC2F8F359), //  1e-300\n        L1      = reinterpret<f64>(0x3FE3333333333303), //  5.99999999999994648725e-01\n        L2      = reinterpret<f64>(0x3FDB6DB6DB6FABFF), //  4.28571428578550184252e-01\n        L3      = reinterpret<f64>(0x3FD55555518F264D), //  3.33333329818377432918e-01\n        L4      = reinterpret<f64>(0x3FD17460A91D4101), //  2.72728123808534006489e-01\n        L5      = reinterpret<f64>(0x3FCD864A93C9DB65), //  2.30660745775561754067e-01\n        L6      = reinterpret<f64>(0x3FCA7E284A454EEF), //  2.06975017800338417784e-01\n        P1      = reinterpret<f64>(0x3FC555555555553E), //  1.66666666666666019037e-01\n        P2      = reinterpret<f64>(0xBF66C16C16BEBD93), // -2.77777777770155933842e-03\n        P3      = reinterpret<f64>(0x3F11566AAF25DE2C), //  6.61375632143793436117e-05\n        P4      = reinterpret<f64>(0xBEBBBD41C5D26BF1), // -1.65339022054652515390e-06\n        P5      = reinterpret<f64>(0x3E66376972BEA4D0), //  4.13813679705723846039e-08\n        lg2     = reinterpret<f64>(0x3FE62E42FEFA39EF), //  6.93147180559945286227e-01\n        lg2_h   = reinterpret<f64>(0x3FE62E4300000000), //  6.93147182464599609375e-01\n        lg2_l   = reinterpret<f64>(0xBE205C610CA86C39), // -1.90465429995776804525e-09\n        ovt     = reinterpret<f64>(0x3C971547652B82FE), //  8.0085662595372944372e-017\n        cp      = reinterpret<f64>(0x3FEEC709DC3A03FD), //  9.61796693925975554329e-01\n        cp_h    = reinterpret<f64>(0x3FEEC709E0000000), //  9.61796700954437255859e-01\n        cp_l    = reinterpret<f64>(0xBE3E2FE0145B01F5), // -7.02846165095275826516e-09\n        ivln2   = reinterpret<f64>(0x3FF71547652B82FE), //  1.44269504088896338700e+00\n        ivln2_h = reinterpret<f64>(0x3FF7154760000000), //  1.44269502162933349609e+00\n        ivln2_l = reinterpret<f64>(0x3E54AE0BF85DDF44), //  1.92596299112661746887e-08\n        inv3    = reinterpret<f64>(0x3FD5555555555555); //  0.3333333333333333333333\n\n      let u_ = reinterpret<u64>(x);\n      let hx = i32(u_ >> 32);\n      let lx = <u32>u_;\n      u_ = reinterpret<u64>(y);\n      let hy = i32(u_ >> 32);\n      let ly = <u32>u_;\n      let ix = hx & 0x7FFFFFFF;\n      let iy = hy & 0x7FFFFFFF;\n      if ((iy | ly) == 0) return 1.0; // x**0 = 1, even if x is NaN\n      // if (hx == 0x3FF00000 && lx == 0) return 1.0; // C: 1**y = 1, even if y is NaN, JS: NaN\n      if ( // NaN if either arg is NaN\n        ix > 0x7FF00000 || (ix == 0x7FF00000 && lx != 0) ||\n        iy > 0x7FF00000 || (iy == 0x7FF00000 && ly != 0)\n      ) return x + y;\n      let yisint = 0, k: i32;\n      if (hx < 0) {\n        if (iy >= 0x43400000) yisint = 2;\n        else if (iy >= 0x3FF00000) {\n          k = (iy >> 20) - 0x3FF;\n          let offset = select<u32>(52, 20, k > 20) - k;\n          let Ly = select<u32>(ly, iy, k > 20);\n          let jj = Ly >> offset;\n          if ((jj << offset) == Ly) yisint = 2 - (jj & 1);\n        }\n      }\n      if (ly == 0) {\n        if (iy == 0x7FF00000) { // y is +-inf\n          if (((ix - 0x3FF00000) | lx) == 0) return NaN; // C: (-1)**+-inf is 1, JS: NaN\n          else if (ix >= 0x3FF00000) return hy >= 0 ? y : 0.0; // (|x|>1)**+-inf = inf,0\n          else return hy >= 0 ? 0.0 : -y; // (|x|<1)**+-inf = 0,inf\n        }\n        if (iy == 0x3FF00000) {\n          if (hy >= 0) return x;\n          return 1 / x;\n        }\n        if (hy == 0x40000000) return x * x;\n        if (hy == 0x3FE00000) {\n          if (hx >= 0) return builtin_sqrt(x);\n        }\n      }\n      let ax = builtin_abs<f64>(x), z: f64;\n      if (lx == 0) {\n        if (ix == 0 || ix == 0x7FF00000 || ix == 0x3FF00000) {\n          z = ax;\n          if (hy < 0) z = 1.0 / z;\n          if (hx < 0) {\n            if (((ix - 0x3FF00000) | yisint) == 0) {\n              let d = z - z;\n              z = d / d;\n            } else if (yisint == 1) z = -z;\n          }\n          return z;\n        }\n      }\n      let s = 1.0;\n      if (hx < 0) {\n        if (yisint == 0) {\n          let d = x - x;\n          return d / d;\n        }\n        if (yisint == 1) s = -1.0;\n      }\n      let t1: f64, t2: f64, p_h: f64, p_l: f64, r: f64, t: f64, u: f64, v: f64, w: f64;\n      let j: i32, n: i32;\n      if (iy > 0x41E00000) {\n        if (iy > 0x43F00000) {\n          if (ix <= 0x3FEFFFFF) return hy < 0 ? huge * huge : tiny * tiny;\n          if (ix >= 0x3FF00000) return hy > 0 ? huge * huge : tiny * tiny;\n        }\n        if (ix < 0x3FEFFFFF) return hy < 0 ? s * huge * huge : s * tiny * tiny;\n        if (ix > 0x3FF00000) return hy > 0 ? s * huge * huge : s * tiny * tiny;\n        t = ax - 1.0;\n        w = (t * t) * (0.5 - t * (inv3 - t * 0.25));\n        u = ivln2_h * t;\n        v = t * ivln2_l - w * ivln2;\n        t1 = u + v;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = v - (t1 - u);\n      } else {\n        let ss: f64, s2: f64, s_h: f64, s_l: f64, t_h: f64, t_l: f64;\n        n = 0;\n        if (ix < 0x00100000) {\n          ax *= two53;\n          n -= 53;\n          ix = <u32>(reinterpret<u64>(ax) >> 32);\n        }\n        n += (ix >> 20) - 0x3FF;\n        j = ix & 0x000FFFFF;\n        ix = j | 0x3FF00000;\n        if (j <= 0x3988E) k = 0;\n        else if (j < 0xBB67A) k = 1;\n        else {\n          k = 0;\n          n += 1;\n          ix -= 0x00100000;\n        }\n        ax = reinterpret<f64>(reinterpret<u64>(ax) & 0xFFFFFFFF | (<u64>ix << 32));\n        let bp = select<f64>(1.5, 1.0, k); // k ? 1.5 : 1.0\n        u = ax - bp;\n        v = 1.0 / (ax + bp);\n        ss = u * v;\n        s_h = ss;\n        s_h = reinterpret<f64>(reinterpret<u64>(s_h) & 0xFFFFFFFF00000000);\n        t_h = reinterpret<f64>(u64(((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18)) << 32);\n        t_l = ax - (t_h - bp);\n        s_l = v * ((u - s_h * t_h) - s_h * t_l);\n        s2 = ss * ss;\n        r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + ss);\n        s2 = s_h * s_h;\n        t_h = 3.0 + s2 + r;\n        t_h = reinterpret<f64>(reinterpret<u64>(t_h) & 0xFFFFFFFF00000000);\n        t_l = r - ((t_h - 3.0) - s2);\n        u = s_h * t_h;\n        v = s_l * t_h + t_l * ss;\n        p_h = u + v;\n        p_h = reinterpret<f64>(reinterpret<u64>(p_h) & 0xFFFFFFFF00000000);\n        p_l = v - (p_h - u);\n        let z_h = cp_h * p_h;\n        let dp_l = select<f64>(dp_l1, 0.0, k);\n        let z_l = cp_l * p_h + p_l * cp + dp_l;\n        t = <f64>n;\n        let dp_h = select<f64>(dp_h1, 0.0, k);\n        t1 = ((z_h + z_l) + dp_h) + t;\n        t1 = reinterpret<f64>(reinterpret<u64>(t1) & 0xFFFFFFFF00000000);\n        t2 = z_l - (((t1 - t) - dp_h) - z_h);\n      }\n      let y1 = y;\n      y1 = reinterpret<f64>(reinterpret<u64>(y1) & 0xFFFFFFFF00000000);\n      p_l = (y - y1) * t1 + y * t2;\n      p_h = y1 * t1;\n      z = p_l + p_h;\n      u_ = reinterpret<u64>(z);\n      j = u32(u_ >> 32);\n      let i = <i32>u_;\n      if (j >= 0x40900000) {\n        if (((j - 0x40900000) | i) != 0) return s * huge * huge;\n        if (p_l + ovt > z - p_h) return s * huge * huge;\n      } else if ((j & 0x7FFFFFFF) >= 0x4090CC00) {\n        if (((j - 0xC090CC00) | i) != 0) return s * tiny * tiny;\n        if (p_l <= z - p_h) return s * tiny * tiny;\n      }\n      i = j & 0x7FFFFFFF;\n      k = (i >> 20) - 0x3FF;\n      n = 0;\n      if (i > 0x3FE00000) {\n        n = j + (0x00100000 >> (k + 1));\n        k = ((n & 0x7FFFFFFF) >> 20) - 0x3FF;\n        t = 0.0;\n        t = reinterpret<f64>(u64(n & ~(0x000FFFFF >> k)) << 32);\n        n = ((n & 0x000FFFFF) | 0x00100000) >> (20 - k);\n        if (j < 0) n = -n;\n        p_h -= t;\n      }\n      t = p_l + p_h;\n      t = reinterpret<f64>(reinterpret<u64>(t) & 0xFFFFFFFF00000000);\n      u = t * lg2_h;\n      v = (p_l - (t - p_h)) * lg2 + t * lg2_l;\n      z = u + v;\n      w = v - (z - u);\n      t = z * z;\n      t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n      r = (z * t1) / (t1 - 2.0) - (w + z * w);\n      z = 1.0 - (r - z);\n      j = u32(reinterpret<u64>(z) >> 32);\n      j += n << 20;\n      if ((j >> 20) <= 0) z = scalbn(z, n);\n      else z = reinterpret<f64>(reinterpret<u64>(z) & 0xFFFFFFFF | (<u64>j << 32));\n      return s * z;\n    }\n  }\n\n  export function seedRandom(value: i64): void {\n    // Instead zero seed use golden ratio:\n    // phi = (1 + sqrt(5)) / 2\n    // trunc(2^64 / phi) = 0x9e3779b97f4a7c15\n    if (value == 0) value = 0x9e3779b97f4a7c15;\n    random_state0_64 = murmurHash3(value);\n    random_state1_64 = murmurHash3(~random_state0_64);\n    random_state0_32 = splitMix32(<u32>value);\n    random_state1_32 = splitMix32(random_state0_32);\n    random_seeded = true;\n  }\n\n  export function random(): f64 { // see: v8/src/base/utils/random-number-generator.cc\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n    let s1 = random_state0_64;\n    let s0 = random_state1_64;\n    random_state0_64 = s0;\n    s1 ^= s1 << 23;\n    s1 ^= s1 >> 17;\n    s1 ^= s0;\n    s1 ^= s0 >> 26;\n    random_state1_64 = s1;\n    let r = (s0 >> 12) | 0x3FF0000000000000;\n    return reinterpret<f64>(r) - 1;\n  }\n\n  export function round(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_ceil<f64>(x) - f64(builtin_ceil<f64>(x) - 0.5 > x);\n    } else {\n      let roundUp = builtin_ceil<f64>(x);\n      return select<f64>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n    }\n  }\n\n  export function sign(x: f64): f64 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return select<f64>(builtin_copysign<f64>(1, x), x, builtin_abs(x) > 0);\n    } else {\n      return select<f64>(1, select<f64>(-1, x, x < 0), x > 0);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f64): bool {\n    return bool(reinterpret<u64>(x) >>> 63);\n  }\n\n  export function sin(x: f64): f64 { // see: musl/src/math/sin.c\n    let u  = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E500000) { // |x| < 2**-26\n        return x;\n      }\n      return sin_kern(x, 0.0, 0);\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    // argument reduction needed\n    let n  = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n\n    x = n & 1 ? cos_kern(y0, y1) : sin_kern(y0, y1, 1);\n    return n & 2 ? -x : x;\n  }\n\n  export function sinh(x: f64): f64 { // see: musl/src/math/sinh.c\n    let u = reinterpret<u64>(x) & 0x7FFFFFFFFFFFFFFF;\n    let a = reinterpret<f64>(u);\n    let w = u32(u >> 32);\n    let h = builtin_copysign(0.5, x);\n    if (w < 0x40862E42) {\n      let t = expm1(a);\n      if (w < 0x3FF00000) {\n        if (w < 0x3FF00000 - (26 << 20)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f64): f64 {\n    return builtin_sqrt<f64>(x);\n  }\n\n  export function tan(x: f64): f64 { // see: musl/src/math/tan.c\n    let u = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >>> 31;\n\n    ux &= 0x7FFFFFFF;\n\n    // |x| ~< pi/4\n    if (ux <= 0x3FE921FB) {\n      if (ux < 0x3E400000) { // |x| < 2**-27\n        return x;\n      }\n      return tan_kern(x, 0.0, 1);\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ux >= 0x7FF00000) return x - x;\n\n    let n = rempio2(x, u, sign);\n    return tan_kern(rempio2_y0, rempio2_y1, 1 - ((n & 1) << 1));\n  }\n\n  export function tanh(x: f64): f64 { // see: musl/src/math/tanh.c\n    let u = reinterpret<u64>(x);\n    u &= 0x7FFFFFFFFFFFFFFF;\n    let y = reinterpret<f64>(u);\n    let w = u32(u >> 32);\n    let t: f64;\n    if (w > 0x3FE193EA) {\n      if (w > 0x40340000) {\n        t = 1 - 0 / y;\n      } else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (w > 0x3FD058AE) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (w >= 0x00100000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f64>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f64): f64 {\n    return builtin_trunc<f64>(x);\n  }\n\n  export function scalbn(x: f64, n: i32): f64 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c\n    const\n      Ox1p53    = reinterpret<f64>(0x4340000000000000),\n      Ox1p1023  = reinterpret<f64>(0x7FE0000000000000),\n      Ox1p_1022 = reinterpret<f64>(0x0010000000000000);\n\n    let y = x;\n    if (n > 1023) {\n      y *= Ox1p1023;\n      n -= 1023;\n      if (n > 1023) {\n        y *= Ox1p1023;\n        n = builtin_min<i32>(n - 1023, 1023);\n      }\n    } else if (n < -1022) {\n      // make sure final n < -53 to avoid double\n      // rounding in the subnormal range\n      y *= Ox1p_1022 * Ox1p53;\n      n += 1022 - 53;\n      if (n < -1022) {\n        y *= Ox1p_1022 * Ox1p53;\n        n = builtin_max<i32>(n + 1022 - 53, -1022);\n      }\n    }\n    return y * reinterpret<f64>(<u64>(0x3FF + n) << 52);\n  }\n\n  export function mod(x: f64, y: f64): f64 { // see: musl/src/math/fmod.c\n    if (builtin_abs<f64>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f64>(x - builtin_trunc<f64>(x), x);\n    }\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    let ex = i64(ux >> 52 & 0x7FF);\n    let ey = i64(uy >> 52 & 0x7FF);\n    let sx = ux >> 63;\n    let uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0x7FF || isNaN<f64>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    let ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f64(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<i64>(ux << 12);\n      ux <<= 1 - ex;\n    } else {\n      ux &= u64(-1) >> 12;\n      ux |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u64(-1) >> 12;\n      uy |= 1 << 52;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 52); ux <<= 1) --ex;\n    let shift = builtin_clz<i64>(ux << 11);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 52;\n      ux |= ex << 52;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f64>(ux | (sx << 63));\n  }\n\n  export function rem(x: f64, y: f64): f64 { // see: musl/src/math/remquo.c\n    let ux = reinterpret<u64>(x);\n    let uy = reinterpret<u64>(y);\n    let ex = i64(ux >> 52 & 0x7FF);\n    let ey = i64(uy >> 52 & 0x7FF);\n    if (uy << 1 == 0 || ex == 0x7FF || isNaN(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    if (ux << 1 == 0) return x;\n    let uxi = ux;\n    if (!ex) {\n      ex -= builtin_clz<i64>(uxi << 12);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= u64(-1) >> 12;\n      uxi |= 1 << 52;\n    }\n    if (!ey) {\n      ey -= builtin_clz<i64>(uy << 12);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u64(-1) >> 12;\n      uy |= 1 << 52;\n    }\n    let q: u32 = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -60;\n      else {\n        let shift = builtin_clz<i64>(uxi << 11);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 52;\n      uxi |= ex << 52;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f64>(uxi);\n    y = builtin_abs<f64>(y);\n    let x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (x2 > y || (x2 == y && <bool>(q & 1))))) {\n      x -= y;\n      // ++q;\n    }\n    return <i64>ux < 0 ? -x : x;\n  }\n\n  export function sincos(x: f64): void { // see: musl/tree/src/math/sincos.c\n    let u = reinterpret<u64>(x);\n    let ux = u32(u >> 32);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3FE921FB) {  // |x| ~<= π/4\n      if (ux < 0x3E46A09E) { // if |x| < 2**-27 * sqrt(2)\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kern(x, 0, 0);\n      sincos_cos = cos_kern(x, 0);\n      return;\n    }\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    let n = rempio2(x, u, sign);\n    let y0 = rempio2_y0;\n    let y1 = rempio2_y1;\n    let s = sin_kern(y0, y1, 1);\n    let c = cos_kern(y0, y1);\n    let sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\n// @ts-ignore: decorator\n@lazy let rempio2f_y: f64;\n\n// @ts-ignore: decorator\n@lazy @inline const PIO2F_TABLE = memory.data<u64>([\n  0xA2F9836E4E441529,\n  0xFC2757D1F534DDC0,\n  0xDB6295993C439041,\n  0xFE5163ABDEBBC561\n]);\n\nfunction Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3\n  const                    // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    pS0 = reinterpret<f32>(0x3E2AAA75), //  1.6666586697e-01f\n    pS1 = reinterpret<f32>(0xBD2F13BA), // -4.2743422091e-02f\n    pS2 = reinterpret<f32>(0xBC0DD36B), // -8.6563630030e-03f\n    qS1 = reinterpret<f32>(0xBF34E5AE); // -7.0662963390e-01f\n\n  let p = z * (pS0 + z * (pS1 + z * pS2));\n  let q: f32 = 1 + z * qS1;\n  return p / q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction expo2f(x: f32, sign: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)\n  const                                // see: musl/src/math/__expo2f.c\n    k    = <u32>235,\n    kln2 = reinterpret<f32>(0x4322E3BC); // 0x1.45c778p+7f\n  let scale = reinterpret<f32>(u32(0x7F + (k >> 1)) << 23);\n  // in directed rounding correct sign before rounding or overflow is important\n  return NativeMathf.exp(x - kln2) * (sign * scale) * scale;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction pio2f_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20\n\n  let offset = (u >> 23) - 152;\n  let shift  = u64(offset & 63);\n  let tblPtr = PIO2F_TABLE + (offset >> 6 << 3);\n\n  let b0 = load<u64>(tblPtr, 0 << 3);\n  let b1 = load<u64>(tblPtr, 1 << 3);\n  let lo: u64;\n\n  if (shift > 32) {\n    let b2 = load<u64>(tblPtr, 2 << 3);\n    lo  = b2 >> (96 - shift);\n    lo |= b1 << (shift - 32);\n  } else {\n    lo = b1 >> (32 - shift);\n  }\n\n  let hi = (b1 >> (64 - shift)) | (b0 << shift);\n  let mantissa: u64 = (u & 0x007FFFFF) | 0x00800000;\n  let product = mantissa * hi + (mantissa * lo >> 32);\n  let r: i64 = product << 2;\n  let q = i32((product >> 62) + (r >>> 63));\n  rempio2f_y = copysign<f64>(coeff, x) * <f64>r;\n  return q;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c\n  const\n    pi2hi = reinterpret<f64>(0x3FF921FB50000000), // 1.57079631090164184570\n    pi2lo = reinterpret<f64>(0x3E5110B4611A6263), // 1.58932547735281966916e-8\n    _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308\n\n  if (u < 0x4DC90FDB) { // π * 0x1p28\n    let q = nearest(x * _2_pi);\n    rempio2f_y = x - q * pi2hi - q * pi2lo;\n    return <i32>q;\n  }\n\n  let q = pio2f_large_quot(x, u);\n  return select(-q, q, sign);\n}\n\n// |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]).\n// @ts-ignore: decorator\n@inline\nfunction sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c\n  const\n    S1 = reinterpret<f64>(0xBFC5555554CBAC77), // -0x15555554cbac77.0p-55\n    S2 = reinterpret<f64>(0x3F811110896EFBB2), //  0x111110896efbb2.0p-59\n    S3 = reinterpret<f64>(0xBF2A00F9E2CAE774), // -0x1a00f9e2cae774.0p-65\n    S4 = reinterpret<f64>(0x3EC6CD878C3B46A7); //  0x16cd878c3b46a7.0p-71\n\n  let z = x * x;\n  let w = z * z;\n  let r = S3 + z * S4;\n  let s = z * x;\n  return f32((x + s * (S1 + z * S2)) + s * w * r);\n}\n\n// |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]).\n// @ts-ignore: decorator\n@inline\nfunction cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c\n  const\n    C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81), // -0x1ffffffd0c5e81.0p-54\n    C1 = reinterpret<f64>(0x3FA55553E1053A42), //  0x155553e1053a42.0p-57\n    C2 = reinterpret<f64>(0xBF56C087E80F1E27), // -0x16c087e80f1e27.0p-62\n    C3 = reinterpret<f64>(0x3EF99342E0EE5069); //  0x199342e0ee5069.0p-68\n\n  let z = x * x;\n  let w = z * z;\n  let r = C2 + z * C3;\n  return f32(((1 + z * C0) + w * C1) + (w * z) * r);\n}\n\n// |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]).\n// @ts-ignore: decorator\n@inline\nfunction tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c\n  const\n    T0 = reinterpret<f64>(0x3FD5554D3418C99F), // 0x15554d3418c99f.0p-54\n    T1 = reinterpret<f64>(0x3FC112FD38999F72), // 0x1112fd38999f72.0p-55\n    T2 = reinterpret<f64>(0x3FAB54C91D865AFE), // 0x1b54c91d865afe.0p-57\n    T3 = reinterpret<f64>(0x3F991DF3908C33CE), // 0x191df3908c33ce.0p-58\n    T4 = reinterpret<f64>(0x3F685DADFCECF44E), // 0x185dadfcecf44e.0p-61\n    T5 = reinterpret<f64>(0x3F8362B9BF971BCD); // 0x1362b9bf971bcd.0p-59\n\n  let z = x * x;\n  let r = T4 + z * T5;\n  let t = T2 + z * T3;\n  let w = z * z;\n  let s = z * x;\n  let u = T0 + z * T1;\n\n  r = (x + s * u) + (s * w) * (t + w * r);\n  return f32(odd ? -1 / r : r);\n}\n\n// See: jdh8/metallic/src/math/float/log2f.c and jdh8/metallic/src/math/float/kernel/atanh.h\n// @ts-ignore: decorator\n@inline\nfunction log2f(x: f64): f64 {\n  const\n    log2e = reinterpret<f64>(0x3FF71547652B82FE), // 1.44269504088896340736\n    c0 = reinterpret<f64>(0x3FD555554FD9CAEF),    // 0.33333332822728226129\n    c1 = reinterpret<f64>(0x3FC999A7A8AF4132),    // 0.20000167595436263505\n    c2 = reinterpret<f64>(0x3FC2438D79437030),    // 0.14268654271188685375\n    c3 = reinterpret<f64>(0x3FBE2F663B001C97);    // 0.11791075649681414150\n\n  let i = reinterpret<i64>(x);\n  let exponent = (i - 0x3FE6A09E667F3BCD) >> 52;\n  x = reinterpret<f64>(i - (exponent << 52));\n  x = (x - 1) / (x + 1);\n  let xx = x * x;\n  let y = x + x * xx * (c0 + c1 * xx + (c2 + c3 * xx) * (xx * xx));\n  return (2 * log2e) * y + <f64>exponent;\n}\n\n// See: jdh8/metallic/src/math/float/exp2f.h and jdh8/metallic/blob/master/src/math/float/kernel/exp2f.h\n// @ts-ignore: decorator\n@inline\nfunction exp2f(x: f64): f64 {\n  const\n    c0 = reinterpret<f64>(0x3FE62E4302FCC24A), // 6.931471880289532425e-1\n    c1 = reinterpret<f64>(0x3FCEBFBE07D97B91), // 2.402265108421173406e-1\n    c2 = reinterpret<f64>(0x3FAC6AF6CCFC1A65), // 5.550357105498874537e-2\n    c3 = reinterpret<f64>(0x3F83B29E3CE9AEF6), // 9.618030771171497658e-3\n    c4 = reinterpret<f64>(0x3F55F0896145A89F), // 1.339086685300950937e-3\n    c5 = reinterpret<f64>(0x3F2446C81E384864); // 1.546973499989028719e-4\n\n  if (x < -1022) return 0;\n  if (x >= 1024) return Infinity;\n\n  let n = nearest(x);\n  x -= n;\n  let xx = x * x;\n  let y = 1 + x * (c0 + c1 * x + (c2 + c3 * x) * xx + (c4 + c5 * x) * (xx * xx));\n  return reinterpret<f64>(reinterpret<i64>(y) + (<i64>n << 52));\n}\n\nexport namespace NativeMathf {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const E       = <f32>NativeMath.E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN2     = <f32>NativeMath.LN2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LN10    = <f32>NativeMath.LN10;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG2E   = <f32>NativeMath.LOG2E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const LOG10E  = <f32>NativeMath.LOG10E;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const PI      = <f32>NativeMath.PI;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT1_2 = <f32>NativeMath.SQRT1_2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const SQRT2   = <f32>NativeMath.SQRT2;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_sin: f32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export let sincos_cos: f32 = 0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function abs(x: f32): f32 {\n    return builtin_abs<f32>(x);\n  }\n\n  export function acos(x: f32): f32 { // see: musl/src/math/acosf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2_hi   = reinterpret<f32>(0x3FC90FDA), // 1.5707962513e+00f\n      pio2_lo   = reinterpret<f32>(0x33A22168), // 7.5497894159e-08f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    let hx = reinterpret<u32>(x);\n    let ix = hx & 0x7FFFFFFF;\n    if (ix >= 0x3F800000) {\n      if (ix == 0x3F800000) {\n        return select<f32>(2 * pio2_hi + Ox1p_120f, 0, <i32>hx < 0);\n      }\n      return 0 / (x - x);\n    }\n    if (ix < 0x3F000000) {\n      if (ix <= 0x32800000) return pio2_hi + Ox1p_120f;\n      return pio2_hi - (x - (pio2_lo - x * Rf(x * x)));\n    }\n    let z: f32, w: f32, s: f32;\n    if (<i32>hx < 0) {\n      // z = (1 + x) * 0.5;\n      z = 0.5 + x * 0.5;\n      s = builtin_sqrt<f32>(z);\n      w = Rf(z) * s - pio2_lo;\n      return 2 * (pio2_hi - (s + w));\n    }\n    // z = (1 - x) * 0.5;\n    z = 0.5 - x * 0.5;\n    s = builtin_sqrt<f32>(z);\n    hx = reinterpret<u32>(s);\n    let df = reinterpret<f32>(hx & 0xFFFFF000);\n    let c = (z - df * df) / (s + df);\n    w = Rf(z) * s + c;\n    return 2 * (df + w);\n  }\n\n  export function acosh(x: f32): f32 { // see: musl/src/math/acoshf.c\n    const s = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    let u = reinterpret<u32>(x);\n    let a = u & 0x7FFFFFFF;\n    if (a < 0x3F800000 + (1 << 23)) { // |x| < 2, invalid if x < 1\n      let xm1 = x - 1;\n      return log1p(xm1 + builtin_sqrt(xm1 * (xm1 + 2)));\n    }\n    if (u < 0x3F800000 + (12 << 23)) { // 2 <= x < 0x1p12\n      return log(2 * x - 1 / (x + builtin_sqrt<f32>(x * x - 1)));\n    }\n    // x >= 0x1p12 or x <= -2 or NaN\n    return log(x) + s;\n  }\n\n  export function asin(x: f32): f32 { // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above\n    const\n      pio2      = reinterpret<f32>(0x3FC90FDB), // 1.570796326794896558e+00f\n      Ox1p_120f = reinterpret<f32>(0x03800000); // 0x1p-120f\n\n    let sx = x;\n    let hx = reinterpret<u32>(x) & 0x7FFFFFFF;\n    if (hx >= 0x3F800000) {\n      if (hx == 0x3F800000) return x * pio2 + Ox1p_120f;\n      return 0 / (x - x);\n    }\n    if (hx < 0x3F000000) {\n      if (hx < 0x39800000 && hx >= 0x00800000) return x;\n      return x + x * Rf(x * x);\n    }\n    // let z: f32 = (1 - builtin_abs<f32>(x)) * 0.5;\n    let z: f32 = 0.5 - builtin_abs<f32>(x) * 0.5;\n    let s = builtin_sqrt<f64>(z); // sic\n    x = f32(pio2 - 2 * (s + s * Rf(z)));\n    return builtin_copysign(x, sx);\n  }\n\n  export function asinh(x: f32): f32 { // see: musl/src/math/asinhf.c\n    const c = reinterpret<f32>(0x3F317218); // 0.693147180559945309417232121458176568f\n    let u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    let y = reinterpret<f32>(u);\n    if (u >= 0x3F800000 + (12 << 23)) y = log(y) + c;\n    else if (u >= 0x3F800000 + (1 << 23))  y =   log(2 * y + 1 / (builtin_sqrt<f32>(y * y + 1) + y));\n    else if (u >= 0x3F800000 - (12 << 23)) y = log1p(y + y * y / (builtin_sqrt<f32>(y * y + 1) + 1));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan(x: f32): f32 { // see: musl/src/math/atanf.c and SUN COPYRIGHT NOTICE above\n    const\n      atanhi0   = reinterpret<f32>(0x3EED6338), //  4.6364760399e-01f\n      atanhi1   = reinterpret<f32>(0x3F490FDA), //  7.8539812565e-01f\n      atanhi2   = reinterpret<f32>(0x3F7B985E), //  9.8279368877e-01f\n      atanhi3   = reinterpret<f32>(0x3FC90FDA), //  1.5707962513e+00f\n      atanlo0   = reinterpret<f32>(0x31AC3769), //  5.0121582440e-09f\n      atanlo1   = reinterpret<f32>(0x33222168), //  3.7748947079e-08f\n      atanlo2   = reinterpret<f32>(0x33140FB4), //  3.4473217170e-08f\n      atanlo3   = reinterpret<f32>(0x33A22168), //  7.5497894159e-08f\n      aT0       = reinterpret<f32>(0x3EAAAAA9), //  3.3333328366e-01f\n      aT1       = reinterpret<f32>(0xBE4CCA98), // -1.9999158382e-01f\n      aT2       = reinterpret<f32>(0x3E11F50D), //  1.4253635705e-01f\n      aT3       = reinterpret<f32>(0xBDDA1247), // -1.0648017377e-01f\n      aT4       = reinterpret<f32>(0x3D7CAC25), //  6.1687607318e-02f\n      Ox1p_120f = reinterpret<f32>(0x03800000); //  0x1p-120f\n\n    let ix = reinterpret<u32>(x);\n    let sx = x;\n    ix &= 0x7FFFFFFF;\n    let z: f32;\n    if (ix >= 0x4C800000) {\n      if (isNaN(x)) return x;\n      z = atanhi3 + Ox1p_120f;\n      return builtin_copysign(z, sx);\n    }\n    let id: i32;\n    if (ix < 0x3EE00000) {\n      if (ix < 0x39800000) return x;\n      id = -1;\n    } else {\n      x = builtin_abs<f32>(x);\n      if (ix < 0x3F980000) {\n        if (ix < 0x3F300000) {\n          id = 0;\n          x = (2.0 * x - 1.0) / (2.0 + x);\n        } else {\n          id = 1;\n          x = (x - 1.0) / (x + 1.0);\n        }\n      } else {\n        if (ix < 0x401C0000) {\n          id = 2;\n          x = (x - 1.5) / (1.0 + 1.5 * x);\n        } else {\n          id = 3;\n          x = -1.0 / x;\n        }\n      }\n    }\n    z = x * x;\n    let w = z * z;\n    let s1 = z * (aT0 + w * (aT2 + w * aT4));\n    let s2 = w * (aT1 + w * aT3);\n    let s3 = x * (s1 + s2);\n    if (id < 0) return x - s3;\n    switch (id) {\n      case 0: { z = atanhi0 - ((s3 - atanlo0) - x); break; }\n      case 1: { z = atanhi1 - ((s3 - atanlo1) - x); break; }\n      case 2: { z = atanhi2 - ((s3 - atanlo2) - x); break; }\n      case 3: { z = atanhi3 - ((s3 - atanlo3) - x); break; }\n      default: unreachable();\n    }\n    return builtin_copysign(z, sx);\n  }\n\n  export function atanh(x: f32): f32 { // see: musl/src/math/atanhf.c\n    let u = reinterpret<u32>(x);\n    let y = builtin_abs(x);\n    if (u < 0x3F800000 - (1 << 23)) {\n      if (u >= 0x3F800000 - (32 << 23)) y = 0.5 * log1p(2 * y * (1.0 + y / (1 - y)));\n    } else y = 0.5 * log1p(2 * (y / (1 - y)));\n    return builtin_copysign(y, x);\n  }\n\n  export function atan2(y: f32, x: f32): f32 { // see: musl/src/math/atan2f.c and SUN COPYRIGHT NOTICE above\n    const\n      pi    = reinterpret<f32>(0x40490FDB), //  3.1415927410e+00f\n      pi_lo = reinterpret<f32>(0xB3BBBD2E); // -8.7422776573e-08f\n\n    if (isNaN(x) || isNaN(y)) return x + y;\n    let ix = reinterpret<u32>(x);\n    let iy = reinterpret<u32>(y);\n    if (ix == 0x3F800000) return atan(y);\n    let m = u32(((iy >> 31) & 1) | ((ix >> 30) & 2));\n    ix &= 0x7FFFFFFF;\n    iy &= 0x7FFFFFFF;\n    if (iy == 0) {\n      switch (m) {\n        case 0:\n        case 1: return  y;\n        case 2: return  pi;\n        case 3: return -pi;\n      }\n    }\n    if (ix == 0) return m & 1 ? -pi / 2 : pi / 2;\n    if (ix == 0x7F800000) {\n      if (iy == 0x7F800000) {\n        let t: f32 = m & 2 ? 3 * pi / 4 : pi / 4;\n        return m & 1 ? -t : t;\n      } else {\n        let t: f32 = m & 2 ? pi : 0.0;\n        return m & 1 ? -t : t;\n      }\n    }\n    if (ix + (26 << 23) < iy || iy == 0x7F800000) return m & 1 ? -pi / 2 : pi / 2;\n    let z: f32;\n    if ((m & 2) && iy + (26 << 23) < ix) z = 0.0;\n    else z = atan(builtin_abs<f32>(y / x));\n    switch (m) {\n      case 0: return  z;\n      case 1: return -z;\n      case 2: return pi - (z - pi_lo);\n      case 3: return (z - pi_lo) - pi;\n    }\n    unreachable();\n    return 0;\n  }\n\n  export function cbrt(x: f32): f32 { // see: musl/src/math/cbrtf.c and SUN COPYRIGHT NOTICE above\n    const\n      B1      = <u32>709958130,\n      B2      = <u32>642849266,\n      Ox1p24f = reinterpret<f32>(0x4B800000);\n\n    let u = reinterpret<u32>(x);\n    let hx = u & 0x7FFFFFFF;\n    if (hx >= 0x7F800000) return x + x;\n    if (hx < 0x00800000) {\n      if (hx == 0) return x;\n      u = reinterpret<u32>(x * Ox1p24f);\n      hx = u & 0x7FFFFFFF;\n      hx = hx / 3 + B2;\n    } else {\n      hx = hx / 3 + B1;\n    }\n    u &= 0x80000000;\n    u |= hx;\n    let t = <f64>reinterpret<f32>(u);\n    let r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    r = t * t * t;\n    t = t * (<f64>x + x + r) / (x + r + r);\n    return <f32>t;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function ceil(x: f32): f32 {\n    return builtin_ceil<f32>(x);\n  }\n\n  export function clz32(x: f32): f32 {\n    if (!isFinite(x)) return 32;\n    return <f32>builtin_clz(dtoi32(x));\n  }\n\n  export function cos(x: f32): f32 { // see: musl/src/math/cosf.c\n    const\n      c1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      c2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      c3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      c4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        // raise inexact if x != 0\n        return 1;\n      }\n      return cos_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {  // |x| ~<= 5π/4\n        if (ux > 0x4016CBE3) { // |x|  ~> 3π/4\n          return -cos_kernf(sign ? x + c2pio2 : x - c2pio2);\n        } else {\n          return sign ? sin_kernf(x + c1pio2) : sin_kernf(c1pio2 - x);\n        }\n      }\n      if (ux <= 0x40E231D5) {  // |x| ~<= 9π/4\n        if (ux > 0x40AFEDDF) { // |x|  ~> 7π/4\n          return cos_kernf(sign ? x + c4pio2 : x - c4pio2);\n        } else {\n          return sign ? sin_kernf(-x - c3pio2) : sin_kernf(x - c3pio2);\n        }\n      }\n    }\n\n    // cos(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    // general argument reduction needed\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n\n    let t = n & 1 ? sin_kernf(y) : cos_kernf(y);\n    return (n + 1) & 2 ? -t : t;\n  }\n\n  export function cosh(x: f32): f32 { // see: musl/src/math/coshf.c\n    let u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    x = reinterpret<f32>(u);\n    if (u < 0x3F317217) {\n      if (u < 0x3F800000 - (12 << 23)) return 1;\n      let t = expm1(x);\n      // return 1 + t * t / (2 * (1 + t));\n      return 1 + t * t / (2 + 2 * t);\n    }\n    if (u < 0x42B17217) {\n      let t = exp(x);\n      // return 0.5 * (t + 1 / t);\n      return 0.5 * t + 0.5 / t;\n    }\n    return expo2f(x, 1);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function floor(x: f32): f32 {\n    return builtin_floor<f32>(x);\n  }\n\n  export function exp(x: f32): f32 { // see: musl/src/math/expf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return expf_lut(x);\n    } else {\n      const\n        ln2hi    = reinterpret<f32>(0x3F317200), //  6.9314575195e-1f\n        ln2lo    = reinterpret<f32>(0x35BFBE8E), //  1.4286067653e-6f\n        invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+0f\n        P1       = reinterpret<f32>(0x3E2AAA8F), //  1.6666625440e-1f\n        P2       = reinterpret<f32>(0xBB355215), // -2.7667332906e-3f\n        Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n      let hx = reinterpret<u32>(x);\n      let sign = hx >> 31;\n      hx &= 0x7FFFFFFF;\n      if (hx >= 0x42AEAC50) {\n        if (hx > 0x7F800000) return x; // NaN\n        if (hx >= 0x42B17218) {\n          if (!sign) return x * Ox1p127f;\n          else if (hx >= 0x42CFF1B5) return 0;\n        }\n      }\n      let hi: f32, lo: f32;\n      let k: i32;\n      if (hx > 0x3EB17218) {\n        if (hx > 0x3F851592) {\n          k = i32(invln2 * x + builtin_copysign<f32>(0.5, x));\n        } else {\n          k = 1 - (sign << 1);\n        }\n        hi = x - <f32>k * ln2hi;\n        lo = <f32>k * ln2lo;\n        x = hi - lo;\n      } else if (hx > 0x39000000) {\n        k = 0;\n        hi = x;\n        lo = 0;\n      } else {\n        return 1 + x;\n      }\n      let xx = x * x;\n      let c = x - xx * (P1 + xx * P2);\n      let y: f32 = 1 + (x * c / (2 - c) - lo + hi);\n      return k == 0 ? y : scalbn(y, k);\n    }\n  }\n\n  export function exp2(x: f32): f32 {\n    return exp2f_lut(x);\n  }\n\n  export function expm1(x: f32): f32 { // see: musl/src/math/expm1f.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi   = reinterpret<f32>(0x3F317180), //  6.9313812256e-01f\n      ln2_lo   = reinterpret<f32>(0x3717F7D1), //  9.0580006145e-06f\n      invln2   = reinterpret<f32>(0x3FB8AA3B), //  1.4426950216e+00f\n      Q1       = reinterpret<f32>(0xBD088868), // -3.3333212137e-02f\n      Q2       = reinterpret<f32>(0x3ACF3010), //  1.5807170421e-03f\n      Ox1p127f = reinterpret<f32>(0x7F000000); //  0x1p+127f\n\n    let u = reinterpret<u32>(x);\n    let hx = u & 0x7FFFFFFF;\n    let sign = u >> 31;\n    if (hx >= 0x4195B844) {\n      if (hx > 0x7F800000) return x;\n      if (sign) return -1;\n      if (hx > 0x42B17217) { // x > log(FLT_MAX)\n        x *= Ox1p127f;\n        return x;\n      }\n    }\n    let c: f32 = 0.0, t: f32, k: i32;\n    if (hx > 0x3EB17218) {\n      k = select<i32>(\n        1 - (sign << 1),\n        i32(invln2 * x + builtin_copysign<f32>(0.5, x)),\n        hx < 0x3F851592\n      );\n      t = <f32>k;\n      let hi = x - t * ln2_hi;\n      let lo = t * ln2_lo;\n      x = hi - lo;\n      c = (hi - x) - lo;\n    } else if (hx < 0x33000000) {\n      return x;\n    } else k = 0;\n    let hfx: f32 = 0.5 * x;\n    let hxs: f32 = x * hfx;\n    let r1: f32 = 1.0 + hxs * (Q1 + hxs * Q2);\n    t  = 3.0 - r1 * hfx;\n    let e = hxs * ((r1 - t) / (6.0 - x * t));\n    if (k == 0) return x - (x * e - hxs);\n    e  = x * (e - c) - c;\n    e -= hxs;\n    if (k == -1) return 0.5 * (x - e) - 0.5;\n    if (k == 1) {\n      if (x < -0.25) return -2.0 * (e - (x + 0.5));\n      return 1.0 + 2.0 * (x - e);\n    }\n    u = (0x7F + k) << 23;\n    let twopk = reinterpret<f32>(u);\n    let y: f32;\n    if (k < 0 || k > 56) {\n      y = x - e + 1.0;\n      if (k == 128) y = y * 2.0 * Ox1p127f;\n      else y = y * twopk;\n      return y - 1.0;\n    }\n    u = (0x7F - k) << 23;\n    y = reinterpret<f32>(u);\n    if (k < 20) y = (1 - y) - e;\n    else y = 1 - (e + y);\n    return (x + y) * twopk;\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function fround(x: f32): f32 {\n    return x;\n  }\n\n  export function hypot(x: f32, y: f32): f32 { // see: musl/src/math/hypotf.c\n    const\n      Ox1p90f  = reinterpret<f32>(0x6C800000),\n      Ox1p_90f = reinterpret<f32>(0x12800000);\n\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    ux &= 0x7FFFFFFF;\n    uy &= 0x7FFFFFFF;\n    if (ux < uy) {\n      let ut = ux;\n      ux = uy;\n      uy = ut;\n    }\n    x = reinterpret<f32>(ux);\n    y = reinterpret<f32>(uy);\n    if (uy == 0xFF << 23) return y;\n    if (ux >= 0xFF << 23 || uy == 0 || ux - uy >= 25 << 23) return x + y;\n    let z: f32 = 1;\n    if (ux >= (0x7F + 60) << 23) {\n      z  = Ox1p90f;\n      x *= Ox1p_90f;\n      y *= Ox1p_90f;\n    } else if (uy < (0x7F - 60) << 23) {\n      z  = Ox1p_90f;\n      x *= Ox1p90f;\n      y *= Ox1p90f;\n    }\n    return z * builtin_sqrt<f32>(f32(<f64>x * x + <f64>y * y));\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function imul(x: f32, y: f32): f32 {\n    /*\n     * Wasm (MVP) and JS have different approaches for double->int conversions.\n     *\n     * For emulate JS conversion behavior and avoid trapping from wasm we should modulate by MAX_INT\n     * our float-point arguments before actual convertion to integers.\n     */\n    if (!isFinite(x + y)) return 0;\n    return <f32>(dtoi32(x) * dtoi32(y));\n  }\n\n  export function log(x: f32): f32 { // see: musl/src/math/logf.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return logf_lut(x);\n    } else {\n      const\n        ln2_hi  = reinterpret<f32>(0x3F317180), // 6.9313812256e-01f\n        ln2_lo  = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06f\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f\n        Lg4     = reinterpret<f32>(0x3E789E26), // 0xf89e26.0p-26f\n        Ox1p25f = reinterpret<f32>(0x4C000000);\n\n      let u = reinterpret<u32>(x);\n      let k = 0;\n      let sign = u >> 31;\n      if (sign || u < 0x00800000) {\n        if (u << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0;\n        k -= 25;\n        x *= Ox1p25f;\n        u = reinterpret<u32>(x);\n      } else if (u >= 0x7F800000) {\n        return x;\n      } else if (u == 0x3F800000) {\n        return 0;\n      }\n      u += 0x3F800000 - 0x3F3504F3;\n      k += i32(u >> 23) - 0x7F;\n      u = (u & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(u);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq = <f32>0.5 * f * f;\n      let dk = <f32>k;\n      return s * (hfsq + r) + dk * ln2_lo - hfsq + f + dk * ln2_hi;\n    }\n  }\n\n  export function log10(x: f32): f32 { // see: musl/src/math/log10f.c and SUN COPYRIGHT NOTICE above\n    const\n      ivln10hi  = reinterpret<f32>(0x3EDE6000), //  4.3432617188e-01f\n      ivln10lo  = reinterpret<f32>(0xB804EAD9), // -3.1689971365e-05f\n      log10_2hi = reinterpret<f32>(0x3E9A2080), //  3.0102920532e-01f\n      log10_2lo = reinterpret<f32>(0x355427DB), //  7.9034151668e-07f\n      Lg1       = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2       = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n      Lg3       = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n      Lg4       = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n      Ox1p25f   = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n    let ux = reinterpret<u32>(x);\n    let k = 0;\n    let sign = ux >> 31;\n    if (sign || ux < 0x00800000) {\n      if (ux << 1 == 0) return -1 / (x * x);\n      if (sign) return (x - x) / 0.0;\n      k -= 25;\n      x *= Ox1p25f;\n      ux = reinterpret<u32>(x);\n    } else if (ux >= 0x7F800000) {\n      return x;\n    } else if (ux == 0x3F800000) {\n      return 0;\n    }\n    ux += 0x3F800000 - 0x3F3504F3;\n    k += i32(ux >> 23) - 0x7F;\n    ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n    x = reinterpret<f32>(ux);\n    let f = x - 1.0;\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * Lg4);\n    let t2 = z * (Lg1 + w * Lg3);\n    let r = t2 + t1;\n    let hfsq: f32 = 0.5 * f * f;\n    let hi = f - hfsq;\n    ux = reinterpret<u32>(hi);\n    ux &= 0xFFFFF000;\n    hi = reinterpret<f32>(ux);\n    let lo = f - hi - hfsq + s * (hfsq + r);\n    let dk = <f32>k;\n    return dk * log10_2lo + (lo + hi) * ivln10lo + lo * ivln10hi + hi * ivln10hi + dk * log10_2hi;\n  }\n\n  export function log1p(x: f32): f32 { // see: musl/src/math/log1pf.c and SUN COPYRIGHT NOTICE above\n    const\n      ln2_hi = reinterpret<f32>(0x3F317180), // 6.9313812256e-01\n      ln2_lo = reinterpret<f32>(0x3717F7D1), // 9.0580006145e-06\n      Lg1    = reinterpret<f32>(0x3F2AAAAA), // 0xaaaaaa.0p-24f, 0.66666662693f\n      Lg2    = reinterpret<f32>(0x3ECCCE13), // 0xccce13.0p-25f, 0.40000972152f\n      Lg3    = reinterpret<f32>(0x3E91E9EE), // 0x91e9ee.0p-25f, 0.28498786688f\n      Lg4    = reinterpret<f32>(0x3E789E26); // 0xf89e26.0p-26f, 0.24279078841f\n\n    let ix = reinterpret<u32>(x);\n    let c: f32 = 0;\n    let f: f32 = 0;\n    let k = 1;\n    if (ix < 0x3ED413D0 || bool(ix >> 31)) {\n      if (ix >= 0xBF800000) {\n        if (x == -1) return x / 0.0;\n        return (x - x) / 0.0;\n      }\n      if (ix << 1 < 0x33800000 << 1) return x;\n      if (ix <= 0xBE95F619) {\n        k = 0;\n        c = 0;\n        f = x;\n      }\n    } else if (ix >= 0x7F800000) return x;\n    if (k) {\n      let uf: f32 = 1 + x;\n      let iu = reinterpret<u32>(uf);\n      iu += 0x3F800000 - 0x3F3504F3;\n      k = i32(iu >> 23) - 0x7F;\n      if (k < 25) {\n        c = k >= 2 ? 1 - (uf - x) : x - (uf - 1);\n        c /= uf;\n      } else c = 0;\n      iu = (iu & 0x007FFFFF) + 0x3F3504F3;\n      f = reinterpret<f32>(iu) - 1;\n    }\n    let s = f / (2.0 + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (Lg2 + w * Lg4);\n    let t2 = z * (Lg1 + w * Lg3);\n    let r = t2 + t1;\n    let hfsq: f32 = 0.5 * f * f;\n    let dk = <f32>k;\n    return s * (hfsq + r) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;\n  }\n\n  export function log2(x: f32): f32 { // see: musl/src/math/log2f.c and SUN COPYRIGHT NOTICE above\n    if (ASC_SHRINK_LEVEL < 1) {\n      return log2f_lut(x);\n    } else {\n      const\n        ivln2hi = reinterpret<f32>(0x3FB8B000), //  1.4428710938e+00f\n        ivln2lo = reinterpret<f32>(0xB9389AD4), // -1.7605285393e-04\n        Lg1     = reinterpret<f32>(0x3F2AAAAA), //  0xaaaaaa.0p-24f, 0.66666662693f\n        Lg2     = reinterpret<f32>(0x3ECCCE13), //  0xccce13.0p-25f, 0.40000972152f\n        Lg3     = reinterpret<f32>(0x3E91E9EE), //  0x91e9ee.0p-25f, 0.28498786688f\n        Lg4     = reinterpret<f32>(0x3E789E26), //  0xf89e26.0p-26f, 0.24279078841f\n        Ox1p25f = reinterpret<f32>(0x4C000000); //  0x1p25f\n\n      let ux = reinterpret<u32>(x);\n      let k = 0;\n      let sign = ux >> 31;\n      if (sign || ux < 0x00800000) {\n        if (ux << 1 == 0) return -1 / (x * x);\n        if (sign) return (x - x) / 0.0;\n        k -= 25;\n        x *= Ox1p25f;\n        ux = reinterpret<u32>(x);\n      } else if (ux >= 0x7F800000) {\n        return x;\n      } else if (ux == 0x3F800000) {\n        return 0;\n      }\n      ux += 0x3F800000 - 0x3F3504F3;\n      k += i32(ux >> 23) - 0x7F;\n      ux = (ux & 0x007FFFFF) + 0x3F3504F3;\n      x = reinterpret<f32>(ux);\n      let f = x - 1.0;\n      let s = f / (2.0 + f);\n      let z = s * s;\n      let w = z * z;\n      let t1 = w * (Lg2 + w * Lg4);\n      let t2 = z * (Lg1 + w * Lg3);\n      let r = t2 + t1;\n      let hfsq: f32 = 0.5 * f * f;\n      let hi = f - hfsq;\n      let u = reinterpret<u32>(hi);\n      u &= 0xFFFFF000;\n      hi = reinterpret<f32>(u);\n      let lo: f32 = f - hi - hfsq + s * (hfsq + r);\n      let dk = <f32>k;\n      return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function max(value1: f32, value2: f32): f32 {\n    return builtin_max<f32>(value1, value2);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function min(value1: f32, value2: f32): f32 {\n    return builtin_min<f32>(value1, value2);\n  }\n\n  export function pow(x: f32, y: f32): f32 {\n    // TODO: remove this fast pathes after introduced own mid-end IR with \"stdlib call simplify\" transforms\n    if (builtin_abs<f32>(y) <= 2) {\n      if (y == 2.0) return x * x;\n      if (y == 0.5) {\n        return select<f32>(\n          builtin_abs<f32>(builtin_sqrt<f32>(x)),\n          Infinity,\n          x != -Infinity\n        );\n      }\n      if (y == -1.0) return 1 / x;\n      if (y == 1.0) return x;\n      if (y == 0.0) return 1.0;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      // see: musl/src/math/powf.c\n      return powf_lut(x, y);\n    } else {\n      // based on:  jdh8/metallic/src/math/float/powf.c\n      if (y == 0) return 1;\n      // @ts-ignore: cast\n      if (isNaN(x) | isNaN(y)) {\n        return NaN;\n      }\n      let sign: u32 = 0;\n      let uy = reinterpret<u32>(y);\n      let ux = reinterpret<u32>(x);\n      let sx = ux >> 31;\n      ux &= 0x7FFFFFFF;\n      if (sx && nearest(y) == y) {\n        x = -x;\n        sx = 0;\n        sign = u32(nearest(y * 0.5) != y * 0.5) << 31;\n      }\n      let m: u32;\n      if (ux == 0x3F800000) { // x == 1\n        m = sx | u32((uy & 0x7FFFFFFF) == 0x7F800000) ? 0x7FC00000 : 0x3F800000;\n      } else if (ux == 0) {\n        m = <i32>uy < 0 ? 0x7F800000 : 0;\n      } else if (ux == 0x7F800000) {\n        m = <i32>uy < 0 ? 0 : 0x7F800000;\n      } else if (sx) {\n        m = 0x7FC00000;\n      } else {\n        m = reinterpret<u32>(<f32>exp2f(<f64>y * log2f(x)));\n      }\n      return reinterpret<f32>(m | sign);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function seedRandom(value: i64): void {\n    NativeMath.seedRandom(value);\n  }\n\n  // Using xoroshiro64starstar from http://xoshiro.di.unimi.it/xoroshiro64starstar.c\n  export function random(): f32 {\n    if (!random_seeded) seedRandom(reinterpret<i64>(seed()));\n\n    let s0 = random_state0_32;\n    let s1 = random_state1_32;\n    let r  = rotl<u32>(s0 * 0x9E3779BB, 5) * 5;\n\n    s1 ^= s0;\n    random_state0_32 = rotl<u32>(s0, 26) ^ s1 ^ (s1 << 9);\n    random_state1_32 = rotl<u32>(s1, 13);\n\n    return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;\n  }\n\n  export function round(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return builtin_ceil<f32>(x) - f32(builtin_ceil<f32>(x) - 0.5 > x);\n    } else {\n      let roundUp = builtin_ceil<f32>(x);\n      return select<f32>(roundUp, roundUp - 1.0, roundUp - 0.5 <= x);\n    }\n  }\n\n  export function sign(x: f32): f32 {\n    if (ASC_SHRINK_LEVEL > 0) {\n      return select<f32>(builtin_copysign<f32>(1, x), x, builtin_abs(x) > 0);\n    } else {\n      return select<f32>(1, select<f32>(-1, x, x < 0), x > 0);\n    }\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function signbit(x: f32): bool {\n    return <bool>(reinterpret<u32>(x) >>> 31);\n  }\n\n  export function sin(x: f32): f32 { // see: musl/src/math/sinf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // M_PI_2 * 1\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // M_PI_2 * 2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // M_PI_2 * 3\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // M_PI_2 * 4\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return sin_kernf(x);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return sign ? -cos_kernf(x + s1pio2) : cos_kernf(x - s1pio2);\n        }\n        return sin_kernf(-(sign ? x + s2pio2 : x - s2pio2));\n      }\n\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return sign ? cos_kernf(x + s3pio2) : -cos_kernf(x - s3pio2);\n        }\n        return sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n      }\n    }\n\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n\n    let t = n & 1 ? cos_kernf(y) : sin_kernf(y);\n    return n & 2 ? -t : t;\n  }\n\n  export function sinh(x: f32): f32 { // see: musl/src/math/sinhf.c\n    let u = reinterpret<u32>(x) & 0x7FFFFFFF;\n    let a = reinterpret<f32>(u);\n    let h = builtin_copysign<f32>(0.5, x);\n    if (u < 0x42B17217) {\n      let t = expm1(a);\n      if (u < 0x3F800000) {\n        if (u < 0x3F800000 - (12 << 23)) return x;\n        return h * (2 * t - t * t / (t + 1));\n      }\n      return h * (t + t / (t + 1));\n    }\n    return expo2f(a, 2 * h);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function sqrt(x: f32): f32 {\n    return builtin_sqrt<f32>(x);\n  }\n\n  export function tan(x: f32): f32 { // see: musl/src/math/tanf.c\n    const\n      t1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      t2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      t3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      t4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        return x;\n      }\n      return tan_kernf(x, 0);\n    }\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          return tan_kernf((sign ? x + t1pio2 : x - t1pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t2pio2 : x - t2pio2), 0);\n        }\n      }\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          return tan_kernf((sign ? x + t3pio2 : x - t3pio2), 1);\n        } else {\n          return tan_kernf((sign ? x + t4pio2 : x - t4pio2), 0);\n        }\n      }\n    }\n\n    // tan(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) return x - x;\n\n    // argument reduction\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n    return tan_kernf(y, n & 1);\n  }\n\n  export function tanh(x: f32): f32 { // see: musl/src/math/tanhf.c\n    let u = reinterpret<u32>(x);\n    u &= 0x7FFFFFFF;\n    let y = reinterpret<f32>(u);\n    let t: f32;\n    if (u > 0x3F0C9F54) {\n      if (u > 0x41200000) t = 1 + 0 / y;\n      else {\n        t = expm1(2 * y);\n        t = 1 - 2 / (t + 2);\n      }\n    } else if (u > 0x3E82C578) {\n      t = expm1(2 * y);\n      t = t / (t + 2);\n    } else if (u >= 0x00800000) {\n      t = expm1(-2 * y);\n      t = -t / (t + 2);\n    } else t = y;\n    return builtin_copysign<f32>(t, x);\n  }\n\n  // @ts-ignore: decorator\n  @inline\n  export function trunc(x: f32): f32 {\n    return builtin_trunc<f32>(x);\n  }\n\n  export function scalbn(x: f32, n: i32): f32 { // see: https://git.musl-libc.org/cgit/musl/tree/src/math/scalbnf.c\n    const\n      Ox1p24f   = reinterpret<f32>(0x4B800000),\n      Ox1p127f  = reinterpret<f32>(0x7F000000),\n      Ox1p_126f = reinterpret<f32>(0x00800000);\n\n    let y = x;\n    if (n > 127) {\n      y *= Ox1p127f;\n      n -= 127;\n      if (n > 127) {\n        y *= Ox1p127f;\n        n = builtin_min<i32>(n - 127, 127);\n      }\n    } else if (n < -126) {\n      y *= Ox1p_126f * Ox1p24f;\n      n += 126 - 24;\n      if (n < -126) {\n        y *= Ox1p_126f * Ox1p24f;\n        n = builtin_max<i32>(n + 126 - 24, -126);\n      }\n    }\n    return y * reinterpret<f32>(<u32>(0x7F + n) << 23);\n  }\n\n  export function mod(x: f32, y: f32): f32 { // see: musl/src/math/fmodf.c\n    if (builtin_abs<f32>(y) == 1.0) {\n      // x % 1, x % -1  ==>  sign(x) * abs(x - 1.0 * trunc(x / 1.0))\n      // TODO: move this rule to compiler's optimization pass.\n      // It could be apply for any x % C_pot, where \"C_pot\" is pow of two const.\n      return builtin_copysign<f32>(x - builtin_trunc<f32>(x), x);\n    }\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    let ex = i32(ux >> 23 & 0xFF);\n    let ey = i32(uy >> 23 & 0xFF);\n    let sm = ux & 0x80000000;\n    let uy1 = uy << 1;\n    if (uy1 == 0 || ex == 0xFF || isNaN<f32>(y)) {\n      let m = x * y;\n      return m / m;\n    }\n    let ux1 = ux << 1;\n    if (ux1 <= uy1) {\n      return x * f32(ux1 != uy1);\n    }\n    if (!ex) {\n      ex -= builtin_clz<u32>(ux << 9);\n      ux <<= 1 - ex;\n    } else {\n      ux &= <u32>-1 >> 9;\n      ux |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u32(-1) >> 9;\n      uy |= 1 << 23;\n    }\n    while (ex > ey) {\n      if (ux >= uy) {\n        if (ux == uy) return 0 * x;\n        ux -= uy;\n      }\n      ux <<= 1;\n      --ex;\n    }\n    if (ux >= uy) {\n      if (ux == uy) return 0 * x;\n      ux -= uy;\n    }\n    // for (; !(ux >> 23); ux <<= 1) --ex;\n    let shift = <i32>builtin_clz<u32>(ux << 8);\n    ex -= shift;\n    ux <<= shift;\n    if (ex > 0) {\n      ux -= 1 << 23;\n      ux |= <u32>ex << 23;\n    } else {\n      ux >>= -ex + 1;\n    }\n    return reinterpret<f32>(ux | sm);\n  }\n\n  export function rem(x: f32, y: f32): f32 { // see: musl/src/math/remquof.c\n    let ux = reinterpret<u32>(x);\n    let uy = reinterpret<u32>(y);\n    let ex = i32(ux >> 23 & 0xFF);\n    let ey = i32(uy >> 23 & 0xFF);\n    let uxi = ux;\n    if (uy << 1 == 0 || ex == 0xFF || isNaN(y)) return (x * y) / (x * y);\n    if (ux << 1 == 0) return x;\n    if (!ex) {\n      ex -= builtin_clz<u32>(uxi << 9);\n      uxi <<= 1 - ex;\n    } else {\n      uxi &= u32(-1) >> 9;\n      uxi |= 1 << 23;\n    }\n    if (!ey) {\n      ey -= builtin_clz<u32>(uy << 9);\n      uy <<= 1 - ey;\n    } else {\n      uy &= u32(-1) >> 9;\n      uy |= 1 << 23;\n    }\n    let q = 0;\n    do {\n      if (ex < ey) {\n        if (ex + 1 == ey) break; // goto end\n        return x;\n      }\n      while (ex > ey) {\n        if (uxi >= uy) {\n          uxi -= uy;\n          ++q;\n        }\n        uxi <<= 1;\n        q <<= 1;\n        --ex;\n      }\n      if (uxi >= uy) {\n        uxi -= uy;\n        ++q;\n      }\n      if (uxi == 0) ex = -30;\n      else {\n        let shift = builtin_clz<i32>(uxi << 8);\n        ex -= shift;\n        uxi <<= shift;\n      }\n      break;\n    } while (false);\n    // end:\n    if (ex > 0) {\n      uxi -= 1 << 23;\n      uxi |= <u32>ex << 23;\n    } else {\n      uxi >>= -ex + 1;\n    }\n    x = reinterpret<f32>(uxi);\n    y = builtin_abs<f32>(y);\n    let x2 = x + x;\n    if (ex == ey || (ex + 1 == ey && (<f32>x2 > y || (<f32>x2 == y && bool(q & 1))))) {\n      x -= y;\n      // q++;\n    }\n    return <i32>ux < 0 ? -x : x;\n  }\n\n  export function sincos(x: f32): void { // see: musl/tree/src/math/sincosf.c\n    const\n      s1pio2 = reinterpret<f64>(0x3FF921FB54442D18), // 1 * M_PI_2\n      s2pio2 = reinterpret<f64>(0x400921FB54442D18), // 2 * M_PI_2\n      s3pio2 = reinterpret<f64>(0x4012D97C7F3321D2), // 3 * M_PI_2\n      s4pio2 = reinterpret<f64>(0x401921FB54442D18); // 4 * M_PI_2\n\n    let ux = reinterpret<u32>(x);\n    let sign = ux >> 31;\n    ux &= 0x7FFFFFFF;\n\n    if (ux <= 0x3F490FDA) {  // |x| ~<= π/4\n      if (ux < 0x39800000) { // |x| < 2**-12\n        sincos_sin = x;\n        sincos_cos = 1;\n        return;\n      }\n      sincos_sin = sin_kernf(x);\n      sincos_cos = cos_kernf(x);\n      return;\n    }\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (ux <= 0x407B53D1) {   // |x| ~<= 5π/4\n        if (ux <= 0x4016CBE3) { // |x| ~<= 3π/4\n          if (sign) {\n            sincos_sin = -cos_kernf(x + s1pio2);\n            sincos_cos =  sin_kernf(x + s1pio2);\n          } else {\n            sincos_sin = cos_kernf(s1pio2 - x);\n            sincos_cos = sin_kernf(s1pio2 - x);\n          }\n          return;\n        }\n        // -sin(x + c) is not correct if x+c could be 0: -0 vs +0\n        sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);\n        sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);\n        return;\n      }\n      if (ux <= 0x40E231D5) {   // |x| ~<= 9π/4\n        if (ux <= 0x40AFEDDF) { // |x| ~<= 7π/4\n          if (sign) {\n            sincos_sin =  cos_kernf(x + s3pio2);\n            sincos_cos = -sin_kernf(x + s3pio2);\n          } else {\n            sincos_sin = -cos_kernf(x - s3pio2);\n            sincos_cos =  sin_kernf(x - s3pio2);\n          }\n          return;\n        }\n        sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);\n        sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);\n        return;\n      }\n    }\n    // sin(Inf or NaN) is NaN\n    if (ux >= 0x7F800000) {\n      let xx = x - x;\n      sincos_sin = xx;\n      sincos_cos = xx;\n      return;\n    }\n    // general argument reduction needed\n    let n = rempio2f(x, ux, sign);\n    let y = rempio2f_y;\n    let s = sin_kernf(y);\n    let c = cos_kernf(y);\n    let sin = s, cos = c;\n    if (n & 1) {\n      sin =  c;\n      cos = -s;\n    }\n    if (n & 2) {\n      sin = -sin;\n      cos = -cos;\n    }\n    sincos_sin = sin;\n    sincos_cos = cos;\n  }\n}\n\nexport function ipow32(x: i32, e: i32): i32 {\n  let out = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i32>(1 << e, 0, <u32>e < 32);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i32>(-1, 1, e & 1);\n      return i32(e == 0) | i32(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 32) {\n      let log = 32 - clz(e);\n      // 32 = 2 ^ 5, so need only five cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\nexport function ipow64(x: i64, e: i64): i64 {\n  let out: i64 = 1;\n  if (ASC_SHRINK_LEVEL < 1) {\n    if (x == 2) {\n      return select<i64>(1 << e, 0, <u64>e < 64);\n    }\n    if (e <= 0) {\n      if (x == -1) return select<i64>(-1, 1, e & 1);\n      return i64(e == 0) | i64(x == 1);\n    }\n    else if (e == 1) return x;\n    else if (e == 2) return x * x;\n    else if (e < 64) {\n      let log = 64 - <i32>clz(e);\n      // 64 = 2 ^ 6, so need only six cases.\n      // But some extra cases needs for properly overflowing\n      switch (log) {\n        case 6: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 5: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 4: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 3: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 2: {\n          if (e & 1) out *= x;\n          e >>>= 1;\n          x *= x;\n        }\n        case 1: {\n          if (e & 1) out *= x;\n        }\n      }\n      return out;\n    }\n  }\n  while (e) {\n    if (e & 1) out *= x;\n    e >>>= 1;\n    x *= x;\n  }\n  return out;\n}\n\n/*\nTODO:\nIn compile time if only exponent is constant we could replace ipow32/ipow64 by shortest addition chains\nwhich usually faster than exponentiation by squaring\n\nfor ipow32 and e < 32:\n\nlet b: i32, c: i32, d: i32, h: i32, k: i32, g: i32;\nswitch (e) {\n  case  1: return x;\n  case  2: return x * x;\n  case  3: return x * x * x;\n  case  4: return (b = x * x) * b;\n  case  5: return (b = x * x) * b * x;\n  case  6: return (b = x * x) * b * b;\n  case  7: return (b = x * x) * b * b * x;\n  case  8: return (d = (b = x * x) * b) * d;\n  case  9: return (c = x * x * x) * c * c;\n  case 10: return (d = (b = x * x) * b) * d * b;\n  case 11: return (d = (b = x * x) * b) * d * b * x;\n  case 12: return (d = (b = x * x) * b) * d * d;\n  case 13: return (d = (b = x * x) * b) * d * d * x;\n  case 14: return (d = (b = x * x) * b) * d * d * b;\n  case 15: return (k = (b = x * x) * b * x) * k * k;\n  case 16: return (h = (d = (b = x * x) * b) * d) * h;\n  case 17: return (h = (d = (b = x * x) * b) * d) * h * x;\n  case 18: return (h = (d = (b = x * x) * b) * d * x) * h;\n  case 19: return (h = (d = (b = x * x) * b) * d * x) * h * x;\n  case 20: return (h = (k = (b = x * x) * b * x) * k) * h;\n  case 21: return (h = (k = (b = x * x) * b * x) * k) * h * x;\n  case 22: return (g = (h = (k = (b = x * x) * b * x) * k) * x) * g;\n  case 23: return (h = (d = (c = (b = x * x) * x) * b) * d) * h * c;\n  case 24: return (h = (d = (c = x * x * x) * c) * d) * h;\n  case 25: return (h = (d = (c = x * x * x) * c) * d) * h * x;\n  case 26: return (g = (h = (d = (c = x * x * x) * c) * d) * x) * g;\n  case 27: return (h = (d = (c = x * x * x) * c) * d) * h * c;\n  case 28: return (h = (d = (c = x * x * x) * c * x) * d) * h;\n  case 29: return (h = (d = (c = x * x * x) * c * x) * d) * h * x;\n  case 30: return (h = (d = (c = x * x * x) * c) * d * c) * h;\n  case 31: return (h = (d = (c = x * x * x) * c) * d * c) * h * x;\n}\n\nfor ipow64: TODO\nswitch (e) {\n  case 32:\n  ...\n  case 63:\n}\n*/\n","import { strtol, strtod, strtob } from \"./util/string\";\n\ntype auto = i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isBoolean<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isInteger<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isSigned<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFloat<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVector<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isReference<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isString<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArray<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isArrayLike<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isFunction<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isNullable<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isDefined(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isConstant(expression: auto): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isManaged<T>(value?: T): bool;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isVoid<T>(): bool;\n\n// @ts-ignore\n@builtin\nexport declare function lengthof<T>(func?: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function clz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ctz<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function popcnt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotl<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rotr<T>(value: T, shift: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function abs<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function max<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function min<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ceil<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function floor<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function copysign<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function nearest<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function reinterpret<T>(value: number): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sqrt<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function trunc<T>(value: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function add<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sub<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function mul<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function div<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function eq<T>(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function ne<T>(left: T, right: T): i32;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function rem<T>(left: T, right: T): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function store<T>(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function sizeof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function alignof<T>(): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64\n\n// @ts-ignore: decorator\n@builtin\nexport declare function idof<T>(): u32;\n\n// @ts-ignore\n@builtin\nexport declare function nameof<T>(): string;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unreachable(): auto;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function changetype<T>(value: auto): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function assert<T>(isTrueish: T, message?: string): T;\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function unchecked<T>(expr: T): T;\n\nexport namespace inline {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function always<T>(expr: T): T;\n}\n\n// @ts-ignore: decorator\n@unsafe @builtin\nexport declare function call_indirect<T>(index: u32, ...args: auto[]): T;\n\n// @ts-ignore: decorator\n@builtin\nexport declare function instantiate<T>(...args: auto[]): T;\n\nexport namespace atomic {\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load<T>(ptr: usize, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store<T>(ptr: usize, value: T, immOffset?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function notify(ptr: usize, count: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function fence(): void;\n}\n\n// @ts-ignore: decorator\n@lazy\nexport const enum AtomicWaitResult {\n  OK = 0,\n  NOT_EQUAL = 1,\n  TIMED_OUT = 2\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8(value: auto): i8;\n\nexport namespace i8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i8 = -128;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i8 =  127;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i8 {\n    return <i8>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16(value: auto): i16;\n\nexport namespace i16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i16 = -32768;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i16 =  32767;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i16 {\n    return <i16>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32(value: auto): i32;\n\nexport namespace i32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i32 = -2147483648;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i32 =  2147483647;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i32 {\n    return strtol<i32>(value, radix);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i32, shift: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: i32, right:i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_s(left: i32, right: i32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_u(left: u32, right: u32): u32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f32(value: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): i32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i32, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i32;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i32, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i32, immOffset?: usize): void;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i32, immOffset?: usize): i32;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64(value: auto): i64;\n\nexport namespace i64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: i64 = -9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: i64 =  9223372036854775807;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): i64 {\n    return strtol<i64>(value, radix);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function clz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ctz(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_s(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div_u(left: i64, right:i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_s(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32_u(ptr: usize, immOffset?: usize, immAlign?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(value: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotl(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rotr(value: i64, shift: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: i64, right:i64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: i64, right:i64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_s(left: i64, right: i64): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function rem_u(left: u64, right: u64): u64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_f64(value: f64): i64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: i64, immOffset?: usize, immAlign?: usize): void;\n\n  export namespace atomic {\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load8_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load16_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load32_u(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @builtin\n    export declare function load(ptr: usize, immOffset?: usize): i64;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store8(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store16(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store32(ptr: usize, value: i64, immOffset?: usize): void;\n\n    // @ts-ignore: decorator\n    @unsafe @builtin\n    export declare function store(ptr: usize, value: i64, immOffset?: usize): void;\n\n    export namespace rmw8 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw16 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw32 {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n\n    export namespace rmw {\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function add(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function sub(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function and(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function or(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @builtin\n      export declare function xor(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function xchg(ptr: usize, value: i64, immOffset?: usize): i64;\n\n      // @ts-ignore: decorator\n      @unsafe @builtin\n      export declare function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;\n    }\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function isize(value: auto): isize;\n\nexport namespace isize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? -2147483648\n    : <isize>-9223372036854775808;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()\n    ? 2147483647\n    : <isize>9223372036854775807;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): isize {\n    return <isize>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u8(value: auto): u8;\n\nexport namespace u8 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u8 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u8 = 255;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u8 {\n    return <u8>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u16(value: auto): u16;\n\nexport namespace u16 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u16 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u16 = 65535;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u16 {\n    return <u16>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u32(value: auto): u32;\n\nexport namespace u32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u32 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u32 = 4294967295;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u32 {\n    return <u32>strtol<i32>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function u64(value: auto): u64;\n\nexport namespace u64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: u64 = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: u64 = 18446744073709551615;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): u64 {\n    return <u64>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function usize(value: auto): usize;\n\nexport namespace usize {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: usize = 0;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()\n    ? 4294967295\n    : <usize>18446744073709551615;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string, radix: i32 = 0): usize {\n    return <usize>strtol<i64>(value, radix);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function bool(value: auto): bool;\n\nexport namespace bool {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE: bool = false;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE: bool = true;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): bool {\n    return strtob(value);\n  }\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32(value: auto): f32;\n\nexport namespace f32 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f32 = -16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f32 =  16777215;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f32 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f32 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f32 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): f32 {\n    return <f32>strtod(value);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f32, y: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i32(value: i32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f32, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f32, right: f32): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: f32, right: f32): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: f32, right: f32): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64(value: auto): f64;\n\nexport namespace f64 {\n\n  // @ts-ignore: decorator\n  @lazy\n  export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const MAX_SAFE_INTEGER: f64 =  9007199254740991;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const POSITIVE_INFINITY: f64 =  Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NEGATIVE_INFINITY: f64 = -Infinity;\n\n  // @ts-ignore: decorator\n  @lazy\n  export const NaN: f64 = 0.0 / 0.0;\n\n  // @ts-ignore: decorator\n  @inline\n  export function parse(value: string): f64 {\n    return strtod(value);\n  }\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function copysign(x: f64, y: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function reinterpret_i64(value: i64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: f64, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(value: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(left: f64, right: f64): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(left: f64, right: f64): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(left: f64, right: f64): i32;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function v128(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace v128 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat<T>(x: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane<T>(x: v128, idx: u8): T;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_zero<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store_lane<TFrom>(ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load8x8_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load16x4_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_s(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function load32x2_u(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_splat(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_zero(ptr: usize, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function load64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): v128;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store8_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store16_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store32_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store64_lane(ptr: usize, vec: v128, idx: u8, immOffset?: u32, immAlign?: u32): void;\n\n  // @ts-ignore: decorator\n  @unsafe @builtin\n  export declare function store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr<T>(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function and(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function or(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function xor(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function andnot(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function not(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitselect(v1: v128, v2: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function any_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true<T>(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask<T>(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot<T>(a: v128, b: v128): v128; // i16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr<T>(a: v128, b: v128): v128; // u8, u16 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest<T>(a: v128): v128; // f32, f64 only\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_zero<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_zero<T = f64>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low<T = f32>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_zero<T>(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd<T>(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd<T>(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect<T>(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_q15mulr<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot<T>(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_add<T>(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i8x16(\n  a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8,\n  i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8\n): v128;\n\nexport namespace i8x16 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u8;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function popcnt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8,\n    l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function swizzle(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_swizzle(a: v128, s: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;\n\nexport namespace i16x8 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_s(x: v128, idx: u8): i16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane_u(x: v128, idx: u8): u16;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i16): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function avgr_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub_sat_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function narrow_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i8x16_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function q15mulr_sat_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i8x16_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i8x16_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(\n    a: v128, b: v128,\n    l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8\n  ): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_q15mulr_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_i8x16_i7x16_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;\n\nexport namespace i32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function dot_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_s_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc_sat_f64x2_u_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extadd_pairwise_i16x8_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i16x8_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f64x2_s_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_trunc_f64x2_u_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_dot_i8x16_i7x16_add_s(a: v128, b: v128, c: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function i64x2(a: i64, b: i64): v128;\n\nexport namespace i64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): i64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: i64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shl(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_s(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shr_u(a: v128, b: i32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function all_true(a: v128): bool;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function bitmask(a: v128): i32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extend_high_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_low_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_s(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extmul_high_i32x4_u(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_laneselect(a: v128, b: v128, m: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;\n\nexport namespace f32x4 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f32;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f32): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function demote_f64x2_zero(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n// @ts-ignore: decorator\n@builtin\nexport declare function f64x2(a: f64, b: f64): v128;\n\nexport namespace f64x2 {\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function splat(x: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function extract_lane(x: v128, idx: u8): f64;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function replace_lane(x: v128, idx: u8, value: f64): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function add(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sub(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function mul(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function div(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function neg(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function max(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmin(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function pmax(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function abs(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function sqrt(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ceil(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function floor(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function trunc(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function nearest(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function eq(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ne(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function lt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function le(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function gt(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function ge(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_s(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function convert_low_i32x4_u(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function promote_low_f32x4(a: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_madd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_nmadd(a: v128, b: v128, c: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_min(a: v128, b: v128): v128;\n\n  // @ts-ignore: decorator\n  @builtin\n  export declare function relaxed_max(a: v128, b: v128): v128;\n}\n\n@final\nexport abstract class i31 { // FIXME: usage of 'new' requires a class :(\n\n  // @ts-ignore: decorator\n  @builtin\n  static new(value: i32): i31ref { return changetype<i31ref>(unreachable()); }\n\n  // @ts-ignore: decorator\n  @builtin\n  static get(i31expr: i31ref): i32 { return unreachable(); }\n}\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n\n// @ts-ignore: decorator\n@external(\"env\", \"abort\")\n@external.js(\"throw Error(`${message} in ${fileName}:${lineNumber}:${columnNumber}`);\")\ndeclare function abort(\n  message?: string | null,\n  fileName?: string | null,\n  lineNumber?: u32,\n  columnNumber?: u32\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"trace\")\n@external.js(\"console.log(message, ...[a0, a1, a2, a3, a4].slice(0, n));\")\ndeclare function trace(\n  message: string,\n  n?: i32,\n  a0?: f64,\n  a1?: f64,\n  a2?: f64,\n  a3?: f64,\n  a4?: f64\n): void;\n\n// @ts-ignore: decorator\n@external(\"env\", \"seed\")\n@external.js(\"return Date.now() * Math.random();\")\ndeclare function seed(): f64;\n\n/* eslint-enable @typescript-eslint/no-unused-vars */\n","/**\r\n * Array Operations for AssemblyScript\r\n *\r\n * High-performance array operations using typed arrays.\r\n * These operations work directly on Float64Array data.\r\n */\r\n\r\n// =============================================================================\r\n// Reduction Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Sum all elements in the array\r\n */\r\nexport function array_sum(data: Float64Array): f64 {\r\n  let total: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    total += unchecked(data[i]);\r\n  }\r\n  return total;\r\n}\r\n\r\n/**\r\n * Product of all elements\r\n */\r\nexport function array_product(data: Float64Array): f64 {\r\n  let product: f64 = 1.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    product *= unchecked(data[i]);\r\n  }\r\n  return product;\r\n}\r\n\r\n/**\r\n * Mean (average) of all elements\r\n */\r\nexport function array_mean(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n  return array_sum(data) / f64(len);\r\n}\r\n\r\n/**\r\n * Variance (population variance)\r\n */\r\nexport function array_variance(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  const mean = array_mean(data);\r\n  let sumSqDiff: f64 = 0.0;\r\n\r\n  for (let i = 0; i < len; i++) {\r\n    const diff = unchecked(data[i]) - mean;\r\n    sumSqDiff += diff * diff;\r\n  }\r\n\r\n  return sumSqDiff / f64(len);\r\n}\r\n\r\n/**\r\n * Standard deviation (population)\r\n */\r\nexport function array_stddev(data: Float64Array): f64 {\r\n  return sqrt(array_variance(data));\r\n}\r\n\r\n/**\r\n * Minimum value\r\n */\r\nexport function array_min(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let minVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) minVal = val;\r\n  }\r\n  return minVal;\r\n}\r\n\r\n/**\r\n * Maximum value\r\n */\r\nexport function array_max(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let maxVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) maxVal = val;\r\n  }\r\n  return maxVal;\r\n}\r\n\r\n/**\r\n * Index of minimum value\r\n */\r\nexport function array_argmin(data: Float64Array): i32 {\r\n  const len = data.length;\r\n  if (len == 0) return -1;\r\n\r\n  let minIdx: i32 = 0;\r\n  let minVal = unchecked(data[0]);\r\n\r\n  for (let i: i32 = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) {\r\n      minVal = val;\r\n      minIdx = i;\r\n    }\r\n  }\r\n  return minIdx;\r\n}\r\n\r\n/**\r\n * Index of maximum value\r\n */\r\nexport function array_argmax(data: Float64Array): i32 {\r\n  const len = data.length;\r\n  if (len == 0) return -1;\r\n\r\n  let maxIdx: i32 = 0;\r\n  let maxVal = unchecked(data[0]);\r\n\r\n  for (let i: i32 = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) {\r\n      maxVal = val;\r\n      maxIdx = i;\r\n    }\r\n  }\r\n  return maxIdx;\r\n}\r\n\r\n/**\r\n * L2 norm (Euclidean norm)\r\n */\r\nexport function array_norm(data: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    sumSq += val * val;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * L1 norm (sum of absolute values)\r\n */\r\nexport function array_norm_l1(data: Float64Array): f64 {\r\n  let sum: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    sum += abs(unchecked(data[i]));\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * L-infinity norm (max absolute value)\r\n */\r\nexport function array_norm_linf(data: Float64Array): f64 {\r\n  let maxAbs: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const absVal = abs(unchecked(data[i]));\r\n    if (absVal > maxAbs) maxAbs = absVal;\r\n  }\r\n  return maxAbs;\r\n}\r\n\r\n// =============================================================================\r\n// Vector Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Dot product of two arrays\r\n */\r\nexport function array_dot(a: Float64Array, b: Float64Array): f64 {\r\n  const len = min(a.length, b.length);\r\n  let result: f64 = 0.0;\r\n  for (let i = 0; i < len; i++) {\r\n    result += unchecked(a[i]) * unchecked(b[i]);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Element-wise addition: result = a + b\r\n */\r\nexport function array_add(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise subtraction: result = a - b\r\n */\r\nexport function array_sub(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) - unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise multiplication: result = a * b\r\n */\r\nexport function array_mul(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) * unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise division: result = a / b\r\n */\r\nexport function array_div(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) / unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Scale array by scalar: result = a * scalar\r\n */\r\nexport function array_scale(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar to array: result = a + scalar\r\n */\r\nexport function array_add_scalar(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) + scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Negate array: result = -a\r\n */\r\nexport function array_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = -unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Absolute value: result = |a|\r\n */\r\nexport function array_abs(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = abs(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n/**\r\n * Square root: result = sqrt(a)\r\n */\r\nexport function array_sqrt(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = sqrt(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n/**\r\n * Square: result = a^2\r\n */\r\nexport function array_square(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(a[i]);\r\n    unchecked((result[i] = val * val));\r\n  }\r\n}\r\n\r\n/**\r\n * Exponential: result = Math.exp(a)\r\n */\r\nexport function array_exp(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = Math.exp(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n/**\r\n * Natural log: result = Math.log(a)\r\n */\r\nexport function array_log(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = Math.log(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n/**\r\n * Sine: result = Math.sin(a)\r\n */\r\nexport function array_sin(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = Math.sin(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n/**\r\n * Cosine: result = Math.cos(a)\r\n */\r\nexport function array_cos(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = Math.cos(unchecked(a[i]))));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Helpers\r\n// =============================================================================\r\n\r\n/**\r\n * Linear combination: result = alpha*a + beta*b (AXPBY)\r\n */\r\nexport function array_axpby(\r\n  alpha: f64,\r\n  a: Float64Array,\r\n  beta: f64,\r\n  b: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = alpha * unchecked(a[i]) + beta * unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Euclidean distance between two vectors\r\n */\r\nexport function array_distance(a: Float64Array, b: Float64Array): f64 {\r\n  const len = min(a.length, b.length);\r\n  let sumSq: f64 = 0.0;\r\n  for (let i = 0; i < len; i++) {\r\n    const diff = unchecked(a[i]) - unchecked(b[i]);\r\n    sumSq += diff * diff;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * Cosine similarity between two vectors\r\n */\r\nexport function array_cosine_similarity(a: Float64Array, b: Float64Array): f64 {\r\n  const dot = array_dot(a, b);\r\n  const normA = array_norm(a);\r\n  const normB = array_norm(b);\r\n  if (normA == 0.0 || normB == 0.0) return 0.0;\r\n  return dot / (normA * normB);\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations (modify input array)\r\n// =============================================================================\r\n\r\n/**\r\n * Scale array in place: a *= scalar\r\n */\r\nexport function array_scale_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar in place: a += scalar\r\n */\r\nexport function array_add_scalar_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) + scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Add arrays in place: a += b\r\n */\r\nexport function array_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Clamp all values in place to [lo, hi]\r\n */\r\nexport function array_clamp_inplace(a: Float64Array, lo: f64, hi: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(a[i]);\r\n    unchecked((a[i] = max(lo, min(hi, val))));\r\n  }\r\n}\r\n\r\n/**\r\n * Fill array with value\r\n */\r\nexport function array_fill(a: Float64Array, value: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = value));\r\n  }\r\n}\r\n\r\n/**\r\n * Copy array: dst = src\r\n */\r\nexport function array_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((dst[i] = unchecked(src[i])));\r\n  }\r\n}\r\n","import { compareImpl } from \"./string\";\n\ntype Comparator<T> = (a: T, b: T) => i32;\n\n// @ts-ignore: decorator\n@lazy @inline const EMPTY = u32.MAX_VALUE;\n// @ts-ignore: decorator\n@inline const INSERTION_SORT_THRESHOLD = 48;\n// @ts-ignore: decorator\n@inline const MIN_RUN_LENGTH = 32;\n\n// @ts-ignore: decorator\n@inline\nfunction log2u(n: u32): u32 {\n  return 31 - clz(n);\n}\n\n// @ts-ignore: decorator\n@inline\nexport function COMPARATOR<T>(): Comparator<T> {\n  if (isInteger<T>()) {\n    if (isSigned<T>() && sizeof<T>() <= 4) {\n      return (a, b) => i32(a) - i32(b);\n    } else {\n      return (a, b) => i32(a > b) - i32(a < b);\n    }\n  } else if (isFloat<T>()) {\n    if (sizeof<T>() == 4) {\n      return (a, b) => {\n        let ia = reinterpret<i32>(f32(a));\n        let ib = reinterpret<i32>(f32(b));\n        ia ^= ia >> 31 >>> 1;\n        ib ^= ib >> 31 >>> 1;\n        return i32(ia > ib) - i32(ia < ib);\n      };\n    } else {\n      return (a, b) => {\n        let ia = reinterpret<i64>(f64(a));\n        let ib = reinterpret<i64>(f64(b));\n        ia ^= ia >> 63 >>> 1;\n        ib ^= ib >> 63 >>> 1;\n        return i32(ia > ib) - i32(ia < ib);\n      };\n    }\n  } else if (isString<T>()) {\n    return (a, b) => {\n      if (\n        changetype<usize>(a) == changetype<usize>(b) ||\n        changetype<usize>(a) == 0 ||\n        changetype<usize>(b) == 0\n      ) return 0;\n      let alen = changetype<string>(a).length;\n      let blen = changetype<string>(b).length;\n      if (!(alen | blen)) return 0;\n      if (!alen) return -1;\n      if (!blen) return  1;\n      let res = compareImpl(\n        changetype<string>(a), 0,\n        changetype<string>(b), 0,\n        <usize>min(alen, blen)\n      );\n      return res ? res : alen - blen;\n    };\n  } else {\n    return (a, b) => i32(a > b) - i32(a < b);\n  }\n}\n\n// Power Sort implementation (stable) from paper \"Nearly-Optimal Mergesorts\"\n// https://arxiv.org/pdf/1805.04154.pdf\n// This method usually outperform TimSort.\n// TODO: refactor c >>> 31 to c < 0 when binaryen will support this opt\nexport function SORT<T>(\n  ptr: usize,\n  len: i32,\n  comparator: Comparator<T>\n): void {\n  if (len <= INSERTION_SORT_THRESHOLD) {\n    if (len <= 1) return;\n    if (ASC_SHRINK_LEVEL < 1) {\n      switch (len) {\n        case 3: {\n          let a = load<T>(ptr, 0);\n          let b = load<T>(ptr, 1 << alignof<T>());\n          let c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 0);\n          a = select<T>(a, b, c);\n          b = load<T>(ptr, 2 << alignof<T>());\n          c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 1 << alignof<T>());\n          store<T>(ptr, select<T>(a, b, c), 2 << alignof<T>());\n        }\n        case 2: {\n          let a = load<T>(ptr, 0);\n          let b = load<T>(ptr, 1 << alignof<T>());\n          let c = comparator(a, b) > 0;\n          store<T>(ptr, select<T>(b, a, c), 0);\n          store<T>(ptr, select<T>(a, b, c), 1 << alignof<T>());\n          return;\n        }\n      }\n    }\n    insertionSort<T>(ptr, 0, len - 1, 0, comparator);\n    return;\n  }\n\n  let lgPlus2         = log2u(len) + 2;\n  let lgPlus2Size     = lgPlus2 << alignof<u32>();\n  let leftRunStartBuf = __alloc(lgPlus2Size << 1);\n  let leftRunEndBuf   = leftRunStartBuf + lgPlus2Size;\n\n  for (let i: u32 = 0; i < lgPlus2; ++i) {\n    store<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()), EMPTY);\n  }\n\n  let buffer = __alloc(len << alignof<T>());\n\n  let hi   = len - 1;\n  let endA = extendRunRight<T>(ptr, 0, hi, comparator);\n  let lenA = endA + 1;\n\n  if (lenA < MIN_RUN_LENGTH) {\n    endA = min(hi, MIN_RUN_LENGTH - 1);\n    insertionSort<T>(ptr, 0, endA, lenA, comparator);\n  }\n\n  let top: u32 = 0, startA = 0;\n  while (endA < hi) {\n    let startB = endA + 1;\n    let endB = extendRunRight<T>(ptr, startB, hi, comparator);\n    let lenB = endB - startB + 1;\n\n    if (lenB < MIN_RUN_LENGTH) {\n      endB = min(hi, startB + MIN_RUN_LENGTH - 1);\n      insertionSort<T>(ptr, startB, endB, lenB, comparator);\n    }\n\n    let k = nodePower(0, hi, startA, startB, endB);\n\n    for (let i = top; i > k; --i) {\n      let start = load<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()));\n      if (start != EMPTY) {\n        mergeRuns<T>(\n          ptr,\n          start,\n          load<u32>(leftRunEndBuf + (<usize>i << alignof<u32>())) + 1,\n          endA,\n          buffer,\n          comparator\n        );\n        startA = start;\n        store<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()), EMPTY);\n      }\n    }\n\n    store<u32>(leftRunStartBuf + (<usize>k << alignof<u32>()), startA);\n    store<u32>(leftRunEndBuf   + (<usize>k << alignof<u32>()), endA);\n    startA = startB;\n    endA = endB;\n    top = k;\n  }\n\n  for (let i = top; i != 0; --i) {\n    let start = load<u32>(leftRunStartBuf + (<usize>i << alignof<u32>()));\n    if (start != EMPTY) {\n      mergeRuns<T>(\n        ptr,\n        start,\n        load<u32>(leftRunEndBuf + (<usize>i << alignof<u32>())) + 1,\n        hi,\n        buffer,\n        comparator\n      );\n    }\n  }\n  // dealloc aux buffers\n  __free(buffer);\n  __free(leftRunStartBuf);\n}\n\nfunction insertionSort<T>(\n  ptr: usize,\n  left: i32,\n  right: i32,\n  presorted: i32,\n  comparator: Comparator<T>\n): void {\n  if (ASC_SHRINK_LEVEL >= 1) {\n    // slightly improved original insertion sort\n    for (let i = left + presorted; i <= right; ++i) {\n      let j = i - 1;\n      let a = load<T>(ptr + (<usize>i << alignof<T>()));\n      while (j >= left) {\n        let b = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, b) < 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), b, 1 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), a, 1 << alignof<T>());\n    }\n  } else {\n    // even-odd two-way insertion sort which allow increase minRunLen\n    let range = right - left + 1;\n    let i = left + select(range & 1, presorted - ((range - presorted) & 1), presorted == 0);\n    for (; i <= right; i += 2) {\n      let a = load<T>(ptr + (<usize>i << alignof<T>()), 0);\n      let b = load<T>(ptr + (<usize>i << alignof<T>()), 1 << alignof<T>());\n      let min = b, max = a;\n      if (comparator(a, b) <= 0) {\n        min = a, max = b;\n      }\n      let j = i - 1;\n      while (j >= left) {\n        a = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, max) > 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), a, 2 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), max, 2 << alignof<T>());\n      while (j >= left) {\n        a = load<T>(ptr + (<usize>j << alignof<T>()));\n        if (comparator(a, min) > 0) {\n          store<T>(ptr + (<usize>j << alignof<T>()), a, 1 << alignof<T>()); --j;\n        } else break;\n      }\n      store<T>(ptr + (<usize>j << alignof<T>()), min, 1 << alignof<T>());\n    }\n  }\n}\n\nfunction nodePower(left: u32, right: u32, startA: u32, startB: u32, endB: u32): u32 {\n  let n: u64 = right - left + 1;\n  let s = startB - (left << 1);\n  let l = startA + s;\n  let r = endB   + s + 1;\n  let a = (<u64>l << 30) / n;\n  let b = (<u64>r << 30) / n;\n  return clz(<u32>(a ^ b));\n}\n\nfunction extendRunRight<T>(\n  ptr: usize,\n  i: i32,\n  right: i32,\n  comparator: Comparator<T>\n): i32 {\n  if (i == right) return i;\n  let j = i;\n  if (comparator(\n    load<T>(ptr + (<usize>  j << alignof<T>())),\n    load<T>(ptr + (<usize>++j << alignof<T>()))\n  ) > 0) {\n    while (\n      j < right &&\n      (comparator(\n        load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),\n        load<T>(ptr + (<usize>j << alignof<T>()))\n      ) >>> 31) // < 0\n    ) ++j;\n    // reverse\n    let k = j;\n    while (i < k) {\n      let tmp = load<T>(ptr + (<usize>i << alignof<T>()));\n      store<T>(ptr + (<usize>i << alignof<T>()), load<T>(ptr + (<usize>k << alignof<T>()))); ++i;\n      store<T>(ptr + (<usize>k << alignof<T>()), tmp); --k;\n    }\n  } else {\n    while (\n      j < right &&\n      comparator(\n        load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>()),\n        load<T>(ptr + (<usize>j << alignof<T>()))\n      ) >= 0\n    ) ++j;\n  }\n  return j;\n}\n\n// Merges arr[l..m - 1] and arr[m..r]\nfunction mergeRuns<T>(\n  ptr: usize,\n  l: i32,\n  m: i32,\n  r: i32,\n  buffer: usize,\n  comparator: Comparator<T>\n): void {\n  --m;\n  let i: i32, j: i32, t = r + m;\n  for (i = m + 1; i > l; --i) {\n    store<T>(\n      buffer + (<usize>(i - 1) << alignof<T>()),\n      load<T>(ptr + (<usize>(i - 1) << alignof<T>()))\n    );\n  }\n  for (j = m; j < r; ++j) {\n    store<T>(\n      buffer + (<usize>(t - j) << alignof<T>()),\n      load<T>(ptr + (<usize>j << alignof<T>()), 1 << alignof<T>())\n    );\n  }\n  for (let k = l; k <= r; ++k) {\n    let a = load<T>(buffer + (<usize>j << alignof<T>()));\n    let b = load<T>(buffer + (<usize>i << alignof<T>()));\n    if (comparator(a, b) < 0) {\n      store<T>(ptr + (<usize>k << alignof<T>()), a);\n      --j;\n    } else {\n      store<T>(ptr + (<usize>k << alignof<T>()), b);\n      ++i;\n    }\n  }\n}\n","// This file is shared with the compiler and must remain portable\n\n/** Runtime types. */\nexport enum Runtime {\n  /** Simple bump allocator without GC. */\n  Stub = 0,\n  /** Stop the world semi-automatic GC. */\n  Minimal = 1,\n  /** incremental GC. */\n  Incremental = 2,\n}\n","import { COMPARATOR, SORT } from \"./util/sort\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_NOTIMPLEMENTED } from \"./util/error\";\nimport { joinIntegerArray, joinFloatArray } from \"./util/string\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { idof } from \"./builtins\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\nexport class Int8Array extends ArrayBufferView {\n  [key: number]: i8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i8>();\n\n  constructor(length: i32) {\n    super(length, alignof<i8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i8 {\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i8>): void {\n    store<i8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): i8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: i8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int8Array, i8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i8, b: i8) => i32 = COMPARATOR<i8>()): Int8Array {\n    SORT<i8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SLICE<Int8Array, i8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int8Array {\n    return SUBARRAY<Int8Array, i8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int8Array {\n    return COPY_WITHIN<Int8Array, i8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {\n    return MAP<Int8Array, i8>(this, fn);\n  }\n\n  filter(fn: (value: i8, index: i32, self: Int8Array) => bool): Int8Array {\n    return FILTER<Int8Array, i8>(this, fn);\n  }\n\n  findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int8Array, i8>(this, fn);\n  }\n\n  some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return SOME<Int8Array, i8>(this, fn);\n  }\n\n  every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {\n    return EVERY<Int8Array, i8>(this, fn);\n  }\n\n  forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {\n    FOREACH<Int8Array, i8>(this, fn);\n  }\n\n  reverse(): Int8Array {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i8>(this.dataStart, this.length, separator);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int8Array {\n    return WRAP<Int8Array, i8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8Array extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, value);\n  }\n\n  at(index: i32): u8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8Array, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8Array {\n    SORT<u8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SLICE<Uint8Array, u8>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return SUBARRAY<Uint8Array, u8>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8Array {\n    return COPY_WITHIN<Uint8Array, u8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {\n    return MAP<Uint8Array, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8Array) => bool): Uint8Array {\n    return FILTER<Uint8Array, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint8Array, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return SOME<Uint8Array, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {\n    return EVERY<Uint8Array, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {\n    FOREACH<Uint8Array, u8>(this, fn);\n  }\n\n  reverse(): Uint8Array {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8Array {\n    return WRAP<Uint8Array, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint8ClampedArray extends ArrayBufferView {\n  [key: number]: u8;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u8>();\n\n  constructor(length: i32) {\n    super(length, alignof<u8>());\n  }\n\n  get length(): i32 {\n    return this.byteLength;\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u8 {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u8 {\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u8>): void {\n    if (<u32>index >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u8>): void {\n    store<u8>(this.dataStart + <usize>index, ~(<i32>value >> 31) & (((255 - value) >> 31) | value));\n  }\n\n  at(index: i32): u8 {\n    let len = this.byteLength;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u8>(this.dataStart + <usize>index);\n  }\n\n  includes(searchElement: u8, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u8, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u8, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint8ClampedArray, u8>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    value = ~(value >> 31) & (((255 - value) >> 31) | value);\n    FILL<u8>(this.dataStart, this.length, u8(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u8, b: u8) => i32 = COMPARATOR<u8>()): Uint8ClampedArray {\n    SORT<u8>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SLICE<Uint8ClampedArray, u8>(this, begin, end);\n  }\n\n  subarray(start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return SUBARRAY<Uint8ClampedArray, u8>(this, start, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {\n    return COPY_WITHIN<Uint8ClampedArray, u8>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {\n    return MAP<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  filter(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): Uint8ClampedArray {\n    return FILTER<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {\n    return FIND_LAST_INDEX<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return SOME<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {\n    return EVERY<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {\n    FOREACH<Uint8ClampedArray, u8>(this, fn);\n  }\n\n  reverse(): Uint8ClampedArray {\n    REVERSE<u8>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u8>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint8ClampedArray {\n    return WRAP<Uint8ClampedArray, u8>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int16Array extends ArrayBufferView {\n  [key: number]: i16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i16>();\n\n  constructor(length: i32) {\n    super(length, alignof<i16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i16 {\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<i16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<i16>): void {\n    store<i16>(this.dataStart + (<usize>index << alignof<i16>()), value);\n  }\n\n  at(index: i32): i16 {\n    let len = this.byteLength >>> alignof<i16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i16>(this.dataStart + (<usize>index << alignof<i16>()));\n  }\n\n  includes(searchElement: i16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int16Array, i16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    FILL<u16>(this.dataStart, this.length, u16(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i16, b: i16) => i32 = COMPARATOR<i16>()): Int16Array {\n    SORT<i16>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SLICE<Int16Array, i16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int16Array {\n    return SUBARRAY<Int16Array, i16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int16Array {\n    return COPY_WITHIN<Int16Array, i16>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {\n    return MAP<Int16Array, i16>(this, fn);\n  }\n\n  filter(fn: (value: i16, index: i32, self: Int16Array) => bool): Int16Array {\n    return FILTER<Int16Array, i16>(this, fn);\n  }\n\n  findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int16Array, i16>(this, fn);\n  }\n\n  some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return SOME<Int16Array, i16>(this, fn);\n  }\n\n  every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {\n    return EVERY<Int16Array, i16>(this, fn);\n  }\n\n  forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {\n    FOREACH<Int16Array, i16>(this, fn);\n  }\n\n  reverse(): Int16Array {\n    REVERSE<u16>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int16Array {\n    return WRAP<Int16Array, i16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint16Array extends ArrayBufferView {\n  [key: number]: u16;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u16>();\n\n  constructor(length: i32) {\n    super(length, alignof<u16>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u16>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u16 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u16 {\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: native<u16>): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u16>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: native<u16>): void {\n    store<u16>(this.dataStart + (<usize>index << alignof<u16>()), value);\n  }\n\n  at(index: i32): u16 {\n    let len = this.byteLength >>> alignof<u16>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u16>(this.dataStart + (<usize>index << alignof<u16>()));\n  }\n\n  includes(searchElement: u16, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u16, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u16, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint16Array, u16>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    FILL<u16>(this.dataStart, this.length, u16(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u16, b: u16) => i32 = COMPARATOR<u16>()): Uint16Array {\n    SORT<u16>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SLICE<Uint16Array, u16>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return SUBARRAY<Uint16Array, u16>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint16Array {\n    return COPY_WITHIN<Uint16Array, u16>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {\n    return MAP<Uint16Array, u16>(this, fn);\n  }\n\n  filter(fn: (value: u16, index: i32, self: Uint16Array) => bool): Uint16Array {\n    return FILTER<Uint16Array, u16>(this, fn);\n  }\n\n  findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint16Array, u16>(this, fn);\n  }\n\n  some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return SOME<Uint16Array, u16>(this, fn);\n  }\n\n  every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {\n    return EVERY<Uint16Array, u16>(this, fn);\n  }\n\n  forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {\n    FOREACH<Uint16Array, u16>(this, fn);\n  }\n\n  reverse(): Uint16Array {\n    REVERSE<u16>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u16>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint16Array {\n    return WRAP<Uint16Array, u16>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int32Array extends ArrayBufferView {\n  [key: number]: i32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i32>();\n\n  constructor(length: i32) {\n    super(length, alignof<i32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i32 {\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i32): void {\n    store<i32>(this.dataStart + (<usize>index << alignof<i32>()), value);\n  }\n\n  at(index: i32): i32 {\n    let len = this.byteLength >>> alignof<i32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i32>(this.dataStart + (<usize>index << alignof<i32>()));\n  }\n\n  includes(searchElement: i32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int32Array, i32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    FILL<u32>(this.dataStart, this.length, u32(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i32, b: i32) => i32 = COMPARATOR<i32>()): Int32Array {\n    SORT<i32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SLICE<Int32Array, i32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int32Array {\n    return SUBARRAY<Int32Array, i32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int32Array {\n    return COPY_WITHIN<Int32Array, i32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {\n    return MAP<Int32Array, i32>(this, fn);\n  }\n\n  filter(fn: (value: i32, index: i32, self: Int32Array) => bool): Int32Array {\n    return FILTER<Int32Array, i32>(this, fn);\n  }\n\n  findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int32Array, i32>(this, fn);\n  }\n\n  some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return SOME<Int32Array, i32>(this, fn);\n  }\n\n  every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {\n    return EVERY<Int32Array, i32>(this, fn);\n  }\n\n  forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {\n    FOREACH<Int32Array, i32>(this, fn);\n  }\n\n  reverse(): Int32Array {\n    REVERSE<u32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int32Array {\n    return WRAP<Int32Array, i32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint32Array extends ArrayBufferView {\n  [key: number]: u32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u32>();\n\n  constructor(length: i32) {\n    super(length, alignof<u32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u32 {\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u32): void {\n    store<u32>(this.dataStart + (<usize>index << alignof<u32>()), value);\n  }\n\n  at(index: i32): u32 {\n    let len = this.byteLength >>> alignof<u32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u32>(this.dataStart + (<usize>index << alignof<u32>()));\n  }\n\n  includes(searchElement: u32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint32Array, u32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    FILL<u32>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u32, b: u32) => i32 = COMPARATOR<u32>()): Uint32Array {\n    SORT<u32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SLICE<Uint32Array, u32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return SUBARRAY<Uint32Array, u32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint32Array {\n    return COPY_WITHIN<Uint32Array, u32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {\n    return MAP<Uint32Array, u32>(this, fn);\n  }\n\n  filter(fn: (value: u32, index: i32, self: Uint32Array) => bool): Uint32Array {\n    return FILTER<Uint32Array, u32>(this, fn);\n  }\n\n  findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint32Array, u32>(this, fn);\n  }\n\n  some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return SOME<Uint32Array, u32>(this, fn);\n  }\n\n  every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {\n    return EVERY<Uint32Array, u32>(this, fn);\n  }\n\n  forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {\n    FOREACH<Uint32Array, u32>(this, fn);\n  }\n\n  reverse(): Uint32Array {\n    REVERSE<u32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint32Array {\n    return WRAP<Uint32Array, u32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Int64Array extends ArrayBufferView {\n  [key: number]: i64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<i64>();\n\n  constructor(length: i32) {\n    super(length, alignof<i64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<i64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): i64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): i64 {\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: i64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<i64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: i64): void {\n    store<i64>(this.dataStart + (<usize>index << alignof<i64>()), value);\n  }\n\n  at(index: i32): i64 {\n    let len = this.byteLength >>> alignof<i64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<i64>(this.dataStart + (<usize>index << alignof<i64>()));\n  }\n\n  includes(searchElement: i64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: i64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: i64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Int64Array, i64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: i64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    FILL<u64>(this.dataStart, this.length, u64(value), start, end);\n    return this;\n  }\n\n  sort(comparator: (a: i64, b: i64) => i32 = COMPARATOR<i64>()): Int64Array {\n    SORT<i64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SLICE<Int64Array, i64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Int64Array {\n    return SUBARRAY<Int64Array, i64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Int64Array {\n    return COPY_WITHIN<Int64Array, i64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {\n    return MAP<Int64Array, i64>(this, fn);\n  }\n\n  filter(fn: (value: i64, index: i32, self: Int64Array) => bool): Int64Array {\n    return FILTER<Int64Array, i64>(this, fn);\n  }\n\n  findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Int64Array, i64>(this, fn);\n  }\n\n  some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return SOME<Int64Array, i64>(this, fn);\n  }\n\n  every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {\n    return EVERY<Int64Array, i64>(this, fn);\n  }\n\n  forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {\n    FOREACH<Int64Array, i64>(this, fn);\n  }\n\n  reverse(): Int64Array {\n    REVERSE<u64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<i64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Int64Array {\n    return WRAP<Int64Array, i64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Uint64Array extends ArrayBufferView {\n  [key: number]: u64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<u64>();\n\n  constructor(length: i32) {\n    super(length, alignof<u64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<u64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): u64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): u64 {\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: u64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<u64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: u64): void {\n    store<u64>(this.dataStart + (<usize>index << alignof<u64>()), value);\n  }\n\n  at(index: i32): u64 {\n    let len = this.byteLength >>> alignof<u64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<u64>(this.dataStart + (<usize>index << alignof<u64>()));\n  }\n\n  includes(searchElement: u64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: u64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: u64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Uint64Array, u64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: u64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    FILL<u64>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: u64, b: u64) => i32 = COMPARATOR<u64>()): Uint64Array {\n    SORT<u64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SLICE<Uint64Array, u64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return SUBARRAY<Uint64Array, u64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Uint64Array {\n    return COPY_WITHIN<Uint64Array, u64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {\n    return MAP<Uint64Array, u64>(this, fn);\n  }\n\n  filter(fn: (value: u64, index: i32, self: Uint64Array) => bool): Uint64Array {\n    return FILTER<Uint64Array, u64>(this, fn);\n  }\n\n  findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Uint64Array, u64>(this, fn);\n  }\n\n  some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return SOME<Uint64Array, u64>(this, fn);\n  }\n\n  every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {\n    return EVERY<Uint64Array, u64>(this, fn);\n  }\n\n  forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {\n    FOREACH<Uint64Array, u64>(this, fn);\n  }\n\n  reverse(): Uint64Array {\n    REVERSE<u64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinIntegerArray<u64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Uint64Array {\n    return WRAP<Uint64Array, u64>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float32Array extends ArrayBufferView {\n  [key: number]: f32;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f32>();\n\n  constructor(length: i32) {\n    super(length, alignof<f32>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f32>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f32 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f32 {\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f32): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f32>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f32): void {\n    store<f32>(this.dataStart + (<usize>index << alignof<f32>()), value);\n  }\n\n  at(index: i32): f32 {\n    let len = this.byteLength >>> alignof<f32>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f32>(this.dataStart + (<usize>index << alignof<f32>()));\n  }\n\n  includes(searchElement: f32, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f32, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f32, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float32Array, f32>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    FILL<f32>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: f32, b: f32) => i32 = COMPARATOR<f32>()): Float32Array {\n    SORT<f32>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SLICE<Float32Array, f32>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float32Array {\n    return SUBARRAY<Float32Array, f32>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float32Array {\n    return COPY_WITHIN<Float32Array, f32>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {\n    return MAP<Float32Array, f32>(this, fn);\n  }\n\n  filter(fn: (value: f32, index: i32, self: Float32Array) => bool): Float32Array {\n    return FILTER<Float32Array, f32>(this, fn);\n  }\n\n  findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  findLastIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {\n    return FIND_LAST_INDEX<Float32Array, f32>(this, fn);\n  }\n\n  some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return SOME<Float32Array, f32>(this, fn);\n  }\n\n  every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {\n    return EVERY<Float32Array, f32>(this, fn);\n  }\n\n  forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {\n    FOREACH<Float32Array, f32>(this, fn);\n  }\n\n  reverse(): Float32Array {\n    REVERSE<f32>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f32>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float32Array {\n    return WRAP<Float32Array, f32>(buffer, byteOffset, length);\n  }\n}\n\nexport class Float64Array extends ArrayBufferView {\n  [key: number]: f64;\n\n  // @ts-ignore: decorator\n  @lazy\n  static readonly BYTES_PER_ELEMENT: i32 = sizeof<f64>();\n\n  constructor(length: i32) {\n    super(length, alignof<f64>());\n  }\n\n  get length(): i32 {\n    return this.byteLength >>> alignof<f64>();\n  }\n\n  @operator(\"[]\")\n  private __get(index: i32): f64 {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @unsafe @operator(\"{}\")\n  private __uget(index: i32): f64 {\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  @operator(\"[]=\")\n  private __set(index: i32, value: f64): void {\n    if (<u32>index >= <u32>this.byteLength >>> alignof<f64>()) throw new RangeError(E_INDEXOUTOFRANGE);\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  @unsafe @operator(\"{}=\")\n  private __uset(index: i32, value: f64): void {\n    store<f64>(this.dataStart + (<usize>index << alignof<f64>()), value);\n  }\n\n  at(index: i32): f64 {\n    let len = this.byteLength >>> alignof<f64>();\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    return load<f64>(this.dataStart + (<usize>index << alignof<f64>()));\n  }\n\n  includes(searchElement: f64, fromIndex: i32 = 0): bool {\n    return INCLUDES<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  indexOf(searchElement: f64, fromIndex: i32 = 0): i32 {\n    return INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  lastIndexOf(searchElement: f64, fromIndex: i32 = this.length): i32 {\n    return LAST_INDEX_OF<Float64Array, f64>(this, searchElement, fromIndex);\n  }\n\n  fill(value: f64, start: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    FILL<f64>(this.dataStart, this.length, value, start, end);\n    return this;\n  }\n\n  sort(comparator: (a: f64, b: f64) => i32 = COMPARATOR<f64>()): Float64Array {\n    SORT<f64>(this.dataStart, this.length, comparator);\n    return this;\n  }\n\n  slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SLICE<Float64Array, f64>(this, begin, end);\n  }\n\n  subarray(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Float64Array {\n    return SUBARRAY<Float64Array, f64>(this, begin, end);\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Float64Array {\n    return COPY_WITHIN<Float64Array, f64>(this, target, start, end);\n  }\n\n  reduce<T extends number>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  reduceRight<T extends number>(\n    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,\n    initialValue: T,\n  ): T {\n    return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);\n  }\n\n  map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {\n    return MAP<Float64Array, f64>(this, fn);\n  }\n\n  filter(fn: (value: f64, index: i32, self: Float64Array) => bool): Float64Array {\n    return FILTER<Float64Array, f64>(this, fn);\n  }\n\n  findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  findLastIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {\n    return FIND_LAST_INDEX<Float64Array, f64>(this, fn);\n  }\n\n  some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return SOME<Float64Array, f64>(this, fn);\n  }\n\n  every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {\n    return EVERY<Float64Array, f64>(this, fn);\n  }\n\n  forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {\n    FOREACH<Float64Array, f64>(this, fn);\n  }\n\n  reverse(): Float64Array {\n    REVERSE<f64>(this.dataStart, this.length);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    return joinFloatArray<f64>(this.dataStart, this.length, separator);\n  }\n\n  set<U extends ArrayLike<number>>(source: U, offset: i32 = 0): void {\n    SET(this, source, offset);\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  static wrap(buffer: ArrayBuffer, byteOffset: i32 = 0, length: i32 = -1): Float64Array {\n    return WRAP<Float64Array, f64>(buffer, byteOffset, length);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SLICE<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  start: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  start  = start < 0 ? max(start + len, 0) : min(start, len);\n  end    = end   < 0 ? max(end   + len, 0) : min(end  , len);\n  len = max(end - start, 0);\n  let slice = instantiate<TArray>(len);\n  memory.copy(\n    slice.dataStart,\n    array.dataStart + (<usize>start << alignof<T>()),\n    <usize>len << alignof<T>()\n  );\n  return slice;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SUBARRAY<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  begin: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  begin = begin < 0 ? max(len + begin, 0) : min(begin, len);\n  end   = end   < 0 ? max(len + end,   0) : min(end,   len);\n  end   = max(end, begin);\n\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<usize>(array.buffer);\n  store<usize>(changetype<usize>(out), buf, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), buf, false);\n  store<usize>(changetype<usize>(out), array.dataStart + (<usize>begin << alignof<T>()), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), (end - begin) << alignof<T>(), offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction COPY_WITHIN<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  target: i32,\n  start: i32,\n  end: i32\n): TArray {\n  let len = array.length;\n  let ptr = array.dataStart;\n\n  end   = min<i32>(end, len);\n  let to    = target < 0 ? max(len + target, 0) : min(target, len);\n  let from  = start < 0 ? max(len + start, 0) : min(start, len);\n  let last  = end < 0 ? max(len + end, 0) : min(end, len);\n  let count = min(last - from, len - to);\n\n  memory.copy(\n    ptr + (<usize>to << alignof<T>()),\n    ptr + (<usize>from << alignof<T>()),\n    <usize>count << alignof<T>()\n  );\n  return array;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE<TArray extends ArrayBufferView, T extends number, TRet extends number>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    initialValue = fn(initialValue, load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction REDUCE_RIGHT<TArray extends ArrayBufferView, T extends number, TRet extends number>(\n  array: TArray,\n  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,\n  initialValue: TRet\n): TRet {\n  let ptr = array.dataStart;\n  for (let i = array.length - 1; i >= 0; i--) {\n    initialValue = fn(initialValue, load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n  return initialValue;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction MAP<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => T,\n): TArray {\n  let len = array.length;\n  let ptr = array.dataStart;\n\n  let byteLength = len << alignof<T>();\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<ArrayBuffer>(__new(byteLength, idof<ArrayBuffer>()));\n  for (let i = 0; i < len; i++) {\n    store<T>(\n      changetype<usize>(buf) + (<usize>i << alignof<T>()),\n      fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)\n    );\n  }\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buf), false);\n  store<usize>(changetype<usize>(out), changetype<usize>(buf), offsetof<TArray>(\"dataStart\"));\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FILTER<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, self: TArray) => bool,\n): TArray {\n  let len = array.length;\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  let buf = changetype<ArrayBuffer>(__new(len << alignof<T>(), idof<ArrayBuffer>()));\n  let dataStart  = array.dataStart;\n  let j: usize = 0;\n  for (let i = 0; i < len; i++) {\n    let value = load<T>(dataStart + (<usize>i << alignof<T>()));\n    if (fn(value, i, array)) {\n      store<T>(\n        changetype<usize>(buf) + (j++ << alignof<T>()),\n        value\n      );\n    }\n  }\n  // shrink output buffer\n  let byteLength = j << alignof<T>();\n  let data = __renew(changetype<usize>(buf), byteLength);\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), data, false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), data, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_INDEX<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FIND_LAST_INDEX<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): i32 {\n  let ptr = array.dataStart;\n  for (let i = array.length - 1; i >= 0; --i) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return i;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INCLUDES<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): bool {\n  if (isFloat<T>()) {\n    let index: isize = fromIndex;\n    let len: isize = array.length;\n    if (len == 0 || index >= len) return false;\n    if (index < 0) index = max(len + index, 0);\n    let dataStart = array.dataStart;\n    while (index < len) {\n      let elem = load<T>(dataStart + (index << alignof<T>()));\n      // @ts-ignore\n      if (elem == searchElement || isNaN(elem) & isNaN(searchElement)) return true;\n      ++index;\n    }\n    return false;\n  } else {\n    return INDEX_OF<TArray, T>(array, searchElement, fromIndex) >= 0;\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction INDEX_OF<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  let index: isize = fromIndex;\n  let len: isize = array.length;\n  if (len == 0 || index >= len) return -1;\n  if (index < 0) index = max(len + index, 0);\n  let dataStart = array.dataStart;\n  while (index < len) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    ++index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction LAST_INDEX_OF<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  searchElement: T,\n  fromIndex: i32,\n): i32 {\n  let index: isize = fromIndex;\n  let len: isize = array.length;\n  if (len == 0) return -1;\n  if (index < 0) index = len + index; // no need to clamp\n  else if (index >= len) index = len - 1;\n  let dataStart = array.dataStart;\n  while (index >= 0) {\n    if (load<T>(dataStart + (index << alignof<T>())) == searchElement) return <i32>index;\n    --index;\n  }\n  return -1;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SOME<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) return true;\n  }\n  return false;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction EVERY<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => bool,\n): bool {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    if (fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array)) continue;\n    return false;\n  }\n  return true;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction FOREACH<TArray extends ArrayBufferView, T extends number>(\n  array: TArray,\n  fn: (value: T, index: i32, array: TArray) => void,\n): void {\n  let ptr = array.dataStart;\n  for (let i = 0, k = array.length; i < k; i++) {\n    fn(load<T>(ptr + (<usize>i << alignof<T>())), i, array);\n  }\n}\n\n// @ts-ignore: decorator\n@inline\nfunction WRAP<TArray extends ArrayBufferView, T>(\n  buffer: ArrayBuffer,\n  byteOffset: i32 = 0,\n  len: i32 = -1\n): TArray {\n  let byteLength: i32;\n  let bufferByteLength = buffer.byteLength;\n  const mask: u32 = sizeof<T>() - 1;\n  if (i32(<u32>byteOffset > <u32>bufferByteLength) | (byteOffset & mask)) {\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  if (len < 0) {\n    if (len == -1) {\n      if (bufferByteLength & mask) {\n        throw new RangeError(E_INVALIDLENGTH);\n      }\n      byteLength = bufferByteLength - byteOffset;\n    } else {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  } else {\n    byteLength = len << alignof<T>();\n    if (byteOffset + byteLength > bufferByteLength) {\n      throw new RangeError(E_INVALIDLENGTH);\n    }\n  }\n  let out = changetype<TArray>(__new(offsetof<TArray>(), idof<TArray>()));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer), offsetof<TArray>(\"buffer\"));\n  __link(changetype<usize>(out), changetype<usize>(buffer), false);\n  store<u32>(changetype<usize>(out), byteLength, offsetof<TArray>(\"byteLength\"));\n  store<usize>(changetype<usize>(out), changetype<usize>(buffer) + <usize>byteOffset, offsetof<TArray>(\"dataStart\"));\n  return out;\n}\n\n// @ts-ignore: decorator\n@inline\nfunction SET<\n  TArray extends ArrayLike<number>,\n  UArray extends ArrayLike<number>\n>(\n  target: TArray,\n  source: UArray,\n  offset: i32 = 0\n): void {\n  // need to assert at compile time that U is not a reference or a function\n  if (isReference<valueof<UArray>>()) {\n    ERROR(E_NOTIMPLEMENTED);\n  }\n  let sourceLen = source.length;\n  if (offset < 0 || sourceLen + offset > target.length) {\n    // offset is out of bounds\n    throw new RangeError(E_INDEXOUTOFRANGE);\n  }\n  // @ts-ignore: dataStart\n  let targetStart = target.dataStart + (<usize>offset << (alignof<valueof<TArray>>()));\n  // @ts-ignore: dataStart\n  let sourceStart = source.dataStart;\n  // if the types align and match, use memory.copy() instead of manual loop\n  if (\n    isInteger<valueof<TArray>>() == isInteger<valueof<UArray>>() &&\n    alignof<valueof<TArray>>() == alignof<valueof<UArray>>() &&\n    !(isSigned<valueof<UArray>>() && target instanceof Uint8ClampedArray)\n  ) {\n    memory.copy(targetStart, sourceStart, <usize>sourceLen << (alignof<valueof<UArray>>()));\n  } else {\n    for (let i = 0; i < sourceLen; i++) {\n      let ptr = targetStart + (<usize>i << (alignof<valueof<TArray>>()));\n      let value = load<valueof<UArray>>(sourceStart + (<usize>i << (alignof<valueof<UArray>>())));\n      // if TArray is Uint8ClampedArray, then values must be clamped\n      if (target instanceof Uint8ClampedArray) {\n        if (isFloat<valueof<UArray>>()) {\n          store<valueof<TArray>>(ptr,\n            isFinite<valueof<UArray>>(value)\n              ? <valueof<TArray>>max<valueof<UArray>>(0, min<valueof<UArray>>(255, value))\n              : 0\n          );\n        } else {\n          if (!isSigned<valueof<UArray>>()) {\n            store<valueof<TArray>>(ptr, min<valueof<UArray>>(255, value));\n          } else if (sizeof<valueof<TArray>>() <= 4) {\n            store<valueof<TArray>>(ptr, ~(<i32>value >> 31) & (((255 - <i32>value) >> 31) | value));\n          } else {\n            store<valueof<TArray>>(ptr, ~(<i64>value >> 63) & (((255 - <i64>value) >> 63) | value));\n          }\n        }\n      } else {\n        if (isFloat<valueof<UArray>>() && !isFloat<valueof<TArray>>()) {\n          store<valueof<TArray>>(ptr, isFinite<valueof<UArray>>(value) ? <valueof<TArray>>value : 0);\n        } else {\n          store<valueof<TArray>>(ptr, <valueof<TArray>>value);\n        }\n      }\n    }\n  }\n}\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { OBJECT, BLOCK_MAXSIZE, TOTAL_OVERHEAD } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { idof } from \"./builtins\";\nimport { E_INVALIDLENGTH } from \"./util/error\";\n\nexport abstract class ArrayBufferView {\n\n  readonly buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  readonly byteLength: i32;\n\n  get byteOffset(): i32 {\n    return <i32>(this.dataStart - changetype<usize>(this.buffer));\n  }\n\n  protected constructor(length: i32, alignLog2: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    let buffer = changetype<ArrayBuffer>(__new(length = length << alignLog2, idof<ArrayBuffer>()));\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    }\n    this.buffer = buffer; // links\n    this.dataStart = changetype<usize>(buffer);\n    this.byteLength = length;\n  }\n}\n\n@final export class ArrayBuffer {\n\n  static isView<T>(value: T): bool {\n    if (isNullable<T>()) {\n      if (changetype<usize>(value) == 0) return false;\n    }\n    if (value instanceof Int8Array) return true;\n    if (value instanceof Uint8Array) return true;\n    if (value instanceof Uint8ClampedArray) return true;\n    if (value instanceof Int16Array) return true;\n    if (value instanceof Uint16Array) return true;\n    if (value instanceof Int32Array) return true;\n    if (value instanceof Uint32Array) return true;\n    if (value instanceof Int64Array) return true;\n    if (value instanceof Uint64Array) return true;\n    if (value instanceof Float32Array) return true;\n    if (value instanceof Float64Array) return true;\n    if (value instanceof DataView) return true;\n    return false;\n  }\n\n  constructor(length: i32) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);\n    let buffer = changetype<ArrayBuffer>(__new(<usize>length, idof<ArrayBuffer>()));\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(changetype<usize>(buffer), 0, <usize>length);\n    }\n    return buffer;\n  }\n\n  get byteLength(): i32 {\n    return changetype<OBJECT>(changetype<usize>(this) - TOTAL_OVERHEAD).rtSize;\n  }\n\n  slice(begin: i32 = 0, end: i32 = BLOCK_MAXSIZE): ArrayBuffer {\n    let length = this.byteLength;\n    begin = begin < 0 ? max(length + begin, 0) : min(begin, length);\n    end   = end   < 0 ? max(length + end  , 0) : min(end  , length);\n    let outSize = <usize>max(end - begin, 0);\n    let out = changetype<ArrayBuffer>(__new(outSize, idof<ArrayBuffer>()));\n    memory.copy(changetype<usize>(out), changetype<usize>(this) + <usize>begin, outSize);\n    return out;\n  }\n\n  toString(): string {\n    return \"[object ArrayBuffer]\";\n  }\n}\n","/**\r\n * Matrix Operations for AssemblyScript\r\n *\r\n * Dense matrix operations using flat Float64Array storage.\r\n * Row-major order: element at (i,j) is at index i*cols + j\r\n *\r\n * Note: AssemblyScript doesn't support classes with complex patterns,\r\n * so we use pure functions with explicit dimensions.\r\n */\r\n\r\n// =============================================================================\r\n// Matrix Creation\r\n// =============================================================================\r\n\r\n/**\r\n * Create a matrix filled with zeros\r\n */\r\nexport function matrix_zeros(rows: i32, cols: i32): Float64Array {\r\n  return new Float64Array(rows * cols);\r\n}\r\n\r\n/**\r\n * Create a matrix filled with ones\r\n */\r\nexport function matrix_ones(rows: i32, cols: i32): Float64Array {\r\n  const data = new Float64Array(rows * cols);\r\n  const len = rows * cols;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((data[i] = 1.0));\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create a matrix filled with a specific value\r\n */\r\nexport function matrix_fill(rows: i32, cols: i32, value: f64): Float64Array {\r\n  const data = new Float64Array(rows * cols);\r\n  const len = rows * cols;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((data[i] = value));\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create an identity matrix\r\n */\r\nexport function matrix_identity(n: i32): Float64Array {\r\n  const data = new Float64Array(n * n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((data[i * n + i] = 1.0));\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create a diagonal matrix from array of values\r\n */\r\nexport function matrix_diag(values: Float64Array): Float64Array {\r\n  const n = values.length;\r\n  const data = new Float64Array(n * n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((data[i * n + i] = unchecked(values[i])));\r\n  }\r\n  return data;\r\n}\r\n\r\n// =============================================================================\r\n// Element Access\r\n// =============================================================================\r\n\r\n/**\r\n * Get element at (row, col)\r\n */\r\nexport function matrix_get(data: Float64Array, cols: i32, row: i32, col: i32): f64 {\r\n  return unchecked(data[row * cols + col]);\r\n}\r\n\r\n/**\r\n * Set element at (row, col)\r\n */\r\nexport function matrix_set(data: Float64Array, cols: i32, row: i32, col: i32, value: f64): void {\r\n  unchecked((data[row * cols + col] = value));\r\n}\r\n\r\n/**\r\n * Get a row as a new array\r\n */\r\nexport function matrix_get_row(data: Float64Array, cols: i32, row: i32): Float64Array {\r\n  const result = new Float64Array(cols);\r\n  const offset = row * cols;\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked((result[j] = unchecked(data[offset + j])));\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Get a column as a new array\r\n */\r\nexport function matrix_get_col(data: Float64Array, rows: i32, cols: i32, col: i32): Float64Array {\r\n  const result = new Float64Array(rows);\r\n  for (let i = 0; i < rows; i++) {\r\n    unchecked((result[i] = unchecked(data[i * cols + col])));\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * Get diagonal elements\r\n */\r\nexport function matrix_get_diag(data: Float64Array, rows: i32, cols: i32): Float64Array {\r\n  const n = min(rows, cols);\r\n  const result = new Float64Array(n);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((result[i] = unchecked(data[i * cols + i])));\r\n  }\r\n  return result;\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Matrix addition: C = A + B\r\n */\r\nexport function matrix_add(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Matrix subtraction: C = A - B\r\n */\r\nexport function matrix_sub(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) - unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise multiplication (Hadamard product): C = A .* B\r\n */\r\nexport function matrix_mul_elementwise(\r\n  a: Float64Array,\r\n  b: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) * unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise division: C = A ./ B\r\n */\r\nexport function matrix_div_elementwise(\r\n  a: Float64Array,\r\n  b: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) / unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Scalar multiplication: C = A * scalar\r\n */\r\nexport function matrix_scale(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Scalar addition: C = A + scalar\r\n */\r\nexport function matrix_add_scalar(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) + scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Negate matrix: C = -A\r\n */\r\nexport function matrix_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = -unchecked(a[i])));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Multiplication\r\n// =============================================================================\r\n\r\n/**\r\n * Matrix multiplication: C = A * B\r\n * A is (aRows x aCols), B is (aCols x bCols), C is (aRows x bCols)\r\n *\r\n * Uses naive O(n^3) algorithm - suitable for SIMD optimization\r\n */\r\nexport function matrix_multiply(\r\n  a: Float64Array,\r\n  aRows: i32,\r\n  aCols: i32,\r\n  b: Float64Array,\r\n  bCols: i32,\r\n  result: Float64Array\r\n): void {\r\n  // Clear result\r\n  const resultLen = aRows * bCols;\r\n  for (let i = 0; i < resultLen; i++) {\r\n    unchecked((result[i] = 0.0));\r\n  }\r\n\r\n  // Naive matmul with good cache access pattern\r\n  for (let i = 0; i < aRows; i++) {\r\n    for (let k = 0; k < aCols; k++) {\r\n      const aik = unchecked(a[i * aCols + k]);\r\n      for (let j = 0; j < bCols; j++) {\r\n        unchecked((result[i * bCols + j] += aik * unchecked(b[k * bCols + j])));\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Matrix-vector multiplication: y = A * x\r\n * A is (rows x cols), x is (cols), y is (rows)\r\n */\r\nexport function matrix_vector_multiply(\r\n  a: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  x: Float64Array,\r\n  result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    let sum: f64 = 0.0;\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      sum += unchecked(a[offset + j]) * unchecked(x[j]);\r\n    }\r\n    unchecked((result[i] = sum));\r\n  }\r\n}\r\n\r\n/**\r\n * Vector-matrix multiplication: y = x^T * A\r\n * x is (rows), A is (rows x cols), y is (cols)\r\n */\r\nexport function vector_matrix_multiply(\r\n  x: Float64Array,\r\n  a: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  result: Float64Array\r\n): void {\r\n  // Clear result\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked((result[j] = 0.0));\r\n  }\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    const xi = unchecked(x[i]);\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked((result[j] += xi * unchecked(a[offset + j])));\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Outer product: C = x * y^T\r\n * x is (m), y is (n), C is (m x n)\r\n */\r\nexport function matrix_outer(x: Float64Array, y: Float64Array, result: Float64Array): void {\r\n  const m = x.length;\r\n  const n = y.length;\r\n  for (let i = 0; i < m; i++) {\r\n    const xi = unchecked(x[i]);\r\n    const offset = i * n;\r\n    for (let j = 0; j < n; j++) {\r\n      unchecked((result[offset + j] = xi * unchecked(y[j])));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Transpose\r\n// =============================================================================\r\n\r\n/**\r\n * Transpose matrix: B = A^T\r\n * A is (rows x cols), B is (cols x rows)\r\n */\r\nexport function matrix_transpose(\r\n  a: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked((result[j * rows + i] = unchecked(a[i * cols + j])));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Reductions\r\n// =============================================================================\r\n\r\n/**\r\n * Sum of all elements\r\n */\r\nexport function matrix_sum(data: Float64Array): f64 {\r\n  let sum: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    sum += unchecked(data[i]);\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * Mean of all elements\r\n */\r\nexport function matrix_mean(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n  return matrix_sum(data) / f64(len);\r\n}\r\n\r\n/**\r\n * Minimum element\r\n */\r\nexport function matrix_min(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let minVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val < minVal) minVal = val;\r\n  }\r\n  return minVal;\r\n}\r\n\r\n/**\r\n * Maximum element\r\n */\r\nexport function matrix_max(data: Float64Array): f64 {\r\n  const len = data.length;\r\n  if (len == 0) return f64.NaN;\r\n\r\n  let maxVal = unchecked(data[0]);\r\n  for (let i = 1; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    if (val > maxVal) maxVal = val;\r\n  }\r\n  return maxVal;\r\n}\r\n\r\n/**\r\n * Frobenius norm (sqrt of sum of squares)\r\n */\r\nexport function matrix_norm_frobenius(data: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    const val = unchecked(data[i]);\r\n    sumSq += val * val;\r\n  }\r\n  return sqrt(sumSq);\r\n}\r\n\r\n/**\r\n * Trace (sum of diagonal elements)\r\n */\r\nexport function matrix_trace(data: Float64Array, rows: i32, cols: i32): f64 {\r\n  const n = min(rows, cols);\r\n  let sum: f64 = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    sum += unchecked(data[i * cols + i]);\r\n  }\r\n  return sum;\r\n}\r\n\r\n/**\r\n * Sum along rows (result is column vector)\r\n */\r\nexport function matrix_sum_rows(\r\n  data: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  result: Float64Array\r\n): void {\r\n  for (let i = 0; i < rows; i++) {\r\n    let sum: f64 = 0.0;\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      sum += unchecked(data[offset + j]);\r\n    }\r\n    unchecked((result[i] = sum));\r\n  }\r\n}\r\n\r\n/**\r\n * Sum along columns (result is row vector)\r\n */\r\nexport function matrix_sum_cols(\r\n  data: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  result: Float64Array\r\n): void {\r\n  // Clear result\r\n  for (let j = 0; j < cols; j++) {\r\n    unchecked((result[j] = 0.0));\r\n  }\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    const offset = i * cols;\r\n    for (let j = 0; j < cols; j++) {\r\n      unchecked((result[j] += unchecked(data[offset + j])));\r\n    }\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Matrix Queries\r\n// =============================================================================\r\n\r\n/**\r\n * Check if matrix is square\r\n */\r\nexport function matrix_is_square(rows: i32, cols: i32): bool {\r\n  return rows == cols;\r\n}\r\n\r\n/**\r\n * Check if matrix is symmetric (within tolerance)\r\n */\r\nexport function matrix_is_symmetric(\r\n  data: Float64Array,\r\n  rows: i32,\r\n  cols: i32,\r\n  tolerance: f64\r\n): bool {\r\n  if (rows != cols) return false;\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = i + 1; j < cols; j++) {\r\n      const aij = unchecked(data[i * cols + j]);\r\n      const aji = unchecked(data[j * cols + i]);\r\n      if (abs(aij - aji) > tolerance) return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Check if matrix is diagonal (within tolerance)\r\n */\r\nexport function matrix_is_diagonal(data: Float64Array, rows: i32, cols: i32, tolerance: f64): bool {\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      if (i != j) {\r\n        if (abs(unchecked(data[i * cols + j])) > tolerance) return false;\r\n      }\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Check if matrix equals identity (within tolerance)\r\n */\r\nexport function matrix_is_identity(data: Float64Array, rows: i32, cols: i32, tolerance: f64): bool {\r\n  if (rows != cols) return false;\r\n\r\n  for (let i = 0; i < rows; i++) {\r\n    for (let j = 0; j < cols; j++) {\r\n      const expected: f64 = i == j ? 1.0 : 0.0;\r\n      if (abs(unchecked(data[i * cols + j]) - expected) > tolerance) return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Scale matrix in place: A *= scalar\r\n */\r\nexport function matrix_scale_inplace(data: Float64Array, scalar: f64): void {\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((data[i] = unchecked(data[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Add scalar in place: A += scalar\r\n */\r\nexport function matrix_add_scalar_inplace(data: Float64Array, scalar: f64): void {\r\n  const len = data.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((data[i] = unchecked(data[i]) + scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Add matrix in place: A += B\r\n */\r\nexport function matrix_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Copy matrix: dst = src\r\n */\r\nexport function matrix_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((dst[i] = unchecked(src[i])));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Basics\r\n// =============================================================================\r\n\r\n/**\r\n * AXPY operation: Y = alpha*X + Y (BLAS Level 1)\r\n */\r\nexport function matrix_axpy(alpha: f64, x: Float64Array, y: Float64Array): void {\r\n  const len = min(x.length, y.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((y[i] = alpha * unchecked(x[i]) + unchecked(y[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * GEMM: C = alpha*A*B + beta*C (General Matrix Multiply)\r\n * A is (m x k), B is (k x n), C is (m x n)\r\n */\r\nexport function matrix_gemm(\r\n  alpha: f64,\r\n  a: Float64Array,\r\n  m: i32,\r\n  k: i32,\r\n  b: Float64Array,\r\n  n: i32,\r\n  beta: f64,\r\n  c: Float64Array\r\n): void {\r\n  // Scale C by beta\r\n  const cLen = m * n;\r\n  for (let i = 0; i < cLen; i++) {\r\n    unchecked((c[i] = beta * unchecked(c[i])));\r\n  }\r\n\r\n  // Add alpha * A * B\r\n  for (let i = 0; i < m; i++) {\r\n    for (let p = 0; p < k; p++) {\r\n      const aip = alpha * unchecked(a[i * k + p]);\r\n      for (let j = 0; j < n; j++) {\r\n        unchecked((c[i * n + j] += aip * unchecked(b[p * n + j])));\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * GEMV: y = alpha*A*x + beta*y (General Matrix-Vector Multiply)\r\n * A is (m x n), x is (n), y is (m)\r\n */\r\nexport function matrix_gemv(\r\n  alpha: f64,\r\n  a: Float64Array,\r\n  m: i32,\r\n  n: i32,\r\n  x: Float64Array,\r\n  beta: f64,\r\n  y: Float64Array\r\n): void {\r\n  for (let i = 0; i < m; i++) {\r\n    let dot: f64 = 0.0;\r\n    const offset = i * n;\r\n    for (let j = 0; j < n; j++) {\r\n      dot += unchecked(a[offset + j]) * unchecked(x[j]);\r\n    }\r\n    unchecked((y[i] = alpha * dot + beta * unchecked(y[i])));\r\n  }\r\n}\r\n","/**\r\n * Polynomial algebra — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../algebra/polynomial_ext.rs`.\r\n *\r\n * Polynomials are coefficient arrays, constant term first (`index = power`).\r\n * Functions take and return `Float64Array`; `discriminant` / `resultant`\r\n * return a scalar.\r\n */\r\n\r\nfunction toArr(fa: Float64Array): Array<f64> {\r\n  const out = new Array<f64>(fa.length);\r\n  for (let i = 0; i < fa.length; i++) out[i] = fa[i];\r\n  return out;\r\n}\r\n\r\nfunction toF64(a: Array<f64>): Float64Array {\r\n  const out = new Float64Array(a.length);\r\n  for (let i = 0; i < a.length; i++) out[i] = a[i];\r\n  return out;\r\n}\r\n\r\nfunction single(v: f64): Array<f64> {\r\n  const a = new Array<f64>(1);\r\n  a[0] = v;\r\n  return a;\r\n}\r\n\r\n/** Trim trailing zero coefficients, keeping at least one. */\r\nfunction trim(c: Array<f64>): Array<f64> {\r\n  if (c.length == 0) return single(0.0);\r\n  let end: i32 = c.length - 1;\r\n  while (end > 0 && c[end] == 0.0) end--;\r\n  return c.slice(0, end + 1);\r\n}\r\n\r\n/** Polynomial long division — returns [quotient, remainder], trimmed. */\r\nfunction polyDivmod(a: Array<f64>, b: Array<f64>): Array<Array<f64>> {\r\n  const at = trim(a);\r\n  const bt = trim(b);\r\n  const res = new Array<Array<f64>>(2);\r\n  if (bt.length == 1 && bt[0] == 0.0) {\r\n    res[0] = single(NaN);\r\n    res[1] = single(NaN);\r\n    return res;\r\n  }\r\n  if (at.length < bt.length) {\r\n    res[0] = single(0.0);\r\n    res[1] = at;\r\n    return res;\r\n  }\r\n  const remainder = at.slice(0, at.length);\r\n  const qLen: i32 = at.length - bt.length + 1;\r\n  const quotient = new Array<f64>(qLen);\r\n  for (let x = 0; x < qLen; x++) quotient[x] = 0.0;\r\n  const bl: i32 = bt.length;\r\n  let i: i32 = qLen;\r\n  while (i > 0) {\r\n    i--;\r\n    quotient[i] = remainder[i + bl - 1] / bt[bl - 1];\r\n    for (let j = 0; j < bl; j++) {\r\n      remainder[i + j] -= quotient[i] * bt[j];\r\n    }\r\n  }\r\n  res[0] = trim(quotient);\r\n  res[1] = bl >= 2 ? trim(remainder.slice(0, bl - 1)) : single(0.0);\r\n  return res;\r\n}\r\n\r\nfunction polyMul(a: Array<f64>, b: Array<f64>): Array<f64> {\r\n  if (a.length == 0 || b.length == 0) return single(0.0);\r\n  const out = new Array<f64>(a.length + b.length - 1);\r\n  for (let x = 0; x < out.length; x++) out[x] = 0.0;\r\n  for (let i = 0; i < a.length; i++) {\r\n    for (let j = 0; j < b.length; j++) {\r\n      out[i + j] += a[i] * b[j];\r\n    }\r\n  }\r\n  return trim(out);\r\n}\r\n\r\nfunction polyDerivative(c: Array<f64>): Array<f64> {\r\n  if (c.length <= 1) return single(0.0);\r\n  const out = new Array<f64>(c.length - 1);\r\n  for (let i = 1; i < c.length; i++) out[i - 1] = c[i] * <f64>i;\r\n  return out;\r\n}\r\n\r\nfunction determinant(m: Array<f64>, n: i32): f64 {\r\n  let det: f64 = 1.0;\r\n  for (let col = 0; col < n; col++) {\r\n    let maxRow = col;\r\n    let maxVal = Math.abs(m[col * n + col]);\r\n    for (let row = col + 1; row < n; row++) {\r\n      const v = Math.abs(m[row * n + col]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        maxRow = row;\r\n      }\r\n    }\r\n    if (maxVal < 1e-15) return 0.0;\r\n    if (maxRow != col) {\r\n      for (let k = 0; k < n; k++) {\r\n        const t = m[col * n + k];\r\n        m[col * n + k] = m[maxRow * n + k];\r\n        m[maxRow * n + k] = t;\r\n      }\r\n      det = -det;\r\n    }\r\n    det *= m[col * n + col];\r\n    for (let row = col + 1; row < n; row++) {\r\n      const factor = m[row * n + col] / m[col * n + col];\r\n      for (let k = col; k < n; k++) {\r\n        m[row * n + k] -= factor * m[col * n + k];\r\n      }\r\n    }\r\n  }\r\n  return det;\r\n}\r\n\r\nfunction makeMonic(p: Array<f64>): Array<f64> {\r\n  const leading = p[p.length - 1];\r\n  if (leading != 0.0 && leading != 1.0) {\r\n    const out = new Array<f64>(p.length);\r\n    for (let i = 0; i < p.length; i++) out[i] = p[i] / leading;\r\n    return out;\r\n  }\r\n  return p;\r\n}\r\n\r\nfunction polyGcd(a: Array<f64>, b: Array<f64>): Array<f64> {\r\n  let r0 = trim(a);\r\n  let r1 = trim(b);\r\n  while (r1.length > 1 || r1[0] != 0.0) {\r\n    const dm = polyDivmod(r0, r1);\r\n    r0 = r1;\r\n    r1 = dm[1];\r\n  }\r\n  return makeMonic(r0);\r\n}\r\n\r\nfunction resultantValue(p: Array<f64>, q: Array<f64>): f64 {\r\n  const pt = trim(p);\r\n  const qt = trim(q);\r\n  const m: i32 = pt.length - 1;\r\n  const n: i32 = qt.length - 1;\r\n  if (m == 0 && n == 0) return 1.0;\r\n  if (m == 0) return Math.pow(pt[0], <f64>n);\r\n  if (n == 0) return Math.pow(qt[0], <f64>m);\r\n  const size: i32 = m + n;\r\n  const mat = new Array<f64>(size * size);\r\n  for (let x = 0; x < size * size; x++) mat[x] = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    for (let j = 0; j <= m; j++) mat[i * size + (i + j)] = pt[m - j];\r\n  }\r\n  for (let i = 0; i < m; i++) {\r\n    for (let j = 0; j <= n; j++) mat[(n + i) * size + (i + j)] = qt[n - j];\r\n  }\r\n  return determinant(mat, size);\r\n}\r\n\r\n// --- Exports ----------------------------------------------------------------\r\n\r\n/** Add polynomials `a + b`. */\r\nexport function polyadd(a: Float64Array, b: Float64Array): Float64Array {\r\n  const aa = toArr(a);\r\n  const bb = toArr(b);\r\n  const len: i32 = aa.length > bb.length ? aa.length : bb.length;\r\n  const sum = new Array<f64>(len < 1 ? 1 : len);\r\n  for (let x = 0; x < sum.length; x++) sum[x] = 0.0;\r\n  for (let i = 0; i < len; i++) {\r\n    const av = i < aa.length ? aa[i] : 0.0;\r\n    const bv = i < bb.length ? bb[i] : 0.0;\r\n    sum[i] = av + bv;\r\n  }\r\n  return toF64(trim(sum));\r\n}\r\n\r\n/** Quotient of polynomial division `a / b`. */\r\nexport function polynomialQuotient(a: Float64Array, b: Float64Array): Float64Array {\r\n  return toF64(polyDivmod(toArr(a), toArr(b))[0]);\r\n}\r\n\r\n/** Remainder of polynomial division `a / b`. */\r\nexport function polynomialRemainder(a: Float64Array, b: Float64Array): Float64Array {\r\n  return toF64(polyDivmod(toArr(a), toArr(b))[1]);\r\n}\r\n\r\n/** Monic GCD of polynomials `a` and `b`. */\r\nexport function polynomialGCD(a: Float64Array, b: Float64Array): Float64Array {\r\n  return toF64(polyGcd(toArr(a), toArr(b)));\r\n}\r\n\r\n/** Monic LCM of polynomials `a` and `b`. */\r\nexport function polynomialLCM(a: Float64Array, b: Float64Array): Float64Array {\r\n  const aa = toArr(a);\r\n  const bb = toArr(b);\r\n  const g = polyGcd(aa, bb);\r\n  const dm = polyDivmod(polyMul(aa, bb), g);\r\n  return toF64(makeMonic(dm[0]));\r\n}\r\n\r\n/** Discriminant of a polynomial of degree >= 1. */\r\nexport function discriminant(coeffs: Float64Array): f64 {\r\n  const t = trim(toArr(coeffs));\r\n  const deg: i32 = t.length - 1;\r\n  if (deg < 1) return NaN;\r\n  if (deg == 1) return 1.0;\r\n  if (deg == 2) {\r\n    return t[1] * t[1] - 4.0 * t[2] * t[0];\r\n  }\r\n  if (deg == 3) {\r\n    const d = t[0];\r\n    const c = t[1];\r\n    const b = t[2];\r\n    const a = t[3];\r\n    return (\r\n      18.0 * a * b * c * d -\r\n      4.0 * b * b * b * d +\r\n      b * b * c * c -\r\n      4.0 * a * c * c * c -\r\n      27.0 * a * a * d * d\r\n    );\r\n  }\r\n  const fp = polyDerivative(t);\r\n  const res = resultantValue(t, fp);\r\n  const an = t[t.length - 1];\r\n  const sign: f64 = ((deg * (deg - 1)) / 2) % 2 == 0 ? 1.0 : -1.0;\r\n  return (sign * res) / an;\r\n}\r\n\r\n/** Resultant of two polynomials (Sylvester-matrix determinant). */\r\nexport function resultant(p: Float64Array, q: Float64Array): f64 {\r\n  return resultantValue(toArr(p), toArr(q));\r\n}\r\n","/// <reference path=\"./rt/index.d.ts\" />\n\nimport { BLOCK_MAXSIZE } from \"./rt/common\";\nimport { Runtime } from \"shared/runtime\";\nimport { COMPARATOR, SORT } from \"./util/sort\";\nimport { REVERSE, FILL } from \"./util/bytes\";\nimport { joinBooleanArray, joinIntegerArray, joinFloatArray, joinStringArray, joinReferenceArray } from \"./util/string\";\nimport { idof, isArray as builtin_isArray } from \"./builtins\";\nimport { E_INDEXOUTOFRANGE, E_INVALIDLENGTH, E_EMPTYARRAY, E_HOLEYARRAY } from \"./util/error\";\n\n// @ts-ignore: decorator\n@inline @lazy const MIN_SIZE: usize = 8;\n\n/** Ensures that the given array has _at least_ the specified backing size. */\nfunction ensureCapacity(array: usize, newSize: usize, alignLog2: u32, canGrow: bool = true): void {\n  // Depends on the fact that Arrays mimic ArrayBufferView\n  let oldCapacity = <usize>changetype<ArrayBufferView>(array).byteLength;\n  if (newSize > oldCapacity >>> alignLog2) {\n    if (newSize > BLOCK_MAXSIZE >>> alignLog2) throw new RangeError(E_INVALIDLENGTH);\n    let oldData = changetype<usize>(changetype<ArrayBufferView>(array).buffer);\n    // Grows old capacity by factor of two.\n    // Make sure we don't reach BLOCK_MAXSIZE for new growed capacity.\n    let newCapacity = max(newSize, MIN_SIZE) << alignLog2;\n    if (canGrow) newCapacity = max(min(oldCapacity << 1, BLOCK_MAXSIZE), newCapacity);\n    let newData = __renew(oldData, newCapacity);\n    // __new / __renew already init memory range as zeros in Incremental runtime.\n    // So try to avoid this.\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(newData + oldCapacity, 0, newCapacity - oldCapacity);\n    }\n    if (newData != oldData) { // oldData has been free'd\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"buffer\"));\n      store<usize>(array, newData, offsetof<ArrayBufferView>(\"dataStart\"));\n      __link(array, changetype<usize>(newData), false);\n    }\n    store<u32>(array, <u32>newCapacity, offsetof<ArrayBufferView>(\"byteLength\"));\n  }\n}\n\nexport class Array<T> {\n  [key: number]: T;\n\n  // Mimicking ArrayBufferView isn't strictly necessary here but is done to allow glue code\n  // to work with typed and normal arrays interchangeably. Technically, normal arrays do not need\n  // `dataStart` (equals `buffer`) and `byteLength` (equals computed `buffer.byteLength`), but the\n  // block is 16 bytes anyway so it's fine to have a couple extra fields in there.\n\n  private buffer: ArrayBuffer;\n  @unsafe readonly dataStart: usize;\n  private byteLength: i32; // Uses here as capacity\n\n  // Also note that Array<T> with non-nullable T must guard against uninitialized null values\n  // whenever an element is accessed. Otherwise, the compiler wouldn't be able to guarantee\n  // type-safety anymore. For lack of a better word, such an array is \"holey\".\n\n  private length_: i32;\n\n  static isArray<U>(value: U): bool {\n    return isReference<U>() ? changetype<usize>(value) != 0 && builtin_isArray(value) : false;\n  }\n\n  static create<T>(capacity: i32 = 0): Array<T> {\n    WARNING(\"'Array.create' is deprecated. Use 'new Array' instead, making sure initial elements are initialized.\");\n    let array = new Array<T>(capacity);\n    array.length = 0;\n    return array;\n  }\n\n  constructor(length: i32 = 0) {\n    if (<u32>length > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new RangeError(E_INVALIDLENGTH);\n    // reserve capacity for at least MIN_SIZE elements\n    let bufferSize = max(<usize>length, MIN_SIZE) << alignof<T>();\n    let buffer = changetype<ArrayBuffer>(__new(bufferSize, idof<ArrayBuffer>()));\n    if (ASC_RUNTIME != Runtime.Incremental) {\n      memory.fill(changetype<usize>(buffer), 0, bufferSize);\n    }\n    this.buffer = buffer; // links\n    this.dataStart = changetype<usize>(buffer);\n    this.byteLength = <i32>bufferSize;\n    this.length_ = length;\n  }\n\n  get length(): i32 {\n    return this.length_;\n  }\n\n  set length(newLength: i32) {\n    ensureCapacity(changetype<usize>(this), newLength, alignof<T>(), false);\n    this.length_ = newLength;\n  }\n\n  every(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      if (!fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this)) return false;\n    }\n    return true;\n  }\n\n  findIndex(fn: (value: T, index: i32, array: Array<T>) => bool): i32 {\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      if (fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this)) return i;\n    }\n    return -1;\n  }\n\n  findLastIndex(fn: (value: T, index: i32, array: Array<T>) => bool): i32 {\n    for (let i = this.length_ - 1; i >= 0; --i) {\n      if (fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this)) return i;\n    }\n    return -1;\n  }\n\n  @operator(\"[]\") private __get(index: i32): T {\n    if (<u32>index >= <u32>this.length_) throw new RangeError(E_INDEXOUTOFRANGE);\n    let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n    if (isReference<T>()) {\n      if (!isNullable<T>()) {\n        if (!changetype<usize>(value)) throw new Error(E_HOLEYARRAY);\n      }\n    }\n    return value;\n  }\n\n  @unsafe @operator(\"{}\") private __uget(index: i32): T {\n    return load<T>(this.dataStart + (<usize>index << alignof<T>()));\n  }\n\n  @operator(\"[]=\") private __set(index: i32, value: T): void {\n    if (<u32>index >= <u32>this.length_) {\n      if (index < 0) throw new RangeError(E_INDEXOUTOFRANGE);\n      ensureCapacity(changetype<usize>(this), index + 1, alignof<T>());\n      this.length_ = index + 1;\n    }\n    store<T>(this.dataStart + (<usize>index << alignof<T>()), value);\n    if (isManaged<T>()) {\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    }\n  }\n\n  at(index: i32): T {\n    let len = this.length_;\n    index += select(0, len, index >= 0);\n    if (<u32>index >= <u32>len) throw new RangeError(E_INDEXOUTOFRANGE);\n    let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));\n    if (isReference<T>()) {\n      if (!isNullable<T>()) {\n        if (!changetype<usize>(value)) throw new Error(E_HOLEYARRAY);\n      }\n    }\n    return value;\n  }\n\n  fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {\n    if (isManaged<T>()) {\n      FILL<usize>(this.dataStart, this.length_, changetype<usize>(value), start, end);\n      __link(changetype<usize>(this), changetype<usize>(value), false);\n    } else {\n      FILL<T>(this.dataStart, this.length_, value, start, end);\n    }\n    return this;\n  }\n\n  includes(value: T, fromIndex: i32 = 0): bool {\n    if (isFloat<T>()) {\n      let len = this.length_;\n      if (len == 0 || fromIndex >= len) return false;\n      if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n      let ptr = this.dataStart;\n      while (fromIndex < len) {\n        let elem = load<T>(ptr + (<usize>fromIndex << alignof<T>()));\n        // @ts-ignore\n        if (elem == value || isNaN(elem) & isNaN(value)) return true;\n        ++fromIndex;\n      }\n      return false;\n    } else {\n      return this.indexOf(value, fromIndex) >= 0;\n    }\n  }\n\n  indexOf(value: T, fromIndex: i32 = 0): i32 {\n    let len = this.length_;\n    if (len == 0 || fromIndex >= len) return -1;\n    if (fromIndex < 0) fromIndex = max(len + fromIndex, 0);\n    let ptr = this.dataStart;\n    while (fromIndex < len) {\n      if (load<T>(ptr + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      ++fromIndex;\n    }\n    return -1;\n  }\n\n  lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {\n    let len = this.length_;\n    if (len == 0) return -1;\n    if (fromIndex < 0) fromIndex = len + fromIndex;\n    else if (fromIndex >= len) fromIndex = len - 1;\n    let ptr = this.dataStart;\n    while (fromIndex >= 0) {\n      if (load<T>(ptr + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;\n      --fromIndex;\n    }\n    return -1;\n  }\n\n  push(value: T): i32 {\n    let oldLen = this.length_;\n    let len = oldLen + 1;\n    ensureCapacity(changetype<usize>(this), len, alignof<T>());\n    if (isManaged<T>()) {\n      store<usize>(this.dataStart + (<usize>oldLen << alignof<T>()), changetype<usize>(value));\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    } else {\n      store<T>(this.dataStart + (<usize>oldLen << alignof<T>()), value);\n    }\n    this.length_ = len;\n    return len;\n  }\n\n  concat(other: Array<T>): Array<T> {\n    let thisLen = this.length_;\n    let otherLen = other.length_;\n    let outLen = thisLen + otherLen;\n    if (<u32>outLen > <u32>BLOCK_MAXSIZE >>> alignof<T>()) throw new Error(E_INVALIDLENGTH);\n    let out = changetype<Array<T>>(__newArray(outLen, alignof<T>(), idof<Array<T>>()));\n    let outStart = out.dataStart;\n    let thisSize = <usize>thisLen << alignof<T>();\n    if (isManaged<T>()) {\n      let thisStart = this.dataStart;\n      for (let offset: usize = 0; offset < thisSize; offset += sizeof<T>()) {\n        let ref = load<usize>(thisStart + offset);\n        store<usize>(outStart + offset, ref);\n        __link(changetype<usize>(out), ref, true);\n      }\n      outStart += thisSize;\n      let otherStart = other.dataStart;\n      let otherSize = <usize>otherLen << alignof<T>();\n      for (let offset: usize = 0; offset < otherSize; offset += sizeof<T>()) {\n        let ref = load<usize>(otherStart + offset);\n        store<usize>(outStart + offset, ref);\n        __link(changetype<usize>(out), ref, true);\n      }\n    } else {\n      memory.copy(outStart, this.dataStart, thisSize);\n      memory.copy(outStart + thisSize, other.dataStart, <usize>otherLen << alignof<T>());\n    }\n    return out;\n  }\n\n  copyWithin(target: i32, start: i32, end: i32 = i32.MAX_VALUE): Array<T> {\n    let ptr = this.dataStart;\n    let len = this.length_;\n\n    end = min<i32>(end, len);\n\n    let to    = target < 0 ? max(len + target, 0) : min(target, len);\n    let from  = start < 0 ? max(len + start, 0) : min(start, len);\n    let last  = end < 0 ? max(len + end, 0) : min(end, len);\n    let count = min(last - from, len - to);\n\n    memory.copy( // is memmove\n      ptr + (<usize>to << alignof<T>()),\n      ptr + (<usize>from << alignof<T>()),\n      <usize>count << alignof<T>()\n    );\n    return this;\n  }\n\n  pop(): T {\n    let len = this.length_;\n    if (len < 1) throw new RangeError(E_EMPTYARRAY);\n    let val = load<T>(this.dataStart + (<usize>(--len) << alignof<T>()));\n    this.length_ = len;\n    return val;\n  }\n\n  forEach(fn: (value: T, index: i32, array: Array<T>) => void): void {\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this);\n    }\n  }\n\n  map<U>(fn: (value: T, index: i32, array: Array<T>) => U): Array<U> {\n    let len = this.length_;\n    let out = changetype<Array<U>>(__newArray(len, alignof<U>(), idof<Array<U>>()));\n    let outStart = out.dataStart;\n    for (let i = 0; i < min(len, this.length_); ++i) {\n      let result = fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this);\n      store<U>(outStart + (<usize>i << alignof<U>()), result);\n      if (isManaged<U>()) {\n        __link(changetype<usize>(out), changetype<usize>(result), true);\n      }\n    }\n    return out;\n  }\n\n  filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {\n    let result = changetype<Array<T>>(__newArray(0, alignof<T>(), idof<Array<T>>()));\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      let value = load<T>(this.dataStart + (<usize>i << alignof<T>()));\n      if (fn(value, i, this)) result.push(value);\n    }\n    return result;\n  }\n\n  reduce<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    let acc = initialValue;\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      acc = fn(acc, load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this);\n    }\n    return acc;\n  }\n\n  reduceRight<U>(\n    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,\n    initialValue: U\n  ): U {\n    let acc = initialValue;\n    for (let i = this.length_ - 1; i >= 0; --i) {\n      acc = fn(acc, load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this);\n    }\n    return acc;\n  }\n\n  shift(): T {\n    let len = this.length_;\n    if (len < 1) throw new RangeError(E_EMPTYARRAY);\n    let base = this.dataStart;\n    let element = load<T>(base);\n    let lastIndex = len - 1;\n    memory.copy(\n      base,\n      base + sizeof<T>(),\n      <usize>lastIndex << alignof<T>()\n    );\n    if (isReference<T>()) {\n      store<usize>(base + (<usize>lastIndex << alignof<T>()), 0);\n    } else {\n      // @ts-ignore\n      store<T>(base + (<usize>lastIndex << alignof<T>()), <T>0);\n    }\n    this.length_ = lastIndex;\n    return element;\n  }\n\n  some(fn: (value: T, index: i32, array: Array<T>) => bool): bool {\n    for (let i = 0, len = this.length_; i < min(len, this.length_); ++i) {\n      if (fn(load<T>(this.dataStart + (<usize>i << alignof<T>())), i, this)) return true;\n    }\n    return false;\n  }\n\n  unshift(value: T): i32 {\n    let len = this.length_ + 1;\n    ensureCapacity(changetype<usize>(this), len, alignof<T>());\n    let ptr = this.dataStart;\n    memory.copy(\n      ptr + sizeof<T>(),\n      ptr,\n      <usize>(len - 1) << alignof<T>()\n    );\n    store<T>(ptr, value);\n    if (isManaged<T>()) {\n      __link(changetype<usize>(this), changetype<usize>(value), true);\n    }\n    this.length_ = len;\n    return len;\n  }\n\n  slice(start: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {\n    let len = this.length_;\n    start = start < 0 ? max(start + len, 0) : min(start, len);\n    end   = end   < 0 ? max(end   + len, 0) : min(end  , len);\n    len = max(end - start, 0);\n    let slice = changetype<Array<T>>(__newArray(len, alignof<T>(), idof<Array<T>>()));\n    let sliceBase = slice.dataStart;\n    let thisBase = this.dataStart + (<usize>start << alignof<T>());\n    if (isManaged<T>()) {\n      let off = <usize>0;\n      let end = <usize>len << alignof<usize>();\n      while (off < end) {\n        let ref = load<usize>(thisBase + off);\n        store<usize>(sliceBase + off, ref);\n        __link(changetype<usize>(slice), ref, true);\n        off += sizeof<usize>();\n      }\n    } else {\n      memory.copy(sliceBase, thisBase, len << alignof<T>());\n    }\n    return slice;\n  }\n\n  splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array<T> {\n    let len = this.length_;\n    start       = start < 0 ? max<i32>(len + start, 0) : min<i32>(start, len);\n    deleteCount = max<i32>(min<i32>(deleteCount, len - start), 0);\n    let result  = changetype<Array<T>>(__newArray(deleteCount, alignof<T>(), idof<Array<T>>()));\n    let resultStart = result.dataStart;\n    let thisStart = this.dataStart;\n    let thisBase  = thisStart + (<usize>start << alignof<T>());\n    memory.copy(\n      resultStart,\n      thisBase,\n      <usize>deleteCount << alignof<T>()\n    );\n    let offset = start + deleteCount;\n    if (len != offset) {\n      memory.copy(\n        thisBase,\n        thisStart + (<usize>offset << alignof<T>()),\n        <usize>(len - offset) << alignof<T>()\n      );\n    }\n    this.length_ = len - deleteCount;\n    return result;\n  }\n\n  reverse(): Array<T> {\n    REVERSE<T>(this.dataStart, this.length_);\n    return this;\n  }\n\n  sort(comparator: (a: T, b: T) => i32 = COMPARATOR<T>()): Array<T> {\n    SORT<T>(this.dataStart, this.length_, comparator);\n    return this;\n  }\n\n  join(separator: string = \",\"): string {\n    let ptr = this.dataStart;\n    let len = this.length_;\n    if (isBoolean<T>())   return joinBooleanArray(ptr, len, separator);\n    if (isInteger<T>())   return joinIntegerArray<T>(ptr, len, separator);\n    if (isFloat<T>())     return joinFloatArray<T>(ptr, len, separator);\n\n    if (ASC_SHRINK_LEVEL < 1) {\n      if (isString<T>())  return joinStringArray(ptr, len, separator);\n    }\n    // For rest objects and arrays use general join routine\n    if (isReference<T>()) return joinReferenceArray<T>(ptr, len, separator);\n    ERROR(\"unspported element type\");\n    return <string>unreachable();\n  }\n\n  flat(): T {\n    if (!isArray<T>()) {\n      ERROR(\"Cannot call flat() on Array<T> where T is not an Array.\");\n    }\n    // Get the length and data start values\n    let ptr = this.dataStart;\n    let len = this.length_;\n\n    // calculate the end size with an initial pass\n    let size = 0;\n    for (let i = 0; i < len; ++i) {\n      let child = load<usize>(ptr + (i << alignof<T>()));\n      size += child == 0 ? 0 : load<i32>(child, offsetof<T>(\"length_\"));\n    }\n\n    // calculate the byteLength of the resulting backing ArrayBuffer\n    const align = alignof<valueof<T>>();\n    let byteLength = <usize>size << align;\n    let outBuffer = changetype<ArrayBuffer>(__new(byteLength, idof<ArrayBuffer>()));\n\n    // create the return value and initialize it\n    let outArray = changetype<T>(__new(offsetof<T>(), idof<T>()));\n    store<i32>(changetype<usize>(outArray), size, offsetof<T>(\"length_\"));\n\n    // byteLength, dataStart, and buffer are all readonly\n    store<i32>(changetype<usize>(outArray), byteLength, offsetof<T>(\"byteLength\"));\n    store<usize>(changetype<usize>(outArray), changetype<usize>(outBuffer), offsetof<T>(\"dataStart\"));\n    store<usize>(changetype<usize>(outArray), changetype<usize>(outBuffer), offsetof<T>(\"buffer\"));\n    __link(changetype<usize>(outArray), changetype<usize>(outBuffer), false);\n\n    // set the elements\n    let resultOffset: usize = 0;\n    for (let i = 0; i < len; ++i) { // for each child\n      let child = load<usize>(ptr + (<usize>i << alignof<T>()));\n\n      // ignore null arrays\n      if (!child) continue;\n\n      // copy the underlying buffer data to the result buffer\n      let childDataLength = <usize>load<i32>(child, offsetof<T>(\"length_\")) << align;\n      memory.copy(\n        changetype<usize>(outBuffer) + resultOffset,\n        load<usize>(child, offsetof<T>(\"dataStart\")),\n        childDataLength\n      );\n\n      // advance the result length\n      resultOffset += childDataLength;\n    }\n\n    // if the `valueof<T>` type is managed, we must link each reference\n    if (isManaged<valueof<T>>()) {\n      for (let i = 0; i < size; ++i) {\n        let ref = load<usize>(changetype<usize>(outBuffer) + (<usize>i << usize(alignof<valueof<T>>())));\n        __link(changetype<usize>(outBuffer), ref, true);\n      }\n    }\n\n    return outArray;\n  }\n\n  toString(): string {\n    return this.join();\n  }\n\n  // RT integration\n\n  @unsafe private __visit(cookie: u32): void {\n    if (isManaged<T>()) {\n      let cur = this.dataStart;\n      let end = cur + (<usize>this.length_ << alignof<T>());\n      while (cur < end) {\n        let val = load<usize>(cur);\n        if (val) __visit(val, cookie);\n        cur += sizeof<usize>();\n      }\n    }\n    __visit(changetype<usize>(this.buffer), cookie);\n  }\n}\n","// This file is shared with the compiler and must remain portable\n\n// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕\n//    3                   2                   1\n//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base\n// │                             count                             │\n// ╞═══════════════════════════════════════════════════════════════╡ ┐\n// │                      Typeinfo#flags [id=0]                    │ id < count\n// ├───────────────────────────────────────────────────────────────┤\n// │                              ...                              │\n\n/** Runtime type information data structure. */\n@unmanaged\nexport class Typeinfo {\n  /** Flags describing the shape of this class type. */\n  flags: TypeinfoFlags = TypeinfoFlags.NONE;\n}\n\n/** Runtime type information flags. */\nexport const enum TypeinfoFlags {\n  /** No specific flags. */\n  NONE = 0,\n  /** Type is an `ArrayBufferView`. */\n  ARRAYBUFFERVIEW = 1 << 0,\n  /** Type is an `Array`. */\n  ARRAY = 1 << 1,\n  /** Type is a `StaticArray`. */\n  STATICARRAY = 1 << 2,\n  /** Type is a `Set`. */\n  SET = 1 << 3,\n  /** Type is a `Map`. */\n  MAP = 1 << 4,\n  /** Type has no outgoing pointers. */\n  POINTERFREE = 1 << 5,\n  /** Value alignment of 1 byte. */\n  VALUE_ALIGN_0 = 1 << 6,\n  /** Value alignment of 2 bytes. */\n  VALUE_ALIGN_1 = 1 << 7,\n  /** Value alignment of 4 bytes. */\n  VALUE_ALIGN_2 = 1 << 8,\n  /** Value alignment of 8 bytes. */\n  VALUE_ALIGN_3 = 1 << 9,\n  /** Value alignment of 16 bytes. */\n  VALUE_ALIGN_4 = 1 << 10,\n  /** Value is a signed type. */\n  VALUE_SIGNED = 1 << 11,\n  /** Value is a float type. */\n  VALUE_FLOAT = 1 << 12,\n  /** Value type is nullable. */\n  VALUE_NULLABLE = 1 << 13,\n  /** Value type is managed. */\n  VALUE_MANAGED = 1 << 14,\n  /** Key alignment of 1 byte. */\n  KEY_ALIGN_0 = 1 << 15,\n  /** Key alignment of 2 bytes. */\n  KEY_ALIGN_1 = 1 << 16,\n  /** Key alignment of 4 bytes. */\n  KEY_ALIGN_2 = 1 << 17,\n  /** Key alignment of 8 bytes. */\n  KEY_ALIGN_3 = 1 << 18,\n  /** Key alignment of 16 bytes. */\n  KEY_ALIGN_4 = 1 << 19,\n  /** Key is a signed type. */\n  KEY_SIGNED = 1 << 20,\n  /** Key is a float type. */\n  KEY_FLOAT = 1 << 21,\n  /** Key type is nullable. */\n  KEY_NULLABLE = 1 << 22,\n  /** Key type is managed. */\n  KEY_MANAGED = 1 << 23\n}\n","import { Typeinfo, TypeinfoFlags } from \"./shared/typeinfo\";\nimport { E_INDEXOUTOFRANGE } from \"./util/error\";\nimport { ArrayBufferView } from \"./arraybuffer\";\n\n// @ts-ignore: decorator\n@builtin\nexport declare const __rtti_base: usize;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_globals(cookie: u32): void;\n\n// @ts-ignore: decorator\n@builtin @unsafe\nexport declare function __visit_members(ref: usize, cookie: u32): void;\n\n// @ts-ignore: decorator\n@unsafe\nexport function __typeinfo(id: u32): TypeinfoFlags {\n  let ptr = __rtti_base;\n  if (id > load<u32>(ptr)) throw new Error(E_INDEXOUTOFRANGE);\n  return changetype<Typeinfo>(ptr + sizeof<u32>() + id * offsetof<Typeinfo>()).flags;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newBuffer(size: usize, id: u32, data: usize = 0): usize {\n  let buffer = __new(size, id);\n  if (data) memory.copy(buffer, data, size);\n  return buffer;\n}\n\n// @ts-ignore: decorator\n@unsafe\nexport function __newArray(length: i32, alignLog2: usize, id: u32, data: usize = 0): usize {\n  let bufferSize = <usize>length << alignLog2;\n  // make sure `buffer` is tracked by the shadow stack\n  let buffer = changetype<ArrayBuffer>(__newBuffer(bufferSize, idof<ArrayBuffer>(), data));\n  // ...since allocating the array may trigger GC steps\n  let array = __new(offsetof<i32[]>(), id);\n  store<usize>(array, changetype<usize>(buffer), offsetof<ArrayBufferView>(\"buffer\"));\n  __link(array, changetype<usize>(buffer), false);\n  store<usize>(array, changetype<usize>(buffer), offsetof<ArrayBufferView>(\"dataStart\"));\n  store<i32>(array, bufferSize, offsetof<ArrayBufferView>(\"byteLength\"));\n  store<i32>(array, length, offsetof<i32[]>(\"length_\"));\n  return array;\n}\n\n// @ts-ignore: decorator\n@global @unsafe\nfunction __tostack(ptr: usize): usize { // eslint-disable-line\n  return ptr;\n}\n\n// These are provided by the respective implementation, included as another entry file by asc:\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __alloc(size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __realloc(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __free(ptr: usize): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __new(size: usize, id: u32): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __renew(ptr: usize, size: usize): usize;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __link(parentPtr: usize, childPtr: usize, expectMultiple: bool): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __collect(): void;\n\n// // @ts-ignore: decorator\n// @builtin @unsafe\n// export declare function __visit(ptr: usize, cookie: u32): void;\n","/**\r\n * Signal windowing / resampling kernels — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../signal/windowing.rs`.\r\n */\r\n\r\n/** Linear-interpolation resampling of `x` from `oldRate` to `newRate`. */\r\nexport function resample(x: Float64Array, newRate: f64, oldRate: f64): Float64Array {\r\n  if (x.length <= 0 || newRate <= 0.0 || oldRate <= 0.0) {\r\n    return new Float64Array(0);\r\n  }\r\n  const ratio: f64 = oldRate / newRate;\r\n  const newLen: i32 = <i32>Math.round(<f64>x.length / ratio);\r\n  const out = new Float64Array(newLen);\r\n  const last: i32 = x.length - 1;\r\n  for (let i: i32 = 0; i < newLen; i++) {\r\n    const srcIdx: f64 = <f64>i * ratio;\r\n    let lo: i32 = <i32>Math.floor(srcIdx);\r\n    if (lo < 0) lo = 0;\r\n    if (lo > last) lo = last;\r\n    let hi: i32 = lo + 1;\r\n    if (hi > last) hi = last;\r\n    const frac: f64 = srcIdx - <f64>lo;\r\n    out[i] = x[lo] * (1.0 - frac) + x[hi] * frac;\r\n  }\r\n  return out;\r\n}\r\n\r\n/** Median filter of `x` with window size `n` (forced odd). */\r\nexport function medfilt(x: Float64Array, n: i32): Float64Array {\r\n  if (x.length <= 0) return new Float64Array(0);\r\n  let win: i32 = n < 1 ? 1 : n;\r\n  if (win % 2 == 0) win += 1;\r\n  const half: i32 = win / 2;\r\n  const out = new Float64Array(x.length);\r\n  const work = new Float64Array(win);\r\n  for (let i: i32 = 0; i < x.length; i++) {\r\n    let wlen: i32 = 0;\r\n    for (let j: i32 = i - half; j <= i + half; j++) {\r\n      if (j >= 0 && j < x.length) {\r\n        work[wlen] = x[j];\r\n        wlen++;\r\n      }\r\n    }\r\n    for (let a: i32 = 1; a < wlen; a++) {\r\n      const key: f64 = work[a];\r\n      let b: i32 = a;\r\n      while (b > 0 && work[b - 1] > key) {\r\n        work[b] = work[b - 1];\r\n        b--;\r\n      }\r\n      work[b] = key;\r\n    }\r\n    out[i] = work[wlen / 2];\r\n  }\r\n  return out;\r\n}\r\n\r\n/**\r\n * Generate a window of length `n`. `windowType`: 0 rectangular, 1 hamming,\r\n * 2 hann, 3 blackman, 4 bartlett.\r\n */\r\nexport function windowFunction(n: i32, windowType: i32): Float64Array {\r\n  if (n <= 0) return new Float64Array(0);\r\n  const out = new Float64Array(n);\r\n  const n1: f64 = <f64>(n - 1);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const fi: f64 = <f64>i;\r\n    let v: f64;\r\n    if (windowType == 1) {\r\n      v = 0.54 - 0.46 * Math.cos((2.0 * Math.PI * fi) / n1);\r\n    } else if (windowType == 2) {\r\n      v = 0.5 * (1.0 - Math.cos((2.0 * Math.PI * fi) / n1));\r\n    } else if (windowType == 3) {\r\n      v =\r\n        0.42 -\r\n        0.5 * Math.cos((2.0 * Math.PI * fi) / n1) +\r\n        0.08 * Math.cos((4.0 * Math.PI * fi) / n1);\r\n    } else if (windowType == 4) {\r\n      v = 1.0 - Math.abs((2.0 * fi - n1) / n1);\r\n    } else {\r\n      v = 1.0;\r\n    }\r\n    out[i] = v;\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Spectral-windowing WASM kernels — AssemblyScript parity port (Slice 5.6).\r\n *\r\n * Mirrors the algorithms in:\r\n *   wasm-rust/crates/mathts-wasm/src/signal/spectral.rs\r\n *\r\n * All exported functions use the typed-array calling convention.\r\n * Window-type encoding: 0=Hann, 1=Hamming, 2=Blackman, 3=Rectangular.\r\n */\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal helpers\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Apply a window function to `buf` in-place. */\r\nfunction _applyWindowInplace(buf: Float64Array, windowType: i32): void {\r\n  const n: i32 = buf.length;\r\n  if (n == 0) return;\r\n  const n1: f64 = <f64>(n - 1);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const fi: f64 = <f64>i;\r\n    if (windowType == 0) {\r\n      // Hann\r\n      buf[i] *= 0.5 * (1.0 - Math.cos((2.0 * Math.PI * fi) / n1));\r\n    } else if (windowType == 1) {\r\n      // Hamming\r\n      buf[i] *= 0.54 - 0.46 * Math.cos((2.0 * Math.PI * fi) / n1);\r\n    } else if (windowType == 2) {\r\n      // Blackman\r\n      buf[i] *=\r\n        0.42 -\r\n        0.5 * Math.cos((2.0 * Math.PI * fi) / n1) +\r\n        0.08 * Math.cos((4.0 * Math.PI * fi) / n1);\r\n    }\r\n    // Rectangular (3 or default) — no-op\r\n  }\r\n}\r\n\r\n/** Next power of 2 >= n. */\r\nfunction _nextPow2(n: i32): i32 {\r\n  let p: i32 = 1;\r\n  while (p < n) p <<= 1;\r\n  return p;\r\n}\r\n\r\n/**\r\n * Radix-2 Cooley-Tukey FFT on interleaved complex data (re0,im0,re1,im1,...).\r\n * `n` must be a power of 2.\r\n * `inverse` = false for forward, true for inverse (with 1/N scaling).\r\n */\r\nfunction _fftInterleaved(data: Float64Array, n: i32, inverse: bool): void {\r\n  // Bit-reversal permutation\r\n  let j: i32 = 0;\r\n  for (let i: i32 = 1; i < n; i++) {\r\n    let bit: i32 = n >> 1;\r\n    while (j & bit) {\r\n      j ^= bit;\r\n      bit >>= 1;\r\n    }\r\n    j ^= bit;\r\n    if (i < j) {\r\n      // Swap complex elements i and j\r\n      const ri: f64 = data[i * 2];\r\n      const ii: f64 = data[i * 2 + 1];\r\n      data[i * 2] = data[j * 2];\r\n      data[i * 2 + 1] = data[j * 2 + 1];\r\n      data[j * 2] = ri;\r\n      data[j * 2 + 1] = ii;\r\n    }\r\n  }\r\n\r\n  const sign: f64 = inverse ? 1.0 : -1.0;\r\n  let size: i32 = 2;\r\n  while (size <= n) {\r\n    const halfSize: i32 = size >> 1;\r\n    const angle: f64 = (sign * 2.0 * Math.PI) / <f64>size;\r\n    const wRe: f64 = Math.cos(angle);\r\n    const wIm: f64 = Math.sin(angle);\r\n\r\n    for (let start: i32 = 0; start < n; start += size) {\r\n      let tRe: f64 = 1.0;\r\n      let tIm: f64 = 0.0;\r\n      for (let k: i32 = 0; k < halfSize; k++) {\r\n        const eIdx: i32 = (start + k) * 2;\r\n        const oIdx: i32 = (start + k + halfSize) * 2;\r\n        const eRe: f64 = data[eIdx];\r\n        const eIm: f64 = data[eIdx + 1];\r\n        const oRe: f64 = data[oIdx];\r\n        const oIm: f64 = data[oIdx + 1];\r\n        const uRe: f64 = oRe * tRe - oIm * tIm;\r\n        const uIm: f64 = oRe * tIm + oIm * tRe;\r\n        data[eIdx] = eRe + uRe;\r\n        data[eIdx + 1] = eIm + uIm;\r\n        data[oIdx] = eRe - uRe;\r\n        data[oIdx + 1] = eIm - uIm;\r\n        const nextTRe: f64 = tRe * wRe - tIm * wIm;\r\n        const nextTIm: f64 = tRe * wIm + tIm * wRe;\r\n        tRe = nextTRe;\r\n        tIm = nextTIm;\r\n      }\r\n    }\r\n    size <<= 1;\r\n  }\r\n\r\n  if (inverse) {\r\n    const scale: f64 = 1.0 / <f64>n;\r\n    for (let i: i32 = 0; i < n * 2; i++) {\r\n      data[i] *= scale;\r\n    }\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 1. apply_window_f64\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Apply a window function to `samples` in-place.\r\n *\r\n * @param samples - Input/output samples (modified in-place)\r\n * @param windowType - 0=Hann, 1=Hamming, 2=Blackman, 3=Rectangular\r\n * @returns 0 on success, -1 on error\r\n */\r\nexport function apply_window_f64(samples: Float64Array, windowType: i32): i32 {\r\n  if (samples.length == 0) return -1;\r\n  _applyWindowInplace(samples, windowType);\r\n  return 0;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 2. welch_psd_f64\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Welch's overlapped-segment-averaging PSD.\r\n *\r\n * @param samples - Input signal\r\n * @param frameLength - Length of each frame (should be a power of 2)\r\n * @param overlap - Number of overlapping samples between consecutive frames\r\n * @param windowType - Window function (0=Hann, 1=Hamming, 2=Blackman, 3=Rect)\r\n * @returns Float64Array of length frameLength/2 + 1, or empty on error\r\n */\r\nexport function welch_psd_f64(\r\n  samples: Float64Array,\r\n  frameLength: i32,\r\n  overlap: i32,\r\n  windowType: i32,\r\n): Float64Array {\r\n  const n: i32 = samples.length;\r\n  if (n < frameLength || frameLength < 2 || overlap >= frameLength) {\r\n    return new Float64Array(0);\r\n  }\r\n\r\n  const psdLen: i32 = frameLength / 2 + 1;\r\n  const psd = new Float64Array(psdLen);\r\n  const hop: i32 = frameLength - overlap;\r\n\r\n  // Window normalization\r\n  const winBuf = new Float64Array(frameLength);\r\n  for (let i: i32 = 0; i < frameLength; i++) winBuf[i] = 1.0;\r\n  _applyWindowInplace(winBuf, windowType);\r\n  let winPower: f64 = 0.0;\r\n  for (let i: i32 = 0; i < frameLength; i++) winPower += winBuf[i] * winBuf[i];\r\n  winPower /= <f64>frameLength;\r\n\r\n  let numFrames: i32 = 0;\r\n  let start: i32 = 0;\r\n\r\n  // Use next power-of-2 >= frameLength for FFT\r\n  const fftLen: i32 = _nextPow2(frameLength);\r\n  const fftData = new Float64Array(fftLen * 2); // interleaved complex\r\n\r\n  while (start + frameLength <= n) {\r\n    // Zero the FFT buffer\r\n    for (let i: i32 = 0; i < fftLen * 2; i++) fftData[i] = 0.0;\r\n\r\n    // Copy frame and apply window\r\n    for (let i: i32 = 0; i < frameLength; i++) {\r\n      fftData[i * 2] = samples[start + i] * winBuf[i];\r\n      fftData[i * 2 + 1] = 0.0;\r\n    }\r\n\r\n    _fftInterleaved(fftData, fftLen, false);\r\n\r\n    // Accumulate |X[k]|²  (only first fftLen/2+1 bins; psdLen uses frameLength)\r\n    for (let k: i32 = 0; k < psdLen; k++) {\r\n      const re: f64 = fftData[k * 2];\r\n      const im: f64 = fftData[k * 2 + 1];\r\n      psd[k] += re * re + im * im;\r\n    }\r\n\r\n    numFrames++;\r\n    start += hop;\r\n  }\r\n\r\n  if (numFrames == 0) return new Float64Array(0);\r\n\r\n  const norm: f64 = <f64>numFrames * <f64>frameLength * winPower;\r\n  for (let k: i32 = 0; k < psdLen; k++) {\r\n    psd[k] /= norm;\r\n  }\r\n  // Double one-sided bins (except DC and Nyquist)\r\n  for (let k: i32 = 1; k < psdLen - 1; k++) {\r\n    psd[k] *= 2.0;\r\n  }\r\n\r\n  return psd;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 3. bartlett_psd_f64\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Bartlett's non-overlapped segment-averaging PSD (Welch with overlap=0).\r\n *\r\n * @param samples - Input signal\r\n * @param frameLength - Length of each frame\r\n * @returns Float64Array of length frameLength/2 + 1, or empty on error\r\n */\r\nexport function bartlett_psd_f64(samples: Float64Array, frameLength: i32): Float64Array {\r\n  return welch_psd_f64(samples, frameLength, 0, 3); // rectangular, no overlap\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 4. goertzel_f64\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Goertzel algorithm: compute |X[k]|² for a single DFT bin.\r\n *\r\n * @param samples - Input signal\r\n * @param targetFreq - Target frequency in Hz\r\n * @param sampleRate - Sample rate in Hz\r\n * @returns |X[k]|² (power at target frequency), or NaN on error\r\n */\r\nexport function goertzel_f64(samples: Float64Array, targetFreq: f64, sampleRate: f64): f64 {\r\n  const n: i32 = samples.length;\r\n  if (n == 0 || sampleRate <= 0.0) return NaN;\r\n\r\n  const kf: f64 = (targetFreq * <f64>n) / sampleRate;\r\n  const omega: f64 = (2.0 * Math.PI * kf) / <f64>n;\r\n  const cosOmega: f64 = Math.cos(omega);\r\n  const coeff: f64 = 2.0 * cosOmega;\r\n\r\n  let sPrev2: f64 = 0.0;\r\n  let sPrev1: f64 = 0.0;\r\n\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const s: f64 = samples[i] + coeff * sPrev1 - sPrev2;\r\n    sPrev2 = sPrev1;\r\n    sPrev1 = s;\r\n  }\r\n\r\n  return sPrev2 * sPrev2 + sPrev1 * sPrev1 - coeff * sPrev1 * sPrev2;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 5. chirp_z_transform_f64\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Chirp-Z Transform (Bluestein algorithm).\r\n *\r\n * Returns an interleaved Float64Array [re0, im0, re1, im1, ...] of length 2*M.\r\n * Returns empty array on error.\r\n *\r\n * @param samples - Input real signal of length N\r\n * @param m - Number of output points\r\n * @param phiStartRe - Real part of starting complex exponential A\r\n * @param phiStartIm - Imaginary part of A\r\n * @param phiStepRe - Real part of step complex exponential W\r\n * @param phiStepIm - Imaginary part of W\r\n */\r\nexport function chirp_z_transform_f64(\r\n  samples: Float64Array,\r\n  m: i32,\r\n  phiStartRe: f64,\r\n  phiStartIm: f64,\r\n  phiStepRe: f64,\r\n  phiStepIm: f64,\r\n): Float64Array {\r\n  const n: i32 = samples.length;\r\n  if (n == 0 || m == 0) return new Float64Array(0);\r\n\r\n  // L = next power of 2 >= N+M-1\r\n  const lMin: i32 = n + m - 1;\r\n  const l: i32 = _nextPow2(lMin);\r\n\r\n  // arg(W) — the angle of the step complex number\r\n  const argW: f64 = Math.atan2(phiStepIm, phiStepRe);\r\n\r\n  // Build yn: length L (zero-padded after N), interleaved complex\r\n  const yn = new Float64Array(l * 2);\r\n  // A^{-n}: A_inv = conj(A) / |A|²\r\n  const aNormSq: f64 = phiStartRe * phiStartRe + phiStartIm * phiStartIm;\r\n  let aInvRe: f64 = aNormSq > 1e-300 ? phiStartRe / aNormSq : 0.0;\r\n  let aInvIm: f64 = aNormSq > 1e-300 ? -phiStartIm / aNormSq : 0.0;\r\n  let aPowRe: f64 = 1.0; // A^{-n}\r\n  let aPowIm: f64 = 0.0;\r\n\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const iFlt: f64 = <f64>i;\r\n    const phase: f64 = argW * iFlt * iFlt * 0.5;\r\n    const wHalfRe: f64 = Math.cos(phase);\r\n    const wHalfIm: f64 = Math.sin(phase);\r\n    // yn[i] = x[i] * aPow * wHalf\r\n    const tmpRe: f64 = aPowRe * wHalfRe - aPowIm * wHalfIm;\r\n    const tmpIm: f64 = aPowRe * wHalfIm + aPowIm * wHalfRe;\r\n    yn[i * 2] = samples[i] * tmpRe;\r\n    yn[i * 2 + 1] = samples[i] * tmpIm;\r\n    // Advance A^{-n}: multiply by A^{-1}\r\n    const newARe: f64 = aPowRe * aInvRe - aPowIm * aInvIm;\r\n    const newAIm: f64 = aPowRe * aInvIm + aPowIm * aInvRe;\r\n    aPowRe = newARe;\r\n    aPowIm = newAIm;\r\n  }\r\n\r\n  // Build hn (chirp filter): h[i] = W^{-i²/2} for i in 0..M-1\r\n  //                          h[L-i] = W^{-i²/2} for i in 1..N-1\r\n  const hn = new Float64Array(l * 2);\r\n  for (let i: i32 = 0; i < m; i++) {\r\n    const phase: f64 = -argW * <f64>i * <f64>i * 0.5;\r\n    hn[i * 2] = Math.cos(phase);\r\n    hn[i * 2 + 1] = Math.sin(phase);\r\n  }\r\n  for (let i: i32 = 1; i < n; i++) {\r\n    const phase: f64 = -argW * <f64>i * <f64>i * 0.5;\r\n    hn[(l - i) * 2] = Math.cos(phase);\r\n    hn[(l - i) * 2 + 1] = Math.sin(phase);\r\n  }\r\n\r\n  // FFT(yn), FFT(hn), pointwise multiply, IFFT\r\n  _fftInterleaved(yn, l, false);\r\n  _fftInterleaved(hn, l, false);\r\n\r\n  // gz = yn * hn (pointwise complex multiply)\r\n  const gz = new Float64Array(l * 2);\r\n  for (let i: i32 = 0; i < l; i++) {\r\n    const re: f64 = yn[i * 2] * hn[i * 2] - yn[i * 2 + 1] * hn[i * 2 + 1];\r\n    const im: f64 = yn[i * 2] * hn[i * 2 + 1] + yn[i * 2 + 1] * hn[i * 2];\r\n    gz[i * 2] = re;\r\n    gz[i * 2 + 1] = im;\r\n  }\r\n\r\n  // IFFT already scales by 1/L\r\n  _fftInterleaved(gz, l, true);\r\n\r\n  // Extract M output points and multiply by W^{k²/2}\r\n  const out = new Float64Array(m * 2);\r\n  for (let k: i32 = 0; k < m; k++) {\r\n    const kFlt: f64 = <f64>k;\r\n    const phase: f64 = argW * kFlt * kFlt * 0.5;\r\n    const wHalfRe: f64 = Math.cos(phase);\r\n    const wHalfIm: f64 = Math.sin(phase);\r\n    const gRe: f64 = gz[k * 2];\r\n    const gIm: f64 = gz[k * 2 + 1];\r\n    out[k * 2] = gRe * wHalfRe - gIm * wHalfIm;\r\n    out[k * 2 + 1] = gRe * wHalfIm + gIm * wHalfRe;\r\n  }\r\n\r\n  return out;\r\n}\r\n","/**\r\n * Extra linear-algebra kernels — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../matrix/linalg_ext.rs`: reduced row echelon form and the\r\n * characteristic polynomial (Faddeev-LeVerrier).\r\n */\r\n\r\n/** Reduced row echelon form of an m x n row-major matrix. */\r\nexport function rowReduce(a: Float64Array, m: i32, n: i32, tol: f64): Float64Array {\r\n  if (m <= 0 || n <= 0) return new Float64Array(0);\r\n  const out = new Float64Array(m * n);\r\n  for (let i = 0; i < m * n; i++) out[i] = a[i];\r\n\r\n  let pivotRow: i32 = 0;\r\n  for (let col = 0; col < n; col++) {\r\n    if (pivotRow >= m) break;\r\n    let maxRow: i32 = pivotRow;\r\n    let maxVal: f64 = Math.abs(out[pivotRow * n + col]);\r\n    for (let row = pivotRow + 1; row < m; row++) {\r\n      const v: f64 = Math.abs(out[row * n + col]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        maxRow = row;\r\n      }\r\n    }\r\n    if (maxVal < tol) continue;\r\n    if (maxRow != pivotRow) {\r\n      for (let j = 0; j < n; j++) {\r\n        const t: f64 = out[pivotRow * n + j];\r\n        out[pivotRow * n + j] = out[maxRow * n + j];\r\n        out[maxRow * n + j] = t;\r\n      }\r\n    }\r\n    const scale: f64 = out[pivotRow * n + col];\r\n    for (let j = col; j < n; j++) out[pivotRow * n + j] /= scale;\r\n    for (let row = 0; row < m; row++) {\r\n      if (row == pivotRow) continue;\r\n      const factor: f64 = out[row * n + col];\r\n      if (Math.abs(factor) < tol) continue;\r\n      for (let j = col; j < n; j++) {\r\n        out[row * n + j] -= factor * out[pivotRow * n + j];\r\n      }\r\n    }\r\n    pivotRow++;\r\n  }\r\n  for (let i = 0; i < m * n; i++) {\r\n    if (Math.abs(out[i]) < tol) out[i] = 0.0;\r\n  }\r\n  return out;\r\n}\r\n\r\n/**\r\n * Characteristic polynomial of an n x n matrix (Faddeev-LeVerrier).\r\n * Returns n + 1 coefficients, constant term first, monic.\r\n */\r\nexport function characteristicPolynomial(a: Float64Array, n: i32): Float64Array {\r\n  if (n <= 0) return new Float64Array(0);\r\n  const out = new Float64Array(n + 1);\r\n  out[n] = 1.0;\r\n\r\n  let m = new Float64Array(n * n);\r\n  for (let i = 0; i < n * n; i++) m[i] = a[i];\r\n  const shifted = new Float64Array(n * n);\r\n  const prod = new Float64Array(n * n);\r\n\r\n  for (let k = 1; k <= n; k++) {\r\n    let tr: f64 = 0.0;\r\n    for (let i = 0; i < n; i++) tr += m[i * n + i];\r\n    const coeff: f64 = -tr / <f64>k;\r\n    out[n - k] = coeff;\r\n\r\n    if (k < n) {\r\n      for (let i = 0; i < n * n; i++) shifted[i] = m[i];\r\n      for (let i = 0; i < n; i++) shifted[i * n + i] += coeff;\r\n      for (let i = 0; i < n; i++) {\r\n        for (let j = 0; j < n; j++) {\r\n          let s: f64 = 0.0;\r\n          for (let t = 0; t < n; t++) s += a[i * n + t] * shifted[t * n + j];\r\n          prod[i * n + j] = s;\r\n        }\r\n      }\r\n      for (let i = 0; i < n * n; i++) m[i] = prod[i];\r\n    }\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Log-linearized curve fitting — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../numeric/curvefit.rs`. Each fit returns `[a, b]`.\r\n */\r\n\r\n/** Exponential fit `y = a * exp(b * x)`. Returns [a, b]. */\r\nexport function expfit(xs: Float64Array, ys: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(2);\r\n  if (n <= 0) return out;\r\n  let sx: f64 = 0.0;\r\n  let sy: f64 = 0.0;\r\n  let sxx: f64 = 0.0;\r\n  let sxy: f64 = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    const absy: f64 = Math.abs(ys[i]);\r\n    const logY: f64 = Math.log(absy != 0.0 ? absy : 1e-15);\r\n    sx += xs[i];\r\n    sy += logY;\r\n    sxx += xs[i] * xs[i];\r\n    sxy += xs[i] * logY;\r\n  }\r\n  const nf: f64 = <f64>n;\r\n  const b: f64 = (nf * sxy - sx * sy) / (nf * sxx - sx * sx);\r\n  const lna: f64 = (sy - b * sx) / nf;\r\n  out[0] = Math.exp(lna);\r\n  out[1] = b;\r\n  return out;\r\n}\r\n\r\n/** Logarithmic fit `y = a * ln(x) + b`. Returns [a, b]. */\r\nexport function logfit(xs: Float64Array, ys: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(2);\r\n  if (n <= 0) return out;\r\n  let sx: f64 = 0.0;\r\n  let sy: f64 = 0.0;\r\n  let sxx: f64 = 0.0;\r\n  let sxy: f64 = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    const logX: f64 = Math.log(xs[i]);\r\n    sx += logX;\r\n    sy += ys[i];\r\n    sxx += logX * logX;\r\n    sxy += logX * ys[i];\r\n  }\r\n  const nf: f64 = <f64>n;\r\n  const a: f64 = (nf * sxy - sx * sy) / (nf * sxx - sx * sx);\r\n  const b: f64 = (sy - a * sx) / nf;\r\n  out[0] = a;\r\n  out[1] = b;\r\n  return out;\r\n}\r\n\r\n/** Power fit `y = a * x^b`. Returns [a, b]. */\r\nexport function powerfit(xs: Float64Array, ys: Float64Array): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const out = new Float64Array(2);\r\n  if (n <= 0) return out;\r\n  let sx: f64 = 0.0;\r\n  let sy: f64 = 0.0;\r\n  let sxx: f64 = 0.0;\r\n  let sxy: f64 = 0.0;\r\n  for (let i = 0; i < n; i++) {\r\n    const logX: f64 = Math.log(xs[i]);\r\n    const logY: f64 = Math.log(ys[i]);\r\n    sx += logX;\r\n    sy += logY;\r\n    sxx += logX * logX;\r\n    sxy += logX * logY;\r\n  }\r\n  const nf: f64 = <f64>n;\r\n  const b: f64 = (nf * sxy - sx * sy) / (nf * sxx - sx * sx);\r\n  const lna: f64 = (sy - b * sx) / nf;\r\n  out[0] = Math.exp(lna);\r\n  out[1] = b;\r\n  return out;\r\n}\r\n","/**\r\n * Optimization kernels — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../numeric/optimization_ext.rs`: linear programming (simplex),\r\n * quadratic programming (projected gradient), and null-space basis.\r\n *\r\n * Matrices are flat row-major `Float64Array`s with explicit dimensions.\r\n */\r\n\r\n/**\r\n * Quadratic programming: minimize `0.5 x^T H x + f^T x` s.t. `A x <= b`.\r\n * Returns the solution vector `x` (length `n`).\r\n */\r\nexport function quadprog(\r\n  h: Float64Array,\r\n  n: i32,\r\n  f: Float64Array,\r\n  a: Float64Array,\r\n  m: i32,\r\n  b: Float64Array\r\n): Float64Array {\r\n  if (n <= 0) return new Float64Array(0);\r\n  const mc: i32 = m < 0 ? 0 : m;\r\n  const x = new Float64Array(n);\r\n  const grad = new Float64Array(n);\r\n  const xNew = new Float64Array(n);\r\n  const lr: f64 = 0.01;\r\n\r\n  for (let iter = 0; iter < 2000; iter++) {\r\n    for (let i = 0; i < n; i++) {\r\n      grad[i] = f[i];\r\n      for (let j = 0; j < n; j++) grad[i] += h[i * n + j] * x[j];\r\n    }\r\n    for (let i = 0; i < n; i++) xNew[i] = x[i] - lr * grad[i];\r\n    for (let c = 0; c < mc; c++) {\r\n      let ax: f64 = 0.0;\r\n      for (let j = 0; j < n; j++) ax += a[c * n + j] * xNew[j];\r\n      if (ax > b[c]) {\r\n        let aNorm: f64 = 0.0;\r\n        for (let j = 0; j < n; j++) aNorm += a[c * n + j] * a[c * n + j];\r\n        if (aNorm > 1e-15) {\r\n          const scale: f64 = (ax - b[c]) / aNorm;\r\n          for (let j = 0; j < n; j++) xNew[j] -= scale * a[c * n + j];\r\n        }\r\n      }\r\n    }\r\n    let maxDiff: f64 = 0.0;\r\n    for (let i = 0; i < n; i++) {\r\n      const d: f64 = Math.abs(xNew[i] - x[i]);\r\n      if (d > maxDiff) maxDiff = d;\r\n    }\r\n    for (let i = 0; i < n; i++) x[i] = xNew[i];\r\n    if (maxDiff < 1e-10) break;\r\n  }\r\n  return x;\r\n}\r\n\r\n/**\r\n * Linear programming: minimize `c^T x` s.t. `A x <= b`, `x >= 0`, via the\r\n * simplex method. Returns `x` (length `n`), or an empty array if unbounded.\r\n */\r\nexport function linprog(\r\n  c: Float64Array,\r\n  n: i32,\r\n  a: Float64Array,\r\n  b: Float64Array,\r\n  m: i32\r\n): Float64Array {\r\n  if (n <= 0 || m < 0) return new Float64Array(0);\r\n  const total: i32 = n + m;\r\n  const cols: i32 = total + 1;\r\n  const rows: i32 = m + 1;\r\n  const t = new Float64Array(rows * cols);\r\n  for (let i = 0; i < m; i++) {\r\n    for (let j = 0; j < n; j++) t[i * cols + j] = a[i * n + j];\r\n    t[i * cols + n + i] = 1.0;\r\n    t[i * cols + total] = b[i];\r\n  }\r\n  for (let j = 0; j < n; j++) t[m * cols + j] = c[j];\r\n\r\n  for (let iter = 0; iter < 1000; iter++) {\r\n    let pivotCol: i32 = -1;\r\n    let minVal: f64 = -1e-10;\r\n    for (let j = 0; j < total; j++) {\r\n      if (t[m * cols + j] < minVal) {\r\n        minVal = t[m * cols + j];\r\n        pivotCol = j;\r\n      }\r\n    }\r\n    if (pivotCol == -1) break;\r\n    let pivotRow: i32 = -1;\r\n    let minRatio: f64 = Infinity;\r\n    for (let i = 0; i < m; i++) {\r\n      const cv: f64 = t[i * cols + pivotCol];\r\n      if (cv > 1e-10) {\r\n        const ratio: f64 = t[i * cols + total] / cv;\r\n        if (ratio < minRatio) {\r\n          minRatio = ratio;\r\n          pivotRow = i;\r\n        }\r\n      }\r\n    }\r\n    if (pivotRow == -1) return new Float64Array(0); // unbounded\r\n    const pv: f64 = t[pivotRow * cols + pivotCol];\r\n    for (let j = 0; j < cols; j++) t[pivotRow * cols + j] /= pv;\r\n    for (let i = 0; i < rows; i++) {\r\n      if (i == pivotRow) continue;\r\n      const factor: f64 = t[i * cols + pivotCol];\r\n      for (let j = 0; j < cols; j++) {\r\n        t[i * cols + j] -= factor * t[pivotRow * cols + j];\r\n      }\r\n    }\r\n  }\r\n\r\n  const x = new Float64Array(n);\r\n  for (let j = 0; j < n; j++) {\r\n    let basicRow: i32 = -1;\r\n    let isBasic: bool = true;\r\n    for (let i = 0; i < rows; i++) {\r\n      if (Math.abs(t[i * cols + j] - 1.0) < 1e-10) {\r\n        if (basicRow != -1) {\r\n          isBasic = false;\r\n          break;\r\n        }\r\n        basicRow = i;\r\n      } else if (Math.abs(t[i * cols + j]) > 1e-10) {\r\n        isBasic = false;\r\n        break;\r\n      }\r\n    }\r\n    x[j] = isBasic && basicRow != -1 ? t[basicRow * cols + total] : 0.0;\r\n  }\r\n  return x;\r\n}\r\n\r\n/**\r\n * Null-space basis of an `m x n` matrix `A`. Returns the basis vectors\r\n * packed row-major (`count * n` values); the caller derives\r\n * `count = result.length / n`.\r\n */\r\nexport function nullspace(a: Float64Array, m: i32, n: i32): Float64Array {\r\n  if (m <= 0 || n <= 0) return new Float64Array(0);\r\n  const mm = new Float64Array(m * n);\r\n  for (let i = 0; i < m * n; i++) mm[i] = a[i];\r\n  const pcols = new Int32Array(n);\r\n  let npiv: i32 = 0;\r\n  let r: i32 = 0;\r\n\r\n  for (let col = 0; col < n; col++) {\r\n    if (r >= m) break;\r\n    let maxRow: i32 = r;\r\n    let maxVal: f64 = Math.abs(mm[r * n + col]);\r\n    for (let row = r + 1; row < m; row++) {\r\n      const v: f64 = Math.abs(mm[row * n + col]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        maxRow = row;\r\n      }\r\n    }\r\n    if (maxVal < 1e-10) continue;\r\n    if (maxRow != r) {\r\n      for (let j = 0; j < n; j++) {\r\n        const tt: f64 = mm[r * n + j];\r\n        mm[r * n + j] = mm[maxRow * n + j];\r\n        mm[maxRow * n + j] = tt;\r\n      }\r\n    }\r\n    const pivot: f64 = mm[r * n + col];\r\n    for (let j = 0; j < n; j++) mm[r * n + j] /= pivot;\r\n    for (let row = 0; row < m; row++) {\r\n      if (row != r && Math.abs(mm[row * n + col]) > 1e-15) {\r\n        const factor: f64 = mm[row * n + col];\r\n        for (let j = 0; j < n; j++) mm[row * n + j] -= factor * mm[r * n + j];\r\n      }\r\n    }\r\n    pcols[npiv] = col;\r\n    npiv++;\r\n    r++;\r\n  }\r\n\r\n  const count: i32 = n - npiv;\r\n  const out = new Float64Array(count * n);\r\n  let ci: i32 = 0;\r\n  for (let col = 0; col < n; col++) {\r\n    let isPivot: bool = false;\r\n    for (let k = 0; k < npiv; k++) {\r\n      if (pcols[k] == col) {\r\n        isPivot = true;\r\n        break;\r\n      }\r\n    }\r\n    if (isPivot) continue;\r\n    const base: i32 = ci * n;\r\n    out[base + col] = 1.0;\r\n    for (let i = 0; i < npiv; i++) out[base + pcols[i]] = -mm[i * n + col];\r\n    ci++;\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Rational approximation — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../numeric/approx_ext.rs`: partial-fraction residues and\r\n * Padé approximants.\r\n */\r\n\r\nfunction evalPoly(c: Float64Array, x: f64): f64 {\r\n  let s: f64 = 0.0;\r\n  let i: i32 = c.length;\r\n  while (i > 0) {\r\n    i--;\r\n    s = s * x + c[i];\r\n  }\r\n  return s;\r\n}\r\n\r\nfunction evalPolyDeriv(c: Float64Array, x: f64): f64 {\r\n  let s: f64 = 0.0;\r\n  let i: i32 = c.length;\r\n  while (i > 1) {\r\n    i--;\r\n    s = s * x + <f64>i * c[i];\r\n  }\r\n  return s;\r\n}\r\n\r\n/** Real roots of a polynomial via the Durand-Kerner method. */\r\nfunction polyRoots(coeffs: Float64Array): Array<f64> {\r\n  const out = new Array<f64>();\r\n  if (coeffs.length < 2) return out;\r\n  const n: i32 = coeffs.length - 1;\r\n  const lc: f64 = coeffs[n];\r\n  const c = new Float64Array(coeffs.length);\r\n  for (let i = 0; i < coeffs.length; i++) c[i] = coeffs[i] / lc;\r\n\r\n  const re = new Float64Array(n);\r\n  const im = new Float64Array(n);\r\n  for (let i = 0; i < n; i++) {\r\n    const angle: f64 = (2.0 * Math.PI * <f64>i) / <f64>n + 0.4;\r\n    re[i] = 0.4 * Math.cos(angle);\r\n    im[i] = 0.4 * Math.sin(angle);\r\n  }\r\n\r\n  for (let iter = 0; iter < 100; iter++) {\r\n    for (let i = 0; i < n; i++) {\r\n      let pRe: f64 = c[n];\r\n      let pIm: f64 = 0.0;\r\n      let j: i32 = n;\r\n      while (j > 0) {\r\n        j--;\r\n        const nr: f64 = pRe * re[i] - pIm * im[i] + c[j];\r\n        const ni: f64 = pRe * im[i] + pIm * re[i];\r\n        pRe = nr;\r\n        pIm = ni;\r\n      }\r\n      let dRe: f64 = 1.0;\r\n      let dIm: f64 = 0.0;\r\n      for (let k = 0; k < n; k++) {\r\n        if (k == i) continue;\r\n        const diffRe: f64 = re[i] - re[k];\r\n        const diffIm: f64 = im[i] - im[k];\r\n        const nr: f64 = dRe * diffRe - dIm * diffIm;\r\n        const ni: f64 = dRe * diffIm + dIm * diffRe;\r\n        dRe = nr;\r\n        dIm = ni;\r\n      }\r\n      const denom: f64 = dRe * dRe + dIm * dIm;\r\n      if (denom > 1e-30) {\r\n        re[i] -= (pRe * dRe + pIm * dIm) / denom;\r\n        im[i] -= (pIm * dRe - pRe * dIm) / denom;\r\n      }\r\n    }\r\n  }\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    if (Math.abs(im[i]) < 1e-8) out.push(re[i]);\r\n  }\r\n  return out;\r\n}\r\n\r\n/** Solve `A x = b` (`A` is n x n row-major). Returns zeros if singular. */\r\nfunction linsolveAS(a: Float64Array, n: i32, b: Float64Array): Float64Array {\r\n  const w: i32 = n + 1;\r\n  const m = new Float64Array(n * w);\r\n  for (let i = 0; i < n; i++) {\r\n    for (let j = 0; j < n; j++) m[i * w + j] = a[i * n + j];\r\n    m[i * w + n] = b[i];\r\n  }\r\n  for (let col = 0; col < n; col++) {\r\n    let maxRow: i32 = col;\r\n    let maxVal: f64 = Math.abs(m[col * w + col]);\r\n    for (let row = col + 1; row < n; row++) {\r\n      const v: f64 = Math.abs(m[row * w + col]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        maxRow = row;\r\n      }\r\n    }\r\n    if (maxVal < 1e-15) return new Float64Array(n); // singular -> zeros\r\n    if (maxRow != col) {\r\n      for (let j = 0; j < w; j++) {\r\n        const t: f64 = m[col * w + j];\r\n        m[col * w + j] = m[maxRow * w + j];\r\n        m[maxRow * w + j] = t;\r\n      }\r\n    }\r\n    for (let row = col + 1; row < n; row++) {\r\n      const factor: f64 = m[row * w + col] / m[col * w + col];\r\n      for (let j = col; j < w; j++) m[row * w + j] -= factor * m[col * w + j];\r\n    }\r\n  }\r\n  const x = new Float64Array(n);\r\n  let i: i32 = n;\r\n  while (i > 0) {\r\n    i--;\r\n    let s: f64 = m[i * w + n];\r\n    for (let j = i + 1; j < n; j++) s -= m[i * w + j] * x[j];\r\n    x[i] = s / m[i * w + i];\r\n  }\r\n  return x;\r\n}\r\n\r\n/**\r\n * Partial-fraction residues of `P(x)/Q(x)`. Returns a packed\r\n * `Float64Array` `[residues (count) | poles (count)]`; the caller derives\r\n * `count = result.length / 2`.\r\n */\r\nexport function residue(p: Float64Array, q: Float64Array): Float64Array {\r\n  if (p.length <= 0 || q.length <= 1) return new Float64Array(0);\r\n  const poles = polyRoots(q);\r\n  const count: i32 = poles.length;\r\n  const out = new Float64Array(2 * count);\r\n  for (let k = 0; k < count; k++) {\r\n    const pole: f64 = poles[k];\r\n    out[k] = evalPoly(p, pole) / evalPolyDeriv(q, pole);\r\n    out[count + k] = pole;\r\n  }\r\n  return out;\r\n}\r\n\r\n/**\r\n * Padé approximant `[m/n]` from Taylor coefficients. Returns a packed\r\n * `Float64Array` `[numerator (m+1) | denominator (n+1)]`.\r\n */\r\nexport function padeApproximant(coeffs: Float64Array, m: i32, n: i32): Float64Array {\r\n  if (m < 0 || n < 0) return new Float64Array(0);\r\n  const cLen: i32 = coeffs.length > m + n + 1 ? coeffs.length : m + n + 1;\r\n  const c = new Float64Array(cLen);\r\n  for (let i = 0; i < coeffs.length; i++) c[i] = coeffs[i];\r\n\r\n  const out = new Float64Array(m + 1 + n + 1);\r\n  if (n > 0) {\r\n    const a = new Float64Array(n * n);\r\n    const rhs = new Float64Array(n);\r\n    for (let i = 1; i <= n; i++) {\r\n      for (let j = 1; j <= n; j++) {\r\n        const idx: i32 = m + i - j;\r\n        a[(i - 1) * n + (j - 1)] = idx >= 0 && idx < cLen ? c[idx] : 0.0;\r\n      }\r\n      rhs[i - 1] = -c[m + i];\r\n    }\r\n    const b = linsolveAS(a, n, rhs);\r\n    out[m + 1] = 1.0;\r\n    for (let j = 0; j < n; j++) out[m + 1 + j + 1] = b[j];\r\n    for (let i = 0; i <= m; i++) {\r\n      let s: f64 = c[i];\r\n      const jmax: i32 = i < n ? i : n;\r\n      for (let j = 1; j <= jmax; j++) s += b[j - 1] * c[i - j];\r\n      out[i] = s;\r\n    }\r\n  } else {\r\n    for (let i = 0; i <= m; i++) out[i] = c[i];\r\n    out[m + 1] = 1.0;\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Rank-N tensor operations — AssemblyScript fallback mirroring\r\n * `wasm-rust/.../matrix/tensor_ops.rs`.\r\n */\r\n\r\n/**\r\n * Permute the axes of a row-major dense tensor.\r\n *\r\n * `data` is the flat tensor; `shape` and `perm` are same-length arrays\r\n * (passed as `Float64Array`, interpreted as integers). Returns the\r\n * permuted tensor, or an empty array for invalid input.\r\n */\r\nexport function tensorTranspose(\r\n  data: Float64Array,\r\n  shape: Float64Array,\r\n  perm: Float64Array\r\n): Float64Array {\r\n  const rank: i32 = shape.length;\r\n  if (rank <= 0 || rank > 16 || perm.length != rank) {\r\n    return new Float64Array(0);\r\n  }\r\n  const sh = new Int32Array(rank);\r\n  const pm = new Int32Array(rank);\r\n  for (let k = 0; k < rank; k++) {\r\n    sh[k] = <i32>shape[k];\r\n    pm[k] = <i32>perm[k];\r\n    if (sh[k] <= 0 || pm[k] < 0 || pm[k] >= rank) {\r\n      return new Float64Array(0);\r\n    }\r\n  }\r\n\r\n  let total: i32 = 1;\r\n  for (let k = 0; k < rank; k++) total *= sh[k];\r\n\r\n  const outShape = new Int32Array(rank);\r\n  for (let k = 0; k < rank; k++) outShape[k] = sh[pm[k]];\r\n\r\n  const inStrides = new Int32Array(rank);\r\n  const outStrides = new Int32Array(rank);\r\n  let acc: i32 = 1;\r\n  for (let k = rank - 1; k >= 0; k--) {\r\n    inStrides[k] = acc;\r\n    acc *= sh[k];\r\n  }\r\n  acc = 1;\r\n  for (let k = rank - 1; k >= 0; k--) {\r\n    outStrides[k] = acc;\r\n    acc *= outShape[k];\r\n  }\r\n\r\n  const out = new Float64Array(total);\r\n  const idx = new Int32Array(rank);\r\n  for (let n = 0; n < total; n++) {\r\n    let outFlat: i32 = 0;\r\n    let inFlat: i32 = 0;\r\n    for (let k = 0; k < rank; k++) {\r\n      outFlat += idx[k] * outStrides[k];\r\n      inFlat += idx[k] * inStrides[pm[k]];\r\n    }\r\n    out[outFlat] = data[inFlat];\r\n\r\n    let kk: i32 = rank;\r\n    while (kk > 0) {\r\n      kk--;\r\n      idx[kk]++;\r\n      if (idx[kk] < outShape[kk]) break;\r\n      idx[kk] = 0;\r\n    }\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Complex Number Operations for AssemblyScript\r\n *\r\n * Standalone functions for complex number arithmetic.\r\n * These complement the Complex class methods for use cases\r\n * where functional style is preferred.\r\n */\r\n\r\nimport { Complex, complexFromPolar } from '../types/complex';\r\n\r\n// =============================================================================\r\n// Basic Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Add two complex numbers\r\n */\r\nexport function complex_add(a: Complex, b: Complex): Complex {\r\n  return a.add(b);\r\n}\r\n\r\n/**\r\n * Subtract two complex numbers\r\n */\r\nexport function complex_sub(a: Complex, b: Complex): Complex {\r\n  return a.sub(b);\r\n}\r\n\r\n/**\r\n * Multiply two complex numbers\r\n */\r\nexport function complex_mul(a: Complex, b: Complex): Complex {\r\n  return a.mul(b);\r\n}\r\n\r\n/**\r\n * Divide two complex numbers\r\n */\r\nexport function complex_div(a: Complex, b: Complex): Complex {\r\n  return a.div(b);\r\n}\r\n\r\n/**\r\n * Negate a complex number\r\n */\r\nexport function complex_neg(a: Complex): Complex {\r\n  return a.neg();\r\n}\r\n\r\n/**\r\n * Complex conjugate\r\n */\r\nexport function complex_conj(a: Complex): Complex {\r\n  return a.conj();\r\n}\r\n\r\n/**\r\n * Reciprocal (1/z)\r\n */\r\nexport function complex_reciprocal(a: Complex): Complex {\r\n  return a.reciprocal();\r\n}\r\n\r\n// =============================================================================\r\n// Magnitude and Phase\r\n// =============================================================================\r\n\r\n/**\r\n * Absolute value (magnitude)\r\n */\r\nexport function complex_abs(a: Complex): f64 {\r\n  return a.abs();\r\n}\r\n\r\n/**\r\n * Argument (phase angle)\r\n */\r\nexport function complex_arg(a: Complex): f64 {\r\n  return a.arg();\r\n}\r\n\r\n/**\r\n * Squared magnitude (faster than abs^2)\r\n */\r\nexport function complex_abs_squared(a: Complex): f64 {\r\n  return a.re * a.re + a.im * a.im;\r\n}\r\n\r\n// =============================================================================\r\n// Power and Root Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Square root of complex number\r\n */\r\nexport function complex_sqrt(a: Complex): Complex {\r\n  return a.sqrt();\r\n}\r\n\r\n/**\r\n * Complex power: a^n where n is real\r\n */\r\nexport function complex_pow(a: Complex, n: f64): Complex {\r\n  return a.powReal(n);\r\n}\r\n\r\n/**\r\n * Complex to complex power: a^b\r\n */\r\nexport function complex_cpow(a: Complex, b: Complex): Complex {\r\n  // a^b = Math.exp(b * Math.log(a))\r\n  const logA = a.log();\r\n  const product = new Complex(b.re * logA.re - b.im * logA.im, b.re * logA.im + b.im * logA.re);\r\n  return product.exp();\r\n}\r\n\r\n/**\r\n * Square\r\n */\r\nexport function complex_square(a: Complex): Complex {\r\n  return new Complex(a.re * a.re - a.im * a.im, 2.0 * a.re * a.im);\r\n}\r\n\r\n/**\r\n * Cube\r\n */\r\nexport function complex_cube(a: Complex): Complex {\r\n  const re2 = a.re * a.re;\r\n  const im2 = a.im * a.im;\r\n  return new Complex(a.re * (re2 - 3.0 * im2), a.im * (3.0 * re2 - im2));\r\n}\r\n\r\n// =============================================================================\r\n// Exponential and Logarithmic\r\n// =============================================================================\r\n\r\n/**\r\n * Complex exponential\r\n */\r\nexport function complex_exp(a: Complex): Complex {\r\n  return a.exp();\r\n}\r\n\r\n/**\r\n * Complex natural logarithm\r\n */\r\nexport function complex_log(a: Complex): Complex {\r\n  return a.log();\r\n}\r\n\r\n/**\r\n * Complex base-10 logarithm\r\n */\r\nexport function complex_log10(a: Complex): Complex {\r\n  const ln = a.log();\r\n  const ln10 = 2.302585092994046;\r\n  return new Complex(ln.re / ln10, ln.im / ln10);\r\n}\r\n\r\n/**\r\n * Complex base-2 logarithm\r\n */\r\nexport function complex_log2(a: Complex): Complex {\r\n  const ln = a.log();\r\n  const ln2 = 0.6931471805599453;\r\n  return new Complex(ln.re / ln2, ln.im / ln2);\r\n}\r\n\r\n// =============================================================================\r\n// Trigonometric Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Complex sine\r\n */\r\nexport function complex_sin(a: Complex): Complex {\r\n  return a.sin();\r\n}\r\n\r\n/**\r\n * Complex cosine\r\n */\r\nexport function complex_cos(a: Complex): Complex {\r\n  return a.cos();\r\n}\r\n\r\n/**\r\n * Complex tangent\r\n */\r\nexport function complex_tan(a: Complex): Complex {\r\n  return a.tan();\r\n}\r\n\r\n/**\r\n * Complex arc sine\r\n */\r\nexport function complex_asin(a: Complex): Complex {\r\n  return a.asin();\r\n}\r\n\r\n/**\r\n * Complex arc cosine\r\n */\r\nexport function complex_acos(a: Complex): Complex {\r\n  return a.acos();\r\n}\r\n\r\n/**\r\n * Complex arc tangent\r\n */\r\nexport function complex_atan(a: Complex): Complex {\r\n  return a.atan();\r\n}\r\n\r\n// =============================================================================\r\n// Hyperbolic Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Complex hyperbolic sine\r\n */\r\nexport function complex_sinh(a: Complex): Complex {\r\n  return a.sinh();\r\n}\r\n\r\n/**\r\n * Complex hyperbolic cosine\r\n */\r\nexport function complex_cosh(a: Complex): Complex {\r\n  return a.cosh();\r\n}\r\n\r\n/**\r\n * Complex hyperbolic tangent\r\n */\r\nexport function complex_tanh(a: Complex): Complex {\r\n  return a.tanh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic sine\r\n */\r\nexport function complex_asinh(a: Complex): Complex {\r\n  return a.asinh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic cosine\r\n */\r\nexport function complex_acosh(a: Complex): Complex {\r\n  return a.acosh();\r\n}\r\n\r\n/**\r\n * Complex inverse hyperbolic tangent\r\n */\r\nexport function complex_atanh(a: Complex): Complex {\r\n  return a.atanh();\r\n}\r\n\r\n// =============================================================================\r\n// Utility Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Check equality (exact)\r\n */\r\nexport function complex_equals(a: Complex, b: Complex): bool {\r\n  return a.equals(b);\r\n}\r\n\r\n/**\r\n * Check approximate equality\r\n */\r\nexport function complex_approx_equals(a: Complex, b: Complex, tolerance: f64): bool {\r\n  return a.approxEquals(b, tolerance);\r\n}\r\n\r\n/**\r\n * Check if complex number is zero\r\n */\r\nexport function complex_is_zero(a: Complex): bool {\r\n  return a.isZero();\r\n}\r\n\r\n/**\r\n * Check if complex number is real (imaginary part is zero)\r\n */\r\nexport function complex_is_real(a: Complex): bool {\r\n  return a.isReal();\r\n}\r\n\r\n/**\r\n * Check if complex number is purely imaginary\r\n */\r\nexport function complex_is_imaginary(a: Complex): bool {\r\n  return a.isImaginary();\r\n}\r\n\r\n/**\r\n * Check if complex number is NaN\r\n */\r\nexport function complex_is_nan(a: Complex): bool {\r\n  return isNaN(a.re) || isNaN(a.im);\r\n}\r\n\r\n/**\r\n * Check if complex number is finite\r\n */\r\nexport function complex_is_finite(a: Complex): bool {\r\n  return isFinite(a.re) && isFinite(a.im);\r\n}\r\n\r\n// =============================================================================\r\n// Construction Helpers\r\n// =============================================================================\r\n\r\n/**\r\n * Create complex from real part only\r\n */\r\nexport function complex_from_real(re: f64): Complex {\r\n  return new Complex(re, 0.0);\r\n}\r\n\r\n/**\r\n * Create complex from imaginary part only\r\n */\r\nexport function complex_from_imag(im: f64): Complex {\r\n  return new Complex(0.0, im);\r\n}\r\n\r\n/**\r\n * Create complex from polar coordinates\r\n */\r\nexport function complex_from_polar(r: f64, theta: f64): Complex {\r\n  return complexFromPolar(r, theta);\r\n}\r\n\r\n/**\r\n * Convert to polar: returns [r, theta]\r\n */\r\nexport function complex_to_polar(a: Complex): Float64Array {\r\n  const result = new Float64Array(2);\r\n  unchecked((result[0] = a.abs()));\r\n  unchecked((result[1] = a.arg()));\r\n  return result;\r\n}\r\n\r\n// =============================================================================\r\n// Linear Algebra Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Linear combination: alpha*a + beta*b\r\n */\r\nexport function complex_axpby(alpha: Complex, a: Complex, beta: Complex, b: Complex): Complex {\r\n  return alpha.mul(a).add(beta.mul(b));\r\n}\r\n\r\n/**\r\n * Euclidean distance between two complex numbers\r\n */\r\nexport function complex_distance(a: Complex, b: Complex): f64 {\r\n  const diff = a.sub(b);\r\n  return diff.abs();\r\n}\r\n","/**\r\n * Bitwise Operations for AssemblyScript\r\n *\r\n * High-performance elementwise bitwise operations on Int32Array buffers.\r\n * Mirrors the seven JS bitwise ops exposed by\r\n * `functions/src/typed/bitwise.ts` (bitAnd / bitOr / bitXor / bitNot /\r\n * leftShift / rightArithShift / rightLogShift).\r\n *\r\n * Calling convention follows the existing AS array ops (`ops/array.ts`):\r\n * pass high-level TypedArray references; the AS loader handles\r\n * marshaling. Each binary kernel takes (a, b, result); the unary takes\r\n * (a, result); the shift kernels also take per-element shift counts\r\n * stored in a parallel `Int32Array`.\r\n *\r\n * The legacy scalar bitwise primitives live in the Rust WASM crate\r\n * (`wasm-rust/crates/mathts-wasm/src/bitwise/operations.rs`); these\r\n * elementwise variants are what `functions/src/typed/bitwise.ts`\r\n * dispatches to for large `Int32Array` inputs when the AS backend is\r\n * selected via `MATHJS_WASM_BACKEND=assemblyscript`.\r\n */\r\n\r\n/**\r\n * Element-wise bitwise AND: result = a & b\r\n */\r\nexport function bitAnd_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) & unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise bitwise OR: result = a | b\r\n */\r\nexport function bitOr_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) | unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise bitwise XOR: result = a ^ b\r\n */\r\nexport function bitXor_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) ^ unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise bitwise NOT: result = ~a\r\n */\r\nexport function bitNot_i32_array(a: Int32Array, result: Int32Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = ~unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise left shift: result[i] = a[i] << (b[i] & 31)\r\n *\r\n * AssemblyScript's `<<` on `i32` masks the shift count modulo 32, which\r\n * matches JavaScript semantics on Int32Array members.\r\n */\r\nexport function leftShift_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) << unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise arithmetic (sign-preserving) right shift:\r\n *   result[i] = a[i] >> (b[i] & 31)\r\n */\r\nexport function rightArithShift_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) >> unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Element-wise logical (zero-fill) right shift:\r\n *   result[i] = (a[i] >>> b[i]) reinterpreted as i32\r\n *\r\n * AssemblyScript provides `>>>` over u32; we cast through u32 to mirror\r\n * JS `(a[i] >>> b[i]) | 0` semantics — the high bit becomes negative on\r\n * values ≥ 2^31.\r\n */\r\nexport function rightLogShift_i32_array(a: Int32Array, b: Int32Array, result: Int32Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    const av = unchecked(a[i]) as u32;\r\n    const sh = unchecked(b[i]) as u32;\r\n    unchecked((result[i] = (av >>> sh) as i32));\r\n  }\r\n}\r\n","/**\r\n * Polynomial hot-loop kernels — AssemblyScript parity port.\r\n *\r\n * These two exports mirror the Rust kernels in\r\n * `wasm-rust/crates/mathts-wasm/src/poly.rs`.\r\n *\r\n * Naming uses snake_case to match the Rust export surface so the\r\n * bridge can probe for either backend with the same name lookup.\r\n *\r\n * Polynomials are coefficient arrays, constant term first (index = power):\r\n *   p(x) = a[0] + a[1]*x + a[2]*x^2 + …\r\n */\r\n\r\n// ---------------------------------------------------------------------------\r\n// poly_mul_f64  — O(n·m) convolution\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Multiply polynomials `a` and `b`.\r\n * Returns a `Float64Array` of length `a.length + b.length - 1`,\r\n * or `[0.0]` if either operand is empty.\r\n */\r\nexport function poly_mul_f64(a: Float64Array, b: Float64Array): Float64Array {\r\n  if (a.length == 0 || b.length == 0) {\r\n    const z = new Float64Array(1);\r\n    z[0] = 0.0;\r\n    return z;\r\n  }\r\n  const outLen: i32 = a.length + b.length - 1;\r\n  const out = new Float64Array(outLen);\r\n  for (let i = 0; i < outLen; i++) out[i] = 0.0;\r\n  for (let i = 0; i < a.length; i++) {\r\n    const ai = a[i];\r\n    for (let j = 0; j < b.length; j++) {\r\n      out[i + j] += ai * b[j];\r\n    }\r\n  }\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal helpers for resultant / discriminant\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Trim trailing zero coefficients, keeping at least one element. */\r\nfunction trimCoeffs(c: Float64Array): Float64Array {\r\n  if (c.length == 0) {\r\n    const z = new Float64Array(1);\r\n    z[0] = 0.0;\r\n    return z;\r\n  }\r\n  let end: i32 = c.length - 1;\r\n  while (end > 0 && c[end] == 0.0) end--;\r\n  const out = new Float64Array(end + 1);\r\n  for (let i: i32 = 0; i <= end; i++) out[i] = c[i];\r\n  return out;\r\n}\r\n\r\n/**\r\n * Gaussian-elimination determinant of a row-major `n × n` matrix\r\n * stored in a flat Float64Array.\r\n */\r\nfunction detSquare(flat: Float64Array, n: i32): f64 {\r\n  // Copy into a mutable work buffer.\r\n  const m = new Float64Array(n * n);\r\n  for (let i: i32 = 0; i < n * n; i++) m[i] = flat[i];\r\n\r\n  let det: f64 = 1.0;\r\n  for (let col: i32 = 0; col < n; col++) {\r\n    // Partial pivoting.\r\n    let maxRow: i32 = col;\r\n    let maxVal: f64 = Math.abs(m[col * n + col]);\r\n    for (let row: i32 = col + 1; row < n; row++) {\r\n      const v: f64 = Math.abs(m[row * n + col]);\r\n      if (v > maxVal) {\r\n        maxVal = v;\r\n        maxRow = row;\r\n      }\r\n    }\r\n    if (maxVal < 1e-15) return 0.0;\r\n    if (maxRow != col) {\r\n      for (let k: i32 = 0; k < n; k++) {\r\n        const tmp: f64 = m[col * n + k];\r\n        m[col * n + k] = m[maxRow * n + k];\r\n        m[maxRow * n + k] = tmp;\r\n      }\r\n      det = -det;\r\n    }\r\n    det *= m[col * n + col];\r\n    for (let row: i32 = col + 1; row < n; row++) {\r\n      const factor: f64 = m[row * n + col] / m[col * n + col];\r\n      for (let k: i32 = col; k < n; k++) {\r\n        m[row * n + k] -= factor * m[col * n + k];\r\n      }\r\n    }\r\n  }\r\n  return det;\r\n}\r\n\r\n/** Build the (m+n) × (m+n) Sylvester matrix and return its determinant. */\r\nfunction sylvesterDet(p: Float64Array, q: Float64Array): f64 {\r\n  const pt = trimCoeffs(p);\r\n  const qt = trimCoeffs(q);\r\n  const m: i32 = pt.length - 1; // degree of p\r\n  const n: i32 = qt.length - 1; // degree of q\r\n  if (m == 0 && n == 0) return 1.0;\r\n  if (m == 0) return Math.pow(pt[0], <f64>n);\r\n  if (n == 0) return Math.pow(qt[0], <f64>m);\r\n  const size: i32 = m + n;\r\n  const mat = new Float64Array(size * size);\r\n  // First n rows: shifted copies of p (highest-degree first).\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    for (let j: i32 = 0; j <= m; j++) {\r\n      mat[i * size + (i + j)] = pt[m - j];\r\n    }\r\n  }\r\n  // Next m rows: shifted copies of q (highest-degree first).\r\n  for (let i: i32 = 0; i < m; i++) {\r\n    for (let j: i32 = 0; j <= n; j++) {\r\n      mat[(n + i) * size + (i + j)] = qt[n - j];\r\n    }\r\n  }\r\n  return detSquare(mat, size);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// poly_div_mod_f64  — polynomial long division\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Divide polynomial `num` by `den`.\r\n *\r\n * Returns a concatenated `Float64Array`:\r\n *   `[ quotient (q_len elements) | remainder (r_len elements) ]`\r\n *\r\n * where:\r\n *   q_len  = max(0, num.length - den.length + 1)  when den.length <= num.length\r\n *   q_len  = 0                                    when den.length  > num.length\r\n *   r_len  = den.length - 1                        (un-trimmed; caller trims)\r\n *\r\n * Returns `[NaN]` when `den` is empty (division by zero).\r\n */\r\nexport function poly_div_mod_f64(num: Float64Array, den: Float64Array): Float64Array {\r\n  if (den.length == 0) {\r\n    const e = new Float64Array(1);\r\n    e[0] = NaN;\r\n    return e;\r\n  }\r\n\r\n  const numLen: i32 = num.length;\r\n  const denLen: i32 = den.length;\r\n\r\n  // degree(num) < degree(den): quotient = 0, remainder = num\r\n  if (numLen < denLen) {\r\n    const out = new Float64Array(numLen);\r\n    for (let i = 0; i < numLen; i++) out[i] = num[i];\r\n    return out;\r\n  }\r\n\r\n  const qLen: i32 = numLen - denLen + 1;\r\n  const rMax: i32 = denLen - 1;\r\n\r\n  // Work buffer (copy of num).\r\n  const work = new Float64Array(numLen);\r\n  for (let i = 0; i < numLen; i++) work[i] = num[i];\r\n\r\n  const bn = den[denLen - 1];\r\n\r\n  const quotient = new Float64Array(qLen);\r\n  for (let i = 0; i < qLen; i++) quotient[i] = 0.0;\r\n\r\n  // Long division, highest degree first.\r\n  let ii: i32 = 0;\r\n  while (ii < qLen) {\r\n    const i: i32 = numLen - 1 - ii;\r\n    const q = work[i] / bn;\r\n    quotient[i - denLen + 1] = q;\r\n    for (let j: i32 = 0; j < denLen; j++) {\r\n      work[i - denLen + 1 + j] -= q * den[j];\r\n    }\r\n    ii++;\r\n  }\r\n\r\n  const rLen: i32 = rMax < numLen ? rMax : numLen;\r\n  const totalLen: i32 = qLen + rLen;\r\n  const out = new Float64Array(totalLen);\r\n  for (let i: i32 = 0; i < qLen; i++) out[i] = quotient[i];\r\n  for (let i: i32 = 0; i < rLen; i++) out[qLen + i] = work[i];\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// poly_resultant_f64  — Sylvester-matrix determinant\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Compute the resultant of polynomials `p` and `q`.\r\n * Returns NaN when either input is empty.\r\n */\r\nexport function poly_resultant_f64(p: Float64Array, q: Float64Array): f64 {\r\n  if (p.length == 0 || q.length == 0) return NaN;\r\n  return sylvesterDet(p, q);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Internal Householder QR least-squares solver\r\n// Used by poly_fit_f64 / cheb_fit_f64 / legendre_fit_f64.\r\n// a: Float64Array of shape n×k row-major (modified in-place)\r\n// b: Float64Array length n (right-hand side, modified in-place → solution)\r\n// Returns true on success, false on rank-deficient input.\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction householderQRSolve(a: Float64Array, n: i32, k: i32, b: Float64Array): bool {\r\n  const tol: f64 = 1e-12;\r\n\r\n  for (let col: i32 = 0; col < k; col++) {\r\n    // Compute norm of column col from row col downward.\r\n    let norm2: f64 = 0.0;\r\n    for (let row: i32 = col; row < n; row++) {\r\n      const v: f64 = a[row * k + col];\r\n      norm2 += v * v;\r\n    }\r\n    const norm: f64 = Math.sqrt(norm2);\r\n    if (norm < tol) return false;\r\n\r\n    const sign: f64 = a[col * k + col] >= 0.0 ? 1.0 : -1.0;\r\n    const u1: f64 = a[col * k + col] + sign * norm;\r\n    let vtv: f64 = u1 * u1;\r\n    for (let row: i32 = col + 1; row < n; row++) {\r\n      vtv += a[row * k + col] * a[row * k + col];\r\n    }\r\n    const tau: f64 = 2.0 / vtv;\r\n\r\n    // Apply H to columns col..k of A.\r\n    for (let c: i32 = col; c < k; c++) {\r\n      let dot: f64 = u1 * a[col * k + c];\r\n      for (let row: i32 = col + 1; row < n; row++) {\r\n        dot += a[row * k + col] * a[row * k + c];\r\n      }\r\n      dot *= tau;\r\n      a[col * k + c] -= u1 * dot;\r\n      for (let row: i32 = col + 1; row < n; row++) {\r\n        a[row * k + c] -= a[row * k + col] * dot;\r\n      }\r\n    }\r\n\r\n    // Apply H to b[col..n].\r\n    {\r\n      let dot: f64 = u1 * b[col];\r\n      for (let row: i32 = col + 1; row < n; row++) {\r\n        dot += a[row * k + col] * b[row];\r\n      }\r\n      dot *= tau;\r\n      b[col] -= u1 * dot;\r\n      for (let row: i32 = col + 1; row < n; row++) {\r\n        b[row] -= a[row * k + col] * dot;\r\n      }\r\n    }\r\n\r\n    // Update R diagonal and clear sub-diagonal.\r\n    a[col * k + col] = -sign * norm;\r\n    for (let row: i32 = col + 1; row < n; row++) {\r\n      a[row * k + col] = 0.0;\r\n    }\r\n  }\r\n\r\n  // Back-substitution.\r\n  for (let i: i32 = k - 1; i >= 0; i--) {\r\n    let s: f64 = b[i];\r\n    for (let j: i32 = i + 1; j < k; j++) {\r\n      s -= a[i * k + j] * b[j];\r\n    }\r\n    const r_ii: f64 = a[i * k + i];\r\n    if (Math.abs(r_ii) < tol) return false;\r\n    b[i] = s / r_ii;\r\n  }\r\n  return true;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// poly_fit_f64  — Vandermonde + QR least-squares polynomial fit\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Fit a polynomial of given degree to (xs, ys) using Vandermonde + QR.\r\n * Returns a Float64Array of length (degree+1) with coefficients [a0..a_d],\r\n * or a length-1 array containing NaN on rank-deficient input.\r\n */\r\nexport function poly_fit_f64(xs: Float64Array, ys: Float64Array, degree: i32): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const k: i32 = degree + 1;\r\n  const nanResult = new Float64Array(1);\r\n  nanResult[0] = NaN;\r\n  if (n < k || k <= 0 || n != ys.length) return nanResult;\r\n\r\n  // Build Vandermonde matrix (n × k), row-major.\r\n  const a = new Float64Array(n * k);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const x: f64 = xs[i];\r\n    let xpow: f64 = 1.0;\r\n    for (let j: i32 = 0; j < k; j++) {\r\n      a[i * k + j] = xpow;\r\n      xpow *= x;\r\n    }\r\n  }\r\n\r\n  // Copy ys into work buffer (modified in-place by QR solver).\r\n  const b = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) b[i] = ys[i];\r\n\r\n  if (!householderQRSolve(a, n, k, b)) return nanResult;\r\n\r\n  const out = new Float64Array(k);\r\n  for (let j: i32 = 0; j < k; j++) out[j] = b[j];\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// cheb_fit_f64  — Chebyshev-basis + QR least-squares fit\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Fit a Chebyshev-series of given degree to (xs, ys) using QR.\r\n * Returns a Float64Array of coefficients [c0..c_d] (Chebyshev basis),\r\n * or a length-1 NaN array on rank-deficient input.\r\n */\r\nexport function cheb_fit_f64(xs: Float64Array, ys: Float64Array, degree: i32): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const k: i32 = degree + 1;\r\n  const nanResult = new Float64Array(1);\r\n  nanResult[0] = NaN;\r\n  if (n < k || k <= 0 || n != ys.length) return nanResult;\r\n\r\n  // Build Chebyshev Vandermonde (n × k), row-major.\r\n  const a = new Float64Array(n * k);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const x: f64 = xs[i];\r\n    let tPrev: f64 = 1.0;\r\n    let tCurr: f64 = x;\r\n    a[i * k + 0] = tPrev;\r\n    if (k > 1) a[i * k + 1] = tCurr;\r\n    for (let j: i32 = 2; j < k; j++) {\r\n      const tNext: f64 = 2.0 * x * tCurr - tPrev;\r\n      a[i * k + j] = tNext;\r\n      tPrev = tCurr;\r\n      tCurr = tNext;\r\n    }\r\n  }\r\n\r\n  const b = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) b[i] = ys[i];\r\n\r\n  if (!householderQRSolve(a, n, k, b)) return nanResult;\r\n\r\n  const out = new Float64Array(k);\r\n  for (let j: i32 = 0; j < k; j++) out[j] = b[j];\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// legendre_fit_f64  — Legendre-basis + QR least-squares fit\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Fit a Legendre-series of given degree to (xs, ys) using QR.\r\n * Returns a Float64Array of coefficients [c0..c_d] (Legendre basis),\r\n * or a length-1 NaN array on rank-deficient input.\r\n */\r\nexport function legendre_fit_f64(xs: Float64Array, ys: Float64Array, degree: i32): Float64Array {\r\n  const n: i32 = xs.length;\r\n  const k: i32 = degree + 1;\r\n  const nanResult = new Float64Array(1);\r\n  nanResult[0] = NaN;\r\n  if (n < k || k <= 0 || n != ys.length) return nanResult;\r\n\r\n  // Build Legendre Vandermonde (n × k), row-major.\r\n  const a = new Float64Array(n * k);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    const x: f64 = xs[i];\r\n    let pPrev: f64 = 1.0;\r\n    let pCurr: f64 = x;\r\n    a[i * k + 0] = pPrev;\r\n    if (k > 1) a[i * k + 1] = pCurr;\r\n    for (let degN: i32 = 1; degN < k - 1; degN++) {\r\n      // (degN+1) P_{degN+1} = (2*degN+1)*x*P_{degN} - degN*P_{degN-1}\r\n      const pNext: f64 =\r\n        (<f64>(2 * degN + 1) * x * pCurr - <f64>degN * pPrev) / <f64>(degN + 1);\r\n      a[i * k + degN + 1] = pNext;\r\n      pPrev = pCurr;\r\n      pCurr = pNext;\r\n    }\r\n  }\r\n\r\n  const b = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) b[i] = ys[i];\r\n\r\n  if (!householderQRSolve(a, n, k, b)) return nanResult;\r\n\r\n  const out = new Float64Array(k);\r\n  for (let j: i32 = 0; j < k; j++) out[j] = b[j];\r\n  return out;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// poly_discriminant_f64  — disc(p) = (-1)^(m(m-1)/2) / a_m · Res(p, p')\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Compute the discriminant of polynomial `p`.\r\n * Returns NaN for degree < 1 inputs.\r\n */\r\nexport function poly_discriminant_f64(p: Float64Array): f64 {\r\n  if (p.length == 0) return NaN;\r\n  const t = trimCoeffs(p);\r\n  const deg: i32 = t.length - 1;\r\n  if (deg < 1) return NaN;\r\n  if (deg == 1) return 1.0;\r\n  if (deg == 2) {\r\n    const c = t[0];\r\n    const b = t[1];\r\n    const a = t[2];\r\n    return b * b - 4.0 * a * c;\r\n  }\r\n  if (deg == 3) {\r\n    const d = t[0];\r\n    const c = t[1];\r\n    const b = t[2];\r\n    const a = t[3];\r\n    return (\r\n      18.0 * a * b * c * d -\r\n      4.0 * b * b * b * d +\r\n      b * b * c * c -\r\n      4.0 * a * c * c * c -\r\n      27.0 * a * a * d * d\r\n    );\r\n  }\r\n  // deg >= 4: disc(p) = (-1)^(deg*(deg-1)/2) / a_deg * Res(p, p')\r\n  const fp = new Float64Array(deg);\r\n  for (let i: i32 = 1; i <= deg; i++) {\r\n    fp[i - 1] = t[i] * <f64>i;\r\n  }\r\n  const res = sylvesterDet(t, fp);\r\n  const an = t[t.length - 1];\r\n  const exponent: i32 = (deg * (deg - 1)) / 2;\r\n  const sign: f64 = exponent % 2 == 0 ? 1.0 : -1.0;\r\n  return (sign * res) / an;\r\n}\r\n","/**\r\n * Tridiagonal-solve kernel — AssemblyScript parity port (Slice 3.10b).\r\n * Divided-difference kernel — AssemblyScript parity port (Slice 5.5).\r\n *\r\n * Solves a tridiagonal linear system A·x = rhs in O(n) using the\r\n * Thomas algorithm (forward-sweep + back-substitution).\r\n *\r\n * Parameters:\r\n *   diag  — main diagonal,    length n\r\n *   lower — sub-diagonal,     length n-1  (lower[i] = row i+1, col i)\r\n *   upper — super-diagonal,   length n-1  (upper[i] = row i,   col i+1)\r\n *   rhs   — right-hand side,  length n\r\n *\r\n * Returns Float64Array of length n containing the solution x.\r\n * Returns a zero-length Float64Array on a singular (zero-pivot) system.\r\n *\r\n * Mirrors `tridiag_solve_f64` in\r\n * wasm-rust/crates/mathts-wasm/src/tridiag.rs.\r\n */\r\n\r\nexport function tridiag_solve_f64(\r\n  diag: Float64Array,\r\n  lower: Float64Array,\r\n  upper: Float64Array,\r\n  rhs: Float64Array,\r\n): Float64Array {\r\n  const n: i32 = diag.length;\r\n\r\n  if (n == 0) {\r\n    return new Float64Array(0);\r\n  }\r\n\r\n  if (n == 1) {\r\n    const d0 = diag[0];\r\n    if (d0 == 0.0) return new Float64Array(0); // singular\r\n    const result = new Float64Array(1);\r\n    result[0] = rhs[0] / d0;\r\n    return result;\r\n  }\r\n\r\n  // Forward sweep — modified super-diagonal c[] and modified rhs d[].\r\n  const c = new Float64Array(n - 1);\r\n  const d = new Float64Array(n);\r\n\r\n  const d0 = diag[0];\r\n  if (d0 == 0.0) return new Float64Array(0); // singular\r\n  c[0] = upper[0] / d0;\r\n  d[0] = rhs[0] / d0;\r\n\r\n  for (let i: i32 = 1; i < n - 1; i++) {\r\n    const lower_im1 = lower[i - 1];\r\n    const m = diag[i] - lower_im1 * c[i - 1];\r\n    if (m == 0.0) return new Float64Array(0); // singular\r\n    c[i] = upper[i] / m;\r\n    d[i] = (rhs[i] - lower_im1 * d[i - 1]) / m;\r\n  }\r\n\r\n  // Last row.\r\n  const lower_nm2 = lower[n - 2];\r\n  const m_last = diag[n - 1] - lower_nm2 * c[n - 2];\r\n  if (m_last == 0.0) return new Float64Array(0); // singular\r\n  d[n - 1] = (rhs[n - 1] - lower_nm2 * d[n - 2]) / m_last;\r\n\r\n  // Back substitution.\r\n  const x = new Float64Array(n);\r\n  x[n - 1] = d[n - 1];\r\n  for (let i: i32 = n - 2; i >= 0; i--) {\r\n    x[i] = d[i] - c[i] * x[i + 1];\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n// ============================================================================\r\n// divided_difference_f64 — Newton's divided-difference coefficients (Slice 5.5)\r\n// ============================================================================\r\n\r\n/**\r\n * Compute Newton's divided-difference coefficients for polynomial interpolation.\r\n *\r\n * Given n distinct nodes (x_0, y_0) … (x_{n-1}, y_{n-1}), returns a\r\n * Float64Array of n Newton-form coefficients c_0 … c_{n-1} such that the\r\n * interpolating polynomial is:\r\n *\r\n *   P(x) = c_0 + c_1·(x-x_0) + c_2·(x-x_0)(x-x_1) + …\r\n *\r\n * Returns a zero-length Float64Array when any two x-values are equal\r\n * (degenerate / rank-deficient input), matching the AS convention from\r\n * tridiag_solve_f64.\r\n *\r\n * Mirrors `divided_difference_f64` in\r\n * wasm-rust/crates/mathts-wasm/src/tridiag.rs.\r\n */\r\nexport function divided_difference_f64(\r\n  xs: Float64Array,\r\n  ys: Float64Array,\r\n): Float64Array {\r\n  const n: i32 = xs.length;\r\n\r\n  if (n == 0) {\r\n    return new Float64Array(0);\r\n  }\r\n\r\n  // Initialise work buffer with y-values.\r\n  const out = new Float64Array(n);\r\n  for (let i: i32 = 0; i < n; i++) {\r\n    out[i] = ys[i];\r\n  }\r\n\r\n  // In-place divided-difference computation.\r\n  for (let j: i32 = 1; j < n; j++) {\r\n    for (let i: i32 = n - 1; i >= j; i--) {\r\n      const denom: f64 = xs[i] - xs[i - j];\r\n      if (denom == 0.0) {\r\n        return new Float64Array(0); // duplicate x → degenerate\r\n      }\r\n      out[i] = (out[i] - out[i - 1]) / denom;\r\n    }\r\n  }\r\n\r\n  return out;\r\n}\r\n","/**\r\n * Sort hot-loop kernels — AssemblyScript parity port (Slice 5.7a).\r\n *\r\n * Mirrors the algorithms in:\r\n *   wasm-rust/crates/mathts-wasm/src/sort.rs\r\n *\r\n * Three exported functions:\r\n *   - `sort_f64`    — in-place ascending sort (NaN-last, typed-array ABI).\r\n *   - `argsort_f64` — return Int32Array of permutation indices (NaN-last).\r\n *   - `rank_f64`    — return Int32Array of ranks (0-indexed, NaN-last).\r\n *\r\n * AssemblyScript does not expose a built-in generic sort with a custom\r\n * comparator that works on value types at compile-time; the simplest\r\n * portable approach is an insertion sort (O(n²)) for small arrays and a\r\n * recursive quicksort for larger ones.  Since these kernels are only called\r\n * above a 16 K threshold via the bridge, the n²-degenerate case on\r\n * already-sorted input is avoided by a median-of-three pivot.\r\n *\r\n * NaN ordering: NaN sorts after all finite values (NaN-last), matching the\r\n * Rust kernel and JS `Array.prototype.sort`.\r\n */\r\n\r\n// ---------------------------------------------------------------------------\r\n// Comparator helper (NaN-last total order)\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Returns negative if a < b, 0 if a == b, positive if a > b. NaN > finite. */\r\n@inline\r\nfunction cmpNanLast(a: f64, b: f64): i32 {\r\n  // Both finite / equal?\r\n  if (a < b) return -1;\r\n  if (a > b) return 1;\r\n  if (a == b) return 0;\r\n  // At least one is NaN.\r\n  if (isNaN(a) && isNaN(b)) return 0;\r\n  if (isNaN(a)) return 1;   // a is NaN → a > b (NaN-last)\r\n  return -1;                 // b is NaN → a < b\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Quicksort helpers (operate on Float64Array in place)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _medianOfThree(arr: Float64Array, lo: i32, hi: i32): i32 {\r\n  const mid: i32 = lo + ((hi - lo) >> 1);\r\n  // Sort lo, mid, hi and return the median index.\r\n  if (cmpNanLast(arr[lo], arr[mid]) > 0) {\r\n    const t = arr[lo]; arr[lo] = arr[mid]; arr[mid] = t;\r\n  }\r\n  if (cmpNanLast(arr[lo], arr[hi]) > 0) {\r\n    const t = arr[lo]; arr[lo] = arr[hi]; arr[hi] = t;\r\n  }\r\n  if (cmpNanLast(arr[mid], arr[hi]) > 0) {\r\n    const t = arr[mid]; arr[mid] = arr[hi]; arr[hi] = t;\r\n  }\r\n  return mid;\r\n}\r\n\r\n/** In-place quicksort on arr[lo..hi] (inclusive). */\r\nfunction _qsort(arr: Float64Array, lo: i32, hi: i32): void {\r\n  if (hi - lo < 16) {\r\n    // Insertion sort for small ranges.\r\n    for (let i: i32 = lo + 1; i <= hi; i++) {\r\n      const key: f64 = arr[i];\r\n      let j: i32 = i - 1;\r\n      while (j >= lo && cmpNanLast(arr[j], key) > 0) {\r\n        arr[j + 1] = arr[j];\r\n        j--;\r\n      }\r\n      arr[j + 1] = key;\r\n    }\r\n    return;\r\n  }\r\n  // Median-of-three pivot — swap to hi.\r\n  const pivIdx: i32 = _medianOfThree(arr, lo, hi);\r\n  const pivot: f64 = arr[pivIdx];\r\n  const t = arr[pivIdx]; arr[pivIdx] = arr[hi]; arr[hi] = t;\r\n\r\n  let i: i32 = lo - 1;\r\n  for (let j: i32 = lo; j < hi; j++) {\r\n    if (cmpNanLast(arr[j], pivot) <= 0) {\r\n      i++;\r\n      const tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;\r\n    }\r\n  }\r\n  const pivFinal: i32 = i + 1;\r\n  const tmp2 = arr[pivFinal]; arr[pivFinal] = arr[hi]; arr[hi] = tmp2;\r\n\r\n  _qsort(arr, lo, pivFinal - 1);\r\n  _qsort(arr, pivFinal + 1, hi);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Quicksort on Int32Array by Float64Array key (for argsort)\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction _medianOfThreeIdx(data: Float64Array, idx: Int32Array, lo: i32, hi: i32): i32 {\r\n  const mid: i32 = lo + ((hi - lo) >> 1);\r\n  if (cmpNanLast(data[idx[lo]], data[idx[mid]]) > 0) {\r\n    const t = idx[lo]; idx[lo] = idx[mid]; idx[mid] = t;\r\n  }\r\n  if (cmpNanLast(data[idx[lo]], data[idx[hi]]) > 0) {\r\n    const t = idx[lo]; idx[lo] = idx[hi]; idx[hi] = t;\r\n  }\r\n  if (cmpNanLast(data[idx[mid]], data[idx[hi]]) > 0) {\r\n    const t = idx[mid]; idx[mid] = idx[hi]; idx[hi] = t;\r\n  }\r\n  return mid;\r\n}\r\n\r\n/** Sort idx[lo..hi] by data[idx[i]] (ascending, NaN-last). */\r\nfunction _qsortIdx(data: Float64Array, idx: Int32Array, lo: i32, hi: i32): void {\r\n  if (hi - lo < 16) {\r\n    for (let i: i32 = lo + 1; i <= hi; i++) {\r\n      const key: i32 = idx[i];\r\n      const keyVal: f64 = data[key];\r\n      let j: i32 = i - 1;\r\n      while (j >= lo && cmpNanLast(data[idx[j]], keyVal) > 0) {\r\n        idx[j + 1] = idx[j];\r\n        j--;\r\n      }\r\n      idx[j + 1] = key;\r\n    }\r\n    return;\r\n  }\r\n  const pivIdx: i32 = _medianOfThreeIdx(data, idx, lo, hi);\r\n  const pivVal: f64 = data[idx[pivIdx]];\r\n  const t = idx[pivIdx]; idx[pivIdx] = idx[hi]; idx[hi] = t;\r\n\r\n  let i: i32 = lo - 1;\r\n  for (let j: i32 = lo; j < hi; j++) {\r\n    if (cmpNanLast(data[idx[j]], pivVal) <= 0) {\r\n      i++;\r\n      const tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;\r\n    }\r\n  }\r\n  const pivFinal: i32 = i + 1;\r\n  const tmp2 = idx[pivFinal]; idx[pivFinal] = idx[hi]; idx[hi] = tmp2;\r\n\r\n  _qsortIdx(data, idx, lo, pivFinal - 1);\r\n  _qsortIdx(data, idx, pivFinal + 1, hi);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Public exports (typed-array ABI)\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Sort `data` in place, ascending, NaN-last.\r\n * Returns the same `data` array for convenience.\r\n */\r\nexport function sort_f64(data: Float64Array): Float64Array {\r\n  const n: i32 = data.length;\r\n  if (n > 1) _qsort(data, 0, n - 1);\r\n  return data;\r\n}\r\n\r\n/**\r\n * Return an Int32Array of permutation indices (argsort).\r\n * After the call, `data[result[0]] ≤ data[result[1]] ≤ …` (NaN-last).\r\n */\r\nexport function argsort_f64(data: Float64Array): Int32Array {\r\n  const n: i32 = data.length;\r\n  const idx = new Int32Array(n);\r\n  for (let i: i32 = 0; i < n; i++) idx[i] = i;\r\n  if (n > 1) _qsortIdx(data, idx, 0, n - 1);\r\n  return idx;\r\n}\r\n\r\n/**\r\n * Return an Int32Array where `result[i]` = rank (0-indexed position in sorted\r\n * order) of `data[i]` (NaN-last).  Equivalent to inverting the argsort.\r\n */\r\nexport function rank_f64(data: Float64Array): Int32Array {\r\n  const n: i32 = data.length;\r\n  const idx = argsort_f64(data);\r\n  const out = new Int32Array(n);\r\n  for (let k: i32 = 0; k < n; k++) {\r\n    out[idx[k]] = k;\r\n  }\r\n  return out;\r\n}\r\n","/**\r\n * Complex Array Operations for AssemblyScript\r\n *\r\n * Operations on arrays of complex numbers.\r\n * Complex arrays use interleaved storage: [re0, im0, re1, im1, ...]\r\n * A Float64Array of length 2n represents n complex numbers.\r\n */\r\n\r\nimport { Complex } from '../types/complex';\r\n\r\n// =============================================================================\r\n// Array Creation\r\n// =============================================================================\r\n\r\n/**\r\n * Create complex array of zeros\r\n * Returns array of length 2*n (interleaved)\r\n */\r\nexport function complex_array_zeros(n: i32): Float64Array {\r\n  return new Float64Array(n * 2);\r\n}\r\n\r\n/**\r\n * Create complex array of ones (1 + 0i)\r\n */\r\nexport function complex_array_ones(n: i32): Float64Array {\r\n  const data = new Float64Array(n * 2);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((data[i * 2] = 1.0)); // real part\r\n    // imaginary part is already 0\r\n  }\r\n  return data;\r\n}\r\n\r\n/**\r\n * Create complex array with value (re + im*i)\r\n */\r\nexport function complex_array_fill(n: i32, re: f64, im: f64): Float64Array {\r\n  const data = new Float64Array(n * 2);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((data[i * 2] = re));\r\n    unchecked((data[i * 2 + 1] = im));\r\n  }\r\n  return data;\r\n}\r\n\r\n// =============================================================================\r\n// Element Access\r\n// =============================================================================\r\n\r\n/**\r\n * Get complex number at index (returns new Complex)\r\n */\r\nexport function complex_array_get(data: Float64Array, index: i32): Complex {\r\n  const re = unchecked(data[index * 2]);\r\n  const im = unchecked(data[index * 2 + 1]);\r\n  return new Complex(re, im);\r\n}\r\n\r\n/**\r\n * Set complex number at index\r\n */\r\nexport function complex_array_set(data: Float64Array, index: i32, value: Complex): void {\r\n  unchecked((data[index * 2] = value.re));\r\n  unchecked((data[index * 2 + 1] = value.im));\r\n}\r\n\r\n/**\r\n * Set complex number at index from components\r\n */\r\nexport function complex_array_set_parts(data: Float64Array, index: i32, re: f64, im: f64): void {\r\n  unchecked((data[index * 2] = re));\r\n  unchecked((data[index * 2 + 1] = im));\r\n}\r\n\r\n/**\r\n * Get real part at index\r\n */\r\nexport function complex_array_get_re(data: Float64Array, index: i32): f64 {\r\n  return unchecked(data[index * 2]);\r\n}\r\n\r\n/**\r\n * Get imaginary part at index\r\n */\r\nexport function complex_array_get_im(data: Float64Array, index: i32): f64 {\r\n  return unchecked(data[index * 2 + 1]);\r\n}\r\n\r\n/**\r\n * Get number of complex elements (array length / 2)\r\n */\r\nexport function complex_array_length(data: Float64Array): i32 {\r\n  return data.length / 2;\r\n}\r\n\r\n// =============================================================================\r\n// Element-wise Arithmetic\r\n// =============================================================================\r\n\r\n/**\r\n * Complex array addition: result = a + b\r\n */\r\nexport function complex_array_add(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array subtraction: result = a - b\r\n */\r\nexport function complex_array_sub(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const len = min(min(a.length, b.length), result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) - unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array multiplication: result = a * b (element-wise)\r\n * (a + bi)(c + di) = (ac - bd) + (ad + bc)i\r\n */\r\nexport function complex_array_mul(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const n = min(min(a.length, b.length), result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = unchecked(b[idx + 1]);\r\n\r\n    unchecked((result[idx] = aRe * bRe - aIm * bIm));\r\n    unchecked((result[idx + 1] = aRe * bIm + aIm * bRe));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex array division: result = a / b (element-wise)\r\n */\r\nexport function complex_array_div(a: Float64Array, b: Float64Array, result: Float64Array): void {\r\n  const n = min(min(a.length, b.length), result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = unchecked(b[idx + 1]);\r\n\r\n    const denom = bRe * bRe + bIm * bIm;\r\n    unchecked((result[idx] = (aRe * bRe + aIm * bIm) / denom));\r\n    unchecked((result[idx + 1] = (aIm * bRe - aRe * bIm) / denom));\r\n  }\r\n}\r\n\r\n/**\r\n * Scale complex array by real scalar: result = a * scalar\r\n */\r\nexport function complex_array_scale_real(a: Float64Array, scalar: f64, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = unchecked(a[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Scale complex array by complex scalar: result = a * (re + im*i)\r\n */\r\nexport function complex_array_scale_complex(\r\n  a: Float64Array,\r\n  re: f64,\r\n  im: f64,\r\n  result: Float64Array\r\n): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n\r\n    unchecked((result[idx] = aRe * re - aIm * im));\r\n    unchecked((result[idx + 1] = aRe * im + aIm * re));\r\n  }\r\n}\r\n\r\n/**\r\n * Negate complex array: result = -a\r\n */\r\nexport function complex_array_neg(a: Float64Array, result: Float64Array): void {\r\n  const len = min(a.length, result.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((result[i] = -unchecked(a[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex conjugate array: result = conj(a)\r\n */\r\nexport function complex_array_conj(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    unchecked((result[idx] = unchecked(a[idx]))); // real unchanged\r\n    unchecked((result[idx + 1] = -unchecked(a[idx + 1]))); // negate imaginary\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Element-wise Functions\r\n// =============================================================================\r\n\r\n/**\r\n * Magnitude (absolute value) of each element: result[i] = |a[i]|\r\n */\r\nexport function complex_array_abs(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked((result[i] = sqrt(re * re + im * im)));\r\n  }\r\n}\r\n\r\n/**\r\n * Phase (argument) of each element: result[i] = arg(a[i])\r\n */\r\nexport function complex_array_arg(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked((result[i] = Math.atan2(im, re)));\r\n  }\r\n}\r\n\r\n/**\r\n * Square of magnitude: result[i] = |a[i]|^2\r\n */\r\nexport function complex_array_abs_squared(a: Float64Array, result: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    unchecked((result[i] = re * re + im * im));\r\n  }\r\n}\r\n\r\n/**\r\n * Extract real parts\r\n */\r\nexport function complex_array_real(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length / 2, result.length);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((result[i] = unchecked(a[i * 2])));\r\n  }\r\n}\r\n\r\n/**\r\n * Extract imaginary parts\r\n */\r\nexport function complex_array_imag(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length / 2, result.length);\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((result[i] = unchecked(a[i * 2 + 1])));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex exponential: result = Math.exp(a)\r\n */\r\nexport function complex_array_exp(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    const expRe = Math.exp(re);\r\n    unchecked((result[idx] = expRe * Math.cos(im)));\r\n    unchecked((result[idx + 1] = expRe * Math.sin(im)));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex natural log: result = Math.log(a)\r\n */\r\nexport function complex_array_log(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    unchecked((result[idx] = Math.log(sqrt(re * re + im * im))));\r\n    unchecked((result[idx + 1] = Math.atan2(im, re)));\r\n  }\r\n}\r\n\r\n/**\r\n * Complex square root: result = sqrt(a)\r\n */\r\nexport function complex_array_sqrt(a: Float64Array, result: Float64Array): void {\r\n  const n = min(a.length, result.length) / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const re = unchecked(a[idx]);\r\n    const im = unchecked(a[idx + 1]);\r\n\r\n    const r = sqrt(re * re + im * im);\r\n    const sqrtR = sqrt(r);\r\n    const halfTheta = Math.atan2(im, re) / 2.0;\r\n\r\n    unchecked((result[idx] = sqrtR * Math.cos(halfTheta)));\r\n    unchecked((result[idx + 1] = sqrtR * Math.sin(halfTheta)));\r\n  }\r\n}\r\n\r\n// =============================================================================\r\n// Reductions\r\n// =============================================================================\r\n\r\n/**\r\n * Sum of complex array\r\n */\r\nexport function complex_array_sum(a: Float64Array): Complex {\r\n  let sumRe: f64 = 0.0;\r\n  let sumIm: f64 = 0.0;\r\n  const n = a.length / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    sumRe += unchecked(a[i * 2]);\r\n    sumIm += unchecked(a[i * 2 + 1]);\r\n  }\r\n\r\n  return new Complex(sumRe, sumIm);\r\n}\r\n\r\n/**\r\n * Mean of complex array\r\n */\r\nexport function complex_array_mean(a: Float64Array): Complex {\r\n  const n = a.length / 2;\r\n  if (n == 0) return new Complex(f64.NaN, f64.NaN);\r\n\r\n  const sum = complex_array_sum(a);\r\n  return new Complex(sum.re / f64(n), sum.im / f64(n));\r\n}\r\n\r\n/**\r\n * Dot product of two complex arrays: sum(a[i] * conj(b[i]))\r\n */\r\nexport function complex_array_dot(a: Float64Array, b: Float64Array): Complex {\r\n  let sumRe: f64 = 0.0;\r\n  let sumIm: f64 = 0.0;\r\n  const n = min(a.length, b.length) / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    const idx = i * 2;\r\n    const aRe = unchecked(a[idx]);\r\n    const aIm = unchecked(a[idx + 1]);\r\n    const bRe = unchecked(b[idx]);\r\n    const bIm = -unchecked(b[idx + 1]); // conjugate of b\r\n\r\n    sumRe += aRe * bRe - aIm * bIm;\r\n    sumIm += aRe * bIm + aIm * bRe;\r\n  }\r\n\r\n  return new Complex(sumRe, sumIm);\r\n}\r\n\r\n/**\r\n * L2 norm of complex array: sqrt(sum(|a[i]|^2))\r\n */\r\nexport function complex_array_norm(a: Float64Array): f64 {\r\n  let sumSq: f64 = 0.0;\r\n  const n = a.length / 2;\r\n\r\n  for (let i = 0; i < n; i++) {\r\n    const re = unchecked(a[i * 2]);\r\n    const im = unchecked(a[i * 2 + 1]);\r\n    sumSq += re * re + im * im;\r\n  }\r\n\r\n  return sqrt(sumSq);\r\n}\r\n\r\n// =============================================================================\r\n// In-place Operations\r\n// =============================================================================\r\n\r\n/**\r\n * Scale in place: a *= scalar (real)\r\n */\r\nexport function complex_array_scale_inplace(a: Float64Array, scalar: f64): void {\r\n  const len = a.length;\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) * scalar));\r\n  }\r\n}\r\n\r\n/**\r\n * Conjugate in place\r\n */\r\nexport function complex_array_conj_inplace(a: Float64Array): void {\r\n  const n = a.length / 2;\r\n  for (let i = 0; i < n; i++) {\r\n    unchecked((a[i * 2 + 1] = -unchecked(a[i * 2 + 1])));\r\n  }\r\n}\r\n\r\n/**\r\n * Add in place: a += b\r\n */\r\nexport function complex_array_add_inplace(a: Float64Array, b: Float64Array): void {\r\n  const len = min(a.length, b.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((a[i] = unchecked(a[i]) + unchecked(b[i])));\r\n  }\r\n}\r\n\r\n/**\r\n * Copy complex array\r\n */\r\nexport function complex_array_copy(src: Float64Array, dst: Float64Array): void {\r\n  const len = min(src.length, dst.length);\r\n  for (let i = 0; i < len; i++) {\r\n    unchecked((dst[i] = unchecked(src[i])));\r\n  }\r\n}\r\n"]}