Quelle  names.wast.js

/* Copyright 2021 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// ./test/core/names.wast

// ./test/core/names.wast:4
let $0 = instantiate(`(module
  (func (export "foo") (result i32) (i32.const 0))
)`);

// ./test/core/names.wast:8
assert_return(() => invoke($0, `foo`, []), [value("i32", 0)]);

// ./test/core/names.wast:12
let $1 = instantiate(`(module
  (func (export "foo") (result i32) (i32.const 1))
)`);

// ./test/core/names.wast:16
assert_return(() => invoke($1, `foo`, []), [value("i32", 1)]);

// ./test/core/names.wast:19
let $2 = instantiate(`(module
  ;; Test that we can use the empty string as a symbol.
  (func (export "") (result i32) (i32.const 0))

  ;; Test that we can use names beginning with a digit.
  (func (export "0") (result i32) (i32.const 1))

  ;; Test that we can use names beginning with a dash.
  (func (export "-0") (result i32) (i32.const 2))

  ;; Test that we can use names beginning with an underscore.
  (func (export "_") (result i32) (i32.const 3))

  ;; Test that we can use names beginning with a dollar sign.
  (func (export "$$") (result i32) (i32.const 4))

  ;; Test that we can use names beginning with an at sign.
  (func (export "@") (result i32) (i32.const 5))

  ;; Test that we can use non-alphanumeric names.
  (func (export "~!@#$$%^&*()_+\`-={}|[]\\\\:\\";'<>?,./ ") (result i32) (i32.const 6))

  ;; Test that we can use names that have special meaning in JS.
  (func (export "NaN") (result i32) (i32.const 7))
  (func (export "Infinity") (result i32) (i32.const 8))
  (func (export "if") (result i32) (i32.const 9))

  ;; Test that we can use common libc names without conflict.
  (func (export "malloc") (result i32) (i32.const 10))

  ;; Test that we can use some libc hidden names without conflict.
  (func (export "_malloc") (result i32) (i32.const 11))
  (func (export "__malloc") (result i32) (i32.const 12))

  ;; Test that names are case-sensitive.
  (func (export "a") (result i32) (i32.const 13))
  (func (export "A") (result i32) (i32.const 14))

  ;; Test that UTF-8 BOM code points can appear in identifiers.
  (func (export "\u{feff}") (result i32) (i32.const 15))

  ;; Test that Unicode normalization is not applied. These function names
  ;; contain different codepoints which normalize to the same thing under
  ;; NFC or NFD.
  (func (export "\u{c5}") (result i32) (i32.const 16))
  (func (export "A\u{30a}") (result i32) (i32.const 17))
  (func (export "\u{212b}") (result i32) (i32.const 18))

  ;; Test that Unicode compatibility normalization is not applied. These
  ;; function names contain different codepoints which normalize to the
  ;; same thing under NFKC or NFKD.
  (func (export "\u{fb03}") (result i32) (i32.const 19))
  (func (export "f\u{fb01}") (result i32) (i32.const 20))
  (func (export "ffi") (result i32) (i32.const 21))

  ;; Test the C0 control codes.
  (func (export "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f") (result i32) (i32.const 22))
  (func (export "\\10\\11\\12\\13\\14\\15\\16\\17\\18\\19\\1a\\1b\\1c\\1d\\1e\\1f") (result i32) (i32.const 23))
  ;; Test miscellaneous control codes.
  (func (export " \\7f") (result i32) (i32.const 24))
  ;; Test the C1 control codes.
  (func (export "\\c2\\80\\c2\\81\\c2\\82\\c2\\83\\c2\\84\\c2\\85\\c2\\86\\c2\\87\\c2\\88\\c2\\89\\c2\\8a\\c2\\8b\\c2\\8c\\c2\\8d\\c2\\8e\\c2\\8f") (result i32) (i32.const 25))
  (func (export "\\c2\\90\\c2\\91\\c2\\92\\c2\\93\\c2\\94\\c2\\95\\c2\\96\\c2\\97\\c2\\98\\c2\\99\\c2\\9a\\c2\\9b\\c2\\9c\\c2\\9d\\c2\\9e\\c2\\9f") (result i32) (i32.const 26))
  ;; Test the Unicode Specials.
  (func (export "\\ef\\bf\\b0\\ef\\bf\\b1\\ef\\bf\\b2\\ef\\bf\\b3\\ef\\bf\\b4\\ef\\bf\\b5\\ef\\bf\\b6\\ef\\bf\\b7") (result i32) (i32.const 27))
  (func (export "\\ef\\bf\\b8\\ef\\bf\\b9\\ef\\bf\\ba\\ef\\bf\\bb\\ef\\bf\\bc\\ef\\bf\\bd\\ef\\bf\\be\\ef\\bf\\bf") (result i32) (i32.const 28))

  ;; Test that the control pictures are distinct from the control codes they
  ;; depict. These correspond to the C0 and miscellaneous control code tests
  ;; above.
  (func (export "\u{2400}\u{2401}\u{2402}\u{2403}\u{2404}\u{2405}\u{2406}\u{2407}\u{2408}\u{2409}\u{240a}\u{240b}\u{240c}\u{240d}\u{240e}\u{240f}") (result i32) (i32.const 29))
  (func (export "\u{2410}\u{2411}\u{2412}\u{2413}\u{2414}\u{2415}\u{2416}\u{2417}\u{2418}\u{2419}\u{241a}\u{241b}\u{241c}\u{241d}\u{241e}\u{241f}") (result i32) (i32.const 30))
  (func (export "\u{2420}\u{2421}") (result i32) (i32.const 31))

  ;; Test the Unicode Specials in non-escaped form (excluding U+FFFE and
  ;; U+FFFF, so that generic tools don't detect this file as non-UTF-8).
  (func (export "\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}") (result i32) (i32.const 32))

  ;; Test a bare ZWJ code point.
  (func (export "\u{200d}") (result i32) (i32.const 33))
  ;; Test a bare ZWNJ code point.
  (func (export "\u{200c}") (result i32) (i32.const 34))

  ;; Test various bare joiner code points.
  (func (export "\u{34f}") (result i32) (i32.const 35))
  (func (export "\u{2060}") (result i32) (i32.const 36))
  (func (export "\u{2d7f}") (result i32) (i32.const 37))
  (func (export "\u{1107f}") (result i32) (i32.const 38))
  (func (export "\u{180e}") (result i32) (i32.const 39))

  ;; Test various interesting code points: reverse BOM, zero-width space,
  ;; no-break space, soft hyphen, word joiner, ogham space mark,
  ;; right-to-left override, left-to-right override.
  (func (export "\u{ffef}\u{200b}\u{a0}\u{ad}\u{2060}\u{1680}\u{202e}\u{202d}") (result i32) (i32.const 40))

  ;; Test more interesting code points: left-to-right mark, right-to-left mark,
  ;; non-breaking hyphen, line separator, paragraph separator,
  ;; left-to-right embedding, right-to-left embedding,
  ;; pop directional formatting, narrow no-break space, left-to-right isolate,
  ;; right-to-left isolate, first strong isolate, pop directional isolate.
  (func (export "\u{200e}\u{200f}\u{2011}\u{2028}\u{2029}\u{202a}\u{202b}\u{202c}\u{202f}\u{2066}\u{2067}\u{2068}\u{2069}") (result i32) (i32.const 41))

  ;; Test some deprecated code points: inhibit symmetric swapping,
  ;; activate symmetric swapping, inhibit arabic form shaping,
  ;; activate arabic form shaping, national digit shapes, nominal digit shapes.
  (func (export "\u{206a}\u{206b}\u{206c}\u{206d}\u{206e}\u{206f}") (result i32) (i32.const 42))

  ;; Test "invisible" operator code points.
  (func (export "\u{2061}\u{2062}\u{2063}\u{2064}") (result i32) (i32.const 43))

  ;; Test that code points outside the BMP are supported.
  (func (export "\u{10000}\u{dffff}\u{10ffff}") (result i32) (i32.const 44))

  ;; Test that WebAssembly implementations cope in the presence of Zalgo.
  (func (export "Z\u{30f}\u{346}\u{306}\u{35b}\u{34c}\u{334}\u{358}\u{35e}\u{347}\u{32b}\u{325}\u{32a}\u{353}\u{348}\u{354}\u{34e}\u{317}\u{31e}\u{33a}\u{32f}\u{331}\u{31e}\u{319}\u{331}\u{31c}\u{316}\u{320}a\u{357}\u{368}\u{30e}\u{304}\u{306}\u{357}\u{33f}\u{361}\u{35f}\u{340}\u{336}\u{341}\u{325}\u{330}\u{333}\u{32d}\u{359}\u{332}\u{331}\u{339}\u{31d}\u{34e}\u{33c}l\u{344}\u{34a}\u{31a}\u{357}\u{366}\u{344}\u{36b}\u{307}\u{341}\u{336}\u{337}\u{349}\u{329}\u{339}\u{32b}\u{31d}\u{356}\u{345}\u{319}\u{332}\u{33c}\u{347}\u{35a}\u{34d}\u{32e}\u{34e}\u{325}\u{345}\u{31e}g\u{343}\u{310}\u{305}\u{36e}\u{314}\u{310}\u{30e}\u{302}\u{30f}\u{33e}\u{34a}\u{30d}\u{34b}\u{34a}\u{367}\u{301}\u{306}\u{366}\u{35e}\u{336}\u{355}\u{354}\u{35a}\u{329}o\u{34b}\u{314}\u{350}\u{36a}\u{369}\u{321}\u{34f}\u{322}\u{327}\u{341}\u{32b}\u{319}\u{324}\u{32e}\u{356}\u{359}\u{353}\u{33a}\u{31c}\u{329}\u{33c}\u{318}\u{320}") (result i32) (i32.const 45))

  ;; Test Hangul filler code points.
  (func (export "\u{115f}\u{1160}\u{3164}\u{ffa0}") (result i32) (i32.const 46))

  ;; Test variation selectors (which are also ID_Continue code points).
  (func (export "\u{fe00}") (result i32) (i32.const 47))
  (func (export "\u{fe04}") (result i32) (i32.const 48))
  (func (export "\u{e0100}") (result i32) (i32.const 49))
  (func (export "\u{e01ef}") (result i32) (i32.const 50))

  ;; Test an uncombined combining code point.
  (func (export "\u{308}") (result i32) (i32.const 51))

  ;; Test that numerous different present and historical representations of the
  ;; "newline" concept are distinct. Tests largely inspired by:
  ;;   https://en.wikipedia.org/wiki/Newline#Representations
  ;;   https://en.wikipedia.org/wiki/Newline#Unicode and
  ;;   https://en.wikipedia.org/wiki/Newline#Reverse_and_partial_line_feeds
  (func (export "\\0a") (result i32) (i32.const 52))
  (func (export "\u{2424}") (result i32) (i32.const 53))
  (func (export "\u{2028}") (result i32) (i32.const 54))
  (func (export "\\0d") (result i32) (i32.const 55))
  (func (export "\\0d\\0a") (result i32) (i32.const 56))
  (func (export "\\0a\\0d") (result i32) (i32.const 57))
  (func (export "\\1e") (result i32) (i32.const 58))
  (func (export "\\0b") (result i32) (i32.const 59))
  (func (export "\\0c") (result i32) (i32.const 60))
  (func (export "\\c2\\85") (result i32) (i32.const 61))
  (func (export "\u{2029}") (result i32) (i32.const 62))
  (func (export "\u{2026}") (result i32) (i32.const 63))
  (func (export "\u{23ce}") (result i32) (i32.const 64))
  (func (export "\\c2\\8b") (result i32) (i32.const 65))
  (func (export "\\c2\\8c") (result i32) (i32.const 66))
  (func (export "\\c2\\8d") (result i32) (i32.const 67))
  (func (export "\u{21b5}") (result i32) (i32.const 68))
  (func (export "\u{21a9}") (result i32) (i32.const 69))
  (func (export "\u{2324}") (result i32) (i32.const 70))
  (func (export "\u{2936}") (result i32) (i32.const 71))
  (func (export "\u{21b2}") (result i32) (i32.const 72))
  (func (export "\u{2ba8}") (result i32) (i32.const 73))
  (func (export "\u{2bb0}") (result i32) (i32.const 74))

  ;; Test that non-characters are not replaced by the replacement character.
  (func (export "\u{fffd}") (result i32) (i32.const 75))
  (func (export "\\ef\\b7\\90") (result i32) (i32.const 76))
  (func (export "\\ef\\b7\\91") (result i32) (i32.const 77))
  (func (export "\\ef\\b7\\92") (result i32) (i32.const 78))
  (func (export "\\ef\\b7\\93") (result i32) (i32.const 79))
  (func (export "\\ef\\b7\\94") (result i32) (i32.const 80))
  (func (export "\\ef\\b7\\95") (result i32) (i32.const 81))
  (func (export "\\ef\\b7\\96") (result i32) (i32.const 82))
  (func (export "\\ef\\b7\\97") (result i32) (i32.const 83))
  (func (export "\\ef\\b7\\98") (result i32) (i32.const 84))
  (func (export "\\ef\\b7\\99") (result i32) (i32.const 85))
  (func (export "\\ef\\b7\\9a") (result i32) (i32.const 86))
  (func (export "\\ef\\b7\\9b") (result i32) (i32.const 87))
  (func (export "\\ef\\b7\\9c") (result i32) (i32.const 88))
  (func (export "\\ef\\b7\\9d") (result i32) (i32.const 89))
  (func (export "\\ef\\b7\\9e") (result i32) (i32.const 90))
  (func (export "\\ef\\b7\\9f") (result i32) (i32.const 91))
  (func (export "\\ef\\b7\\a0") (result i32) (i32.const 92))
  (func (export "\\ef\\b7\\a1") (result i32) (i32.const 93))
  (func (export "\\ef\\b7\\a2") (result i32) (i32.const 94))
  (func (export "\\ef\\b7\\a3") (result i32) (i32.const 95))
  (func (export "\\ef\\b7\\a4") (result i32) (i32.const 96))
  (func (export "\\ef\\b7\\a5") (result i32) (i32.const 97))
  (func (export "\\ef\\b7\\a6") (result i32) (i32.const 98))
  (func (export "\\ef\\b7\\a7") (result i32) (i32.const 99))
  (func (export "\\ef\\b7\\a8") (result i32) (i32.const 100))
  (func (export "\\ef\\b7\\a9") (result i32) (i32.const 101))
  (func (export "\\ef\\b7\\aa") (result i32) (i32.const 102))
  (func (export "\\ef\\b7\\ab") (result i32) (i32.const 103))
  (func (export "\\ef\\b7\\ac") (result i32) (i32.const 104))
  (func (export "\\ef\\b7\\ad") (result i32) (i32.const 105))
  (func (export "\\ef\\b7\\ae") (result i32) (i32.const 106))
  (func (export "\\ef\\b7\\af") (result i32) (i32.const 107))
  (func (export "\\ef\\bf\\be") (result i32) (i32.const 108))
  (func (export "\\ef\\bf\\bf") (result i32) (i32.const 109))
  (func (export "\\f0\\9f\\bf\\be") (result i32) (i32.const 110))
  (func (export "\\f0\\9f\\bf\\bf") (result i32) (i32.const 111))
  (func (export "\\f0\\af\\bf\\be") (result i32) (i32.const 112))
  (func (export "\\f0\\af\\bf\\bf") (result i32) (i32.const 113))
  (func (export "\\f0\\bf\\bf\\be") (result i32) (i32.const 114))
  (func (export "\\f0\\bf\\bf\\bf") (result i32) (i32.const 115))
  (func (export "\\f1\\8f\\bf\\be") (result i32) (i32.const 116))
  (func (export "\\f1\\8f\\bf\\bf") (result i32) (i32.const 117))
  (func (export "\\f1\\9f\\bf\\be") (result i32) (i32.const 118))
  (func (export "\\f1\\9f\\bf\\bf") (result i32) (i32.const 119))
  (func (export "\\f1\\af\\bf\\be") (result i32) (i32.const 120))
  (func (export "\\f1\\af\\bf\\bf") (result i32) (i32.const 121))
  (func (export "\\f1\\bf\\bf\\be") (result i32) (i32.const 122))
  (func (export "\\f1\\bf\\bf\\bf") (result i32) (i32.const 123))
  (func (export "\\f2\\8f\\bf\\be") (result i32) (i32.const 124))
  (func (export "\\f2\\8f\\bf\\bf") (result i32) (i32.const 125))
  (func (export "\\f2\\9f\\bf\\be") (result i32) (i32.const 126))
  (func (export "\\f2\\9f\\bf\\bf") (result i32) (i32.const 127))
  (func (export "\\f2\\af\\bf\\be") (result i32) (i32.const 128))
  (func (export "\\f2\\af\\bf\\bf") (result i32) (i32.const 129))
  (func (export "\\f2\\bf\\bf\\be") (result i32) (i32.const 130))
  (func (export "\\f2\\bf\\bf\\bf") (result i32) (i32.const 131))
  (func (export "\\f3\\8f\\bf\\be") (result i32) (i32.const 132))
  (func (export "\\f3\\8f\\bf\\bf") (result i32) (i32.const 133))
  (func (export "\\f3\\9f\\bf\\be") (result i32) (i32.const 134))
  (func (export "\\f3\\9f\\bf\\bf") (result i32) (i32.const 135))
  (func (export "\\f3\\af\\bf\\be") (result i32) (i32.const 136))
  (func (export "\\f3\\af\\bf\\bf") (result i32) (i32.const 137))
  (func (export "\\f3\\bf\\bf\\be") (result i32) (i32.const 138))
  (func (export "\\f3\\bf\\bf\\bf") (result i32) (i32.const 139))
  (func (export "\\f4\\8f\\bf\\be") (result i32) (i32.const 140))
  (func (export "\\f4\\8f\\bf\\bf") (result i32) (i32.const 141))

  ;; Test an interrobang with combining diacritical marks above.
  ;; https://xkcd.com/1209/
  (func (export "\u{308}\u{203d}\u{308}\u{309}") (result i32) (i32.const 142))

  ;; Test that RLM/LRM don't change the logical byte order.
  (func (export "abc") (result i32) (i32.const 143))
  (func (export "\u{202d}abc") (result i32) (i32.const 144))
  (func (export "\u{202e}cba") (result i32) (i32.const 145))
  (func (export "\u{202d}abc\u{202e}") (result i32) (i32.const 146))
  (func (export "\u{202e}cba\u{202d}") (result i32) (i32.const 147))

  ;; Test that Unicode font variations are preserved.
  (func (export "\u{1d468}") (result i32) (i32.const 148))
  (func (export "\u{1d434}") (result i32) (i32.const 149))
  (func (export "\u{1d608}") (result i32) (i32.const 150))
  (func (export "\u{1d63c}") (result i32) (i32.const 151))
  (func (export "\u{1d400}") (result i32) (i32.const 152))
  (func (export "\u{1d4d0}") (result i32) (i32.const 153))
  (func (export "\u{1d56c}") (result i32) (i32.const 154))
  (func (export "\u{1d5d4}") (result i32) (i32.const 155))
  (func (export "\u{1d49c}") (result i32) (i32.const 156))
  (func (export "\u{1d504}") (result i32) (i32.const 157))
  (func (export "\u{1d538}") (result i32) (i32.const 158))
  (func (export "\u{1d5a0}") (result i32) (i32.const 159))
  (func (export "\u{1d670}") (result i32) (i32.const 160))
  (func (export "\u{1d00}") (result i32) (i32.const 161))

  ;; Test that various additional letter variations are preserved.
  ;; (U+0040, U+0061, U+0041, U+00C5, U+0041 U+030A, U+212B, and the font
  ;; variations are covered above.)
  (func (export "\u{1d2c}") (result i32) (i32.const 162))
  (func (export "\u{24b6}") (result i32) (i32.const 163))
  (func (export "\u{ff21}") (result i32) (i32.const 164))
  (func (export "\u{1f110}") (result i32) (i32.const 165))
  (func (export "\u{1f130}") (result i32) (i32.const 166))
  (func (export "\u{e0041}") (result i32) (i32.const 167))
  (func (export "U+0041") (result i32) (i32.const 168))
  (func (export "A\u{200b}") (result i32) (i32.const 169))
  (func (export "\u{410}") (result i32) (i32.const 170))
  (func (export "\u{a656}") (result i32) (i32.const 171))
  (func (export "\u{2dfc}") (result i32) (i32.const 172))
  (func (export "\u{2df6}") (result i32) (i32.const 173))
  (func (export "\u{2c6f}") (result i32) (i32.const 174))
  (func (export "\u{1f150}") (result i32) (i32.const 175))
  (func (export "\u{1f170}") (result i32) (i32.const 176))
  (func (export "\u{2c2d}") (result i32) (i32.const 177))
  (func (export "\u{10402}") (result i32) (i32.const 178))
  (func (export "\u{10408}") (result i32) (i32.const 179))
  (func (export "\u{104b0}") (result i32) (i32.const 180))
  (func (export "\u{c0}") (result i32) (i32.const 181))
  (func (export "\u{c1}") (result i32) (i32.const 182))
  (func (export "\u{c2}") (result i32) (i32.const 183))
  (func (export "\u{c3}") (result i32) (i32.const 184))
  (func (export "\u{c4}") (result i32) (i32.const 185))
  (func (export "\u{100}") (result i32) (i32.const 186))
  (func (export "\u{102}") (result i32) (i32.const 187))
  (func (export "\u{104}") (result i32) (i32.const 188))
  (func (export "\u{1cd}") (result i32) (i32.const 189))
  (func (export "\u{1de}") (result i32) (i32.const 190))
  (func (export "\u{1e0}") (result i32) (i32.const 191))
  (func (export "\u{1fa}") (result i32) (i32.const 192))
  (func (export "\u{200}") (result i32) (i32.const 193))
  (func (export "\u{202}") (result i32) (i32.const 194))
  (func (export "\u{226}") (result i32) (i32.const 195))
  (func (export "\u{23a}") (result i32) (i32.const 196))
  (func (export "\u{4d0}") (result i32) (i32.const 197))
  (func (export "\u{4d2}") (result i32) (i32.const 198))
  (func (export "\u{7ca}") (result i32) (i32.const 199))
  (func (export "\u{821}") (result i32) (i32.const 200))
  (func (export "\u{822}") (result i32) (i32.const 201))
  (func (export "\u{823}") (result i32) (i32.const 202))
  (func (export "\u{824}") (result i32) (i32.const 203))
  (func (export "\u{825}") (result i32) (i32.const 204))
  (func (export "\u{904}") (result i32) (i32.const 205))
  (func (export "\u{905}") (result i32) (i32.const 206))
  (func (export "\u{972}") (result i32) (i32.const 207))
  (func (export "\u{985}") (result i32) (i32.const 208))
  (func (export "\u{a05}") (result i32) (i32.const 209))
  (func (export "\u{a85}") (result i32) (i32.const 210))
  (func (export "\u{b05}") (result i32) (i32.const 211))
  (func (export "\u{b85}") (result i32) (i32.const 212))
  (func (export "\u{c05}") (result i32) (i32.const 213))
  (func (export "\u{c85}") (result i32) (i32.const 214))
  (func (export "\u{d05}") (result i32) (i32.const 215))
  (func (export "\u{e30}") (result i32) (i32.const 216))
  (func (export "\u{eb0}") (result i32) (i32.const 217))
  (func (export "\u{f01}") (result i32) (i32.const 218))
  (func (export "\u{f68}") (result i32) (i32.const 219))
  (func (export "\u{fb8}") (result i32) (i32.const 220))
  (func (export "\u{1021}") (result i32) (i32.const 221))
  (func (export "\u{1022}") (result i32) (i32.const 222))
  (func (export "\u{109c}") (result i32) (i32.const 223))
  (func (export "\u{1161}") (result i32) (i32.const 224))
  (func (export "\u{12a0}") (result i32) (i32.const 225))
  (func (export "\u{12d0}") (result i32) (i32.const 226))
  (func (export "\u{13a0}") (result i32) (i32.const 227))
  (func (export "\u{140a}") (result i32) (i32.const 228))
  (func (export "\u{15b3}") (result i32) (i32.const 229))
  (func (export "\u{16a8}") (result i32) (i32.const 230))
  (func (export "\u{16aa}") (result i32) (i32.const 231))
  (func (export "\u{16c6}") (result i32) (i32.const 232))
  (func (export "\u{1700}") (result i32) (i32.const 233))
  (func (export "\u{1720}") (result i32) (i32.const 234))
  (func (export "\u{1740}") (result i32) (i32.const 235))
  (func (export "\u{1760}") (result i32) (i32.const 236))
  (func (export "\u{1820}") (result i32) (i32.const 237))
  (func (export "\u{1887}") (result i32) (i32.const 238))
  (func (export "\u{1920}") (result i32) (i32.const 239))
  (func (export "\u{1963}") (result i32) (i32.const 240))
  (func (export "\u{1a15}") (result i32) (i32.const 241))
  (func (export "\u{1a4b}") (result i32) (i32.const 242))
  (func (export "\u{1a61}") (result i32) (i32.const 243))
  (func (export "\u{1b83}") (result i32) (i32.const 244))
  (func (export "\u{1bc0}") (result i32) (i32.const 245))
  (func (export "\u{1bc1}") (result i32) (i32.const 246))
  (func (export "\u{1c23}") (result i32) (i32.const 247))
  (func (export "\u{1e00}") (result i32) (i32.const 248))
  (func (export "\u{1ea0}") (result i32) (i32.const 249))
  (func (export "\u{1ea2}") (result i32) (i32.const 250))
  (func (export "\u{1ea4}") (result i32) (i32.const 251))
  (func (export "\u{1ea6}") (result i32) (i32.const 252))
  (func (export "\u{1ea8}") (result i32) (i32.const 253))
  (func (export "\u{1eaa}") (result i32) (i32.const 254))
  (func (export "\u{1eac}") (result i32) (i32.const 255))
  (func (export "\u{1eae}") (result i32) (i32.const 256))
  (func (export "\u{1eb0}") (result i32) (i32.const 257))
  (func (export "\u{1eb2}") (result i32) (i32.const 258))
  (func (export "\u{1eb4}") (result i32) (i32.const 259))
  (func (export "\u{1eb6}") (result i32) (i32.const 260))
  (func (export "\u{3042}") (result i32) (i32.const 261))
  (func (export "\u{30a2}") (result i32) (i32.const 262))
  (func (export "\u{311a}") (result i32) (i32.const 263))
  (func (export "\u{314f}") (result i32) (i32.const 264))
  (func (export "\u{320e}") (result i32) (i32.const 265))
  (func (export "\u{320f}") (result i32) (i32.const 266))
  (func (export "\u{3210}") (result i32) (i32.const 267))
  (func (export "\u{3211}") (result i32) (i32.const 268))
  (func (export "\u{3212}") (result i32) (i32.const 269))
  (func (export "\u{3213}") (result i32) (i32.const 270))
  (func (export "\u{3214}") (result i32) (i32.const 271))
  (func (export "\u{3215}") (result i32) (i32.const 272))
  (func (export "\u{3216}") (result i32) (i32.const 273))
  (func (export "\u{3217}") (result i32) (i32.const 274))
  (func (export "\u{3218}") (result i32) (i32.const 275))
  (func (export "\u{3219}") (result i32) (i32.const 276))
  (func (export "\u{321a}") (result i32) (i32.const 277))
  (func (export "\u{321b}") (result i32) (i32.const 278))
  (func (export "\u{326e}") (result i32) (i32.const 279))
  (func (export "\u{326f}") (result i32) (i32.const 280))
  (func (export "\u{3270}") (result i32) (i32.const 281))
  (func (export "\u{3271}") (result i32) (i32.const 282))
  (func (export "\u{3272}") (result i32) (i32.const 283))
  (func (export "\u{3273}") (result i32) (i32.const 284))
  (func (export "\u{3274}") (result i32) (i32.const 285))
  (func (export "\u{3275}") (result i32) (i32.const 286))
  (func (export "\u{3276}") (result i32) (i32.const 287))
  (func (export "\u{3277}") (result i32) (i32.const 288))
  (func (export "\u{3278}") (result i32) (i32.const 289))
  (func (export "\u{3279}") (result i32) (i32.const 290))
  (func (export "\u{327a}") (result i32) (i32.const 291))
  (func (export "\u{327b}") (result i32) (i32.const 292))
  (func (export "\u{32d0}") (result i32) (i32.const 293))
  (func (export "\u{a00a}") (result i32) (i32.const 294))
  (func (export "\u{a4ee}") (result i32) (i32.const 295))
  (func (export "\u{a549}") (result i32) (i32.const 296))
  (func (export "\u{a6a0}") (result i32) (i32.const 297))
  (func (export "\u{a800}") (result i32) (i32.const 298))
  (func (export "\u{a823}") (result i32) (i32.const 299))
  (func (export "\u{a85d}") (result i32) (i32.const 300))
  (func (export "\u{a882}") (result i32) (i32.const 301))
  (func (export "\u{a8ea}") (result i32) (i32.const 302))
  (func (export "\u{a922}") (result i32) (i32.const 303))
  (func (export "\u{a946}") (result i32) (i32.const 304))
  (func (export "\u{a984}") (result i32) (i32.const 305))
  (func (export "\u{aa00}") (result i32) (i32.const 306))
  (func (export "\u{ff71}") (result i32) (i32.const 307))
  (func (export "\u{ffc2}") (result i32) (i32.const 308))
  (func (export "\u{10000}") (result i32) (i32.const 309))
  (func (export "\u{10280}") (result i32) (i32.const 310))
  (func (export "\u{102a0}") (result i32) (i32.const 311))
  (func (export "\u{10300}") (result i32) (i32.const 312))
  (func (export "\u{103a0}") (result i32) (i32.const 313))
  (func (export "\u{10496}") (result i32) (i32.const 314))
  (func (export "\u{10500}") (result i32) (i32.const 315))
  (func (export "\u{10740}") (result i32) (i32.const 316))
  (func (export "\u{10800}") (result i32) (i32.const 317))
  (func (export "\u{10920}") (result i32) (i32.const 318))
  (func (export "\u{10980}") (result i32) (i32.const 319))
  (func (export "\u{109a0}") (result i32) (i32.const 320))
  (func (export "\u{10a00}") (result i32) (i32.const 321))
  (func (export "\u{10b00}") (result i32) (i32.const 322))
  (func (export "\u{10c00}") (result i32) (i32.const 323))
  (func (export "\u{10c01}") (result i32) (i32.const 324))
  (func (export "\u{10c80}") (result i32) (i32.const 325))
  (func (export "\u{11005}") (result i32) (i32.const 326))
  (func (export "\u{11083}") (result i32) (i32.const 327))
  (func (export "\u{11127}") (result i32) (i32.const 328))
  (func (export "\u{11150}") (result i32) (i32.const 329))
  (func (export "\u{11183}") (result i32) (i32.const 330))
  (func (export "\u{11200}") (result i32) (i32.const 331))
  (func (export "\u{11280}") (result i32) (i32.const 332))
  (func (export "\u{112b0}") (result i32) (i32.const 333))
  (func (export "\u{11305}") (result i32) (i32.const 334))
  (func (export "\u{11370}") (result i32) (i32.const 335))
  (func (export "\u{11400}") (result i32) (i32.const 336))
  (func (export "\u{11481}") (result i32) (i32.const 337))
  (func (export "\u{11580}") (result i32) (i32.const 338))
  (func (export "\u{11600}") (result i32) (i32.const 339))
  (func (export "\u{11680}") (result i32) (i32.const 340))
  (func (export "\u{11712}") (result i32) (i32.const 341))
  (func (export "\u{11720}") (result i32) (i32.const 342))
  (func (export "\u{118a1}") (result i32) (i32.const 343))
  (func (export "\u{11ad5}") (result i32) (i32.const 344))
  (func (export "\u{11c00}") (result i32) (i32.const 345))
  (func (export "\u{11c8f}") (result i32) (i32.const 346))
  (func (export "\u{11caf}") (result i32) (i32.const 347))
  (func (export "\u{12000}") (result i32) (i32.const 348))
  (func (export "\u{169d5}") (result i32) (i32.const 349))
  (func (export "\u{16a46}") (result i32) (i32.const 350))
  (func (export "\u{16ae7}") (result i32) (i32.const 351))
  (func (export "\u{16f54}") (result i32) (i32.const 352))
  (func (export "\u{1bc41}") (result i32) (i32.const 353))
  (func (export "\u{1bc64}") (result i32) (i32.const 354))
  (func (export "\u{1e823}") (result i32) (i32.const 355))
  (func (export "\u{1f1e6}") (result i32) (i32.const 356))
  (func (export "\u{2c6d}") (result i32) (i32.const 357))
  (func (export "\u{39b}") (result i32) (i32.const 358))
  (func (export "\u{2c70}") (result i32) (i32.const 359))
  (func (export "\u{aa}") (result i32) (i32.const 360))
  (func (export "\u{2200}") (result i32) (i32.const 361))
  (func (export "\u{20b3}") (result i32) (i32.const 362))
  (func (export "\u{10900}") (result i32) (i32.const 363))
  (func (export "\u{2c80}") (result i32) (i32.const 364))
  (func (export "\u{10330}") (result i32) (i32.const 365))
  (func (export "\u{386}") (result i32) (i32.const 366))
  (func (export "\u{391}") (result i32) (i32.const 367))
  (func (export "\u{1f08}") (result i32) (i32.const 368))
  (func (export "\u{1f09}") (result i32) (i32.const 369))
  (func (export "\u{1f0a}") (result i32) (i32.const 370))
  (func (export "\u{1f0b}") (result i32) (i32.const 371))
  (func (export "\u{1f0c}") (result i32) (i32.const 372))
  (func (export "\u{1f0d}") (result i32) (i32.const 373))
  (func (export "\u{1f0e}") (result i32) (i32.const 374))
  (func (export "\u{1f0f}") (result i32) (i32.const 375))
  (func (export "\u{1f88}") (result i32) (i32.const 376))
  (func (export "\u{1f89}") (result i32) (i32.const 377))
  (func (export "\u{1f8a}") (result i32) (i32.const 378))
  (func (export "\u{1f8b}") (result i32) (i32.const 379))
  (func (export "\u{1f8c}") (result i32) (i32.const 380))
  (func (export "\u{1f8d}") (result i32) (i32.const 381))
  (func (export "\u{1f8e}") (result i32) (i32.const 382))
  (func (export "\u{1f8f}") (result i32) (i32.const 383))
  (func (export "\u{1fb8}") (result i32) (i32.const 384))
  (func (export "\u{1fb9}") (result i32) (i32.const 385))
  (func (export "\u{1fba}") (result i32) (i32.const 386))
  (func (export "\u{1fbb}") (result i32) (i32.const 387))
  (func (export "\u{1fbc}") (result i32) (i32.const 388))
  (func (export "\u{1d6a8}") (result i32) (i32.const 389))
  (func (export "\u{1d6e2}") (result i32) (i32.const 390))
  (func (export "\u{1d71c}") (result i32) (i32.const 391))
  (func (export "\u{1d756}") (result i32) (i32.const 392))
  (func (export "\u{1d790}") (result i32) (i32.const 393))
  (func (export "\u{2376}") (result i32) (i32.const 394))
  (func (export "\u{237a}") (result i32) (i32.const 395))
  (func (export "\u{2a5c}") (result i32) (i32.const 396))
  (func (export "\u{15c5}") (result i32) (i32.const 397))
  (func (export "\u{13aa}") (result i32) (i32.const 398))

  ;; Test unmatched "closing" and "opening" code points.
  (func (export ")\u{2fa}\u{2fc}\u{145cf}\u{1d174}\u{1d176}\u{1d178}\u{1d17a}\u{207e}\u{208e}\u{2769}\u{276b}\u{27ef}\u{fd3f}\u{fe36}\u{fe5a}\u{ff09}\u{ff60}\u{e0029}\u{2773}\u{2775}\u{27e7}\u{27e9}\u{27eb}\u{27ed}\u{2988}\u{298a}\u{2996}\u{2e23}\u{2e25}\u{fe18}\u{fe38}\u{fe3a}\u{fe3c}\u{fe3e}\u{fe40}\u{fe42}\u{fe44}\u{fe48}\u{fe5c}\u{fe5e}\u{ff3d}\u{ff5d}\u{ff63}\u{e005d}\u{e007d}\u{bb}\u{2019}\u{201d}\u{203a}\u{276f}") (result i32) (i32.const 399))
  (func (export "(\u{2f9}\u{2fb}\u{145ce}\u{1d173}\u{1d175}\u{1d177}\u{1d179}\u{207d}\u{208d}\u{2768}\u{276a}\u{27ee}\u{fd3e}\u{fe35}\u{fe59}\u{ff08}\u{ff5f}\u{e0028}\u{2772}\u{2774}\u{27e6}\u{27e8}\u{27ea}\u{27ec}\u{2987}\u{2989}\u{2995}\u{2e22}\u{2e24}\u{fe17}\u{fe37}\u{fe39}\u{fe3b}\u{fe3d}\u{fe3f}\u{fe41}\u{fe43}\u{fe47}\u{fe5b}\u{fe5d}\u{ff3b}\u{ff5b}\u{ff62}\u{e005b}\u{e007b}\u{ab}\u{2018}\u{201c}\u{2039}\u{276e}") (result i32) (i32.const 400))
  (func (export "\u{1da8b}\u{1daa4}") (result i32) (i32.const 401))
  (func (export "\u{1da8b}") (result i32) (i32.const 402))

  ;; Test that Unicode fraction normalization is not applied.
  (func (export "\u{bd}") (result i32) (i32.const 403))
  (func (export "1\u{2044}2") (result i32) (i32.const 404))
  (func (export "1/2") (result i32) (i32.const 405))
  (func (export "\u{b73}") (result i32) (i32.const 406))
  (func (export "\u{d74}") (result i32) (i32.const 407))
  (func (export "\u{2cfd}") (result i32) (i32.const 408))
  (func (export "\u{a831}") (result i32) (i32.const 409))
  (func (export "\u{10141}") (result i32) (i32.const 410))
  (func (export "\u{10175}") (result i32) (i32.const 411))
  (func (export "\u{10176}") (result i32) (i32.const 412))
  (func (export "\u{109bd}") (result i32) (i32.const 413))
  (func (export "\u{10e7b}") (result i32) (i32.const 414))

  ;; Test a full-width quote.
  (func (export "\u{ff02}") (result i32) (i32.const 415))

  ;; Test that different present and historical representations of the "delete"
  ;; concept are distinct.
  (func (export "\\7f") (result i32) (i32.const 416))
  (func (export "\\08") (result i32) (i32.const 417))
  (func (export "\u{232b}") (result i32) (i32.const 418))
  (func (export "\u{2326}") (result i32) (i32.const 419))
  (func (export "\u{2408}") (result i32) (i32.const 420))
  (func (export "\u{2421}") (result i32) (i32.const 421))
  (func (export "\u{1dfb}") (result i32) (i32.const 422))
  (func (export "\\0f") (result i32) (i32.const 423))
  (func (export "\u{2190}") (result i32) (i32.const 424))
  (func (export "\u{2327}") (result i32) (i32.const 425))
  (func (export "\u{2352}") (result i32) (i32.const 426))
  (func (export "\u{2354}") (result i32) (i32.const 427))
  (func (export "\u{2362}") (result i32) (i32.const 428))
  (func (export "\u{236b}") (result i32) (i32.const 429))

  ;; Test that different representations of the "substitute" concept are
  ;; distinct. (U+FFFD is covered above.)
  (func (export "\\1a") (result i32) (i32.const 430))
  (func (export "\u{2426}") (result i32) (i32.const 431))
  (func (export "\u{241a}") (result i32) (i32.const 432))
  (func (export "\u{fffc}") (result i32) (i32.const 433))
  (func (export "?") (result i32) (i32.const 434))
  (func (export "\u{bf}") (result i32) (i32.const 435))
  (func (export "\u{1945}") (result i32) (i32.const 436))
  (func (export "\u{37e}") (result i32) (i32.const 437))
  (func (export "\u{55e}") (result i32) (i32.const 438))
  (func (export "\u{61f}") (result i32) (i32.const 439))
  (func (export "\u{1367}") (result i32) (i32.const 440))
  (func (export "\u{2047}") (result i32) (i32.const 441))
  (func (export "\u{2370}") (result i32) (i32.const 442))
  (func (export "\u{2753}") (result i32) (i32.const 443))
  (func (export "\u{2754}") (result i32) (i32.const 444))
  (func (export "\u{2cfa}") (result i32) (i32.const 445))
  (func (export "\u{2cfb}") (result i32) (i32.const 446))
  (func (export "\u{2e2e}") (result i32) (i32.const 447))
  (func (export "\u{3244}") (result i32) (i32.const 448))
  (func (export "\u{a60f}") (result i32) (i32.const 449))
  (func (export "\u{a6f7}") (result i32) (i32.const 450))
  (func (export "\u{fe16}") (result i32) (i32.const 451))
  (func (export "\u{fe56}") (result i32) (i32.const 452))
  (func (export "\u{ff1f}") (result i32) (i32.const 453))
  (func (export "\u{11143}") (result i32) (i32.const 454))
  (func (export "\u{1e95f}") (result i32) (i32.const 455))
  (func (export "\u{e003f}") (result i32) (i32.const 456))
  (func (export "\u{16844}") (result i32) (i32.const 457))
  (func (export "\u{2bd1}") (result i32) (i32.const 458))

  ;; Test that different present and historical representations of the
  ;; "paragraph" concept are distinct. (U+2029 is covered above).
  (func (export "\u{b6}") (result i32) (i32.const 459))
  (func (export "\u{204b}") (result i32) (i32.const 460))
  (func (export "\u{700}") (result i32) (i32.const 461))
  (func (export "\u{10fb}") (result i32) (i32.const 462))
  (func (export "\u{1368}") (result i32) (i32.const 463))
  (func (export "\u{3037}") (result i32) (i32.const 464))
  (func (export "\u{2761}") (result i32) (i32.const 465))
  (func (export "\u{2e0f}") (result i32) (i32.const 466))
  (func (export "\u{2e10}") (result i32) (i32.const 467))
  (func (export "\u{2e11}") (result i32) (i32.const 468))
  (func (export "\u{2e0e}") (result i32) (i32.const 469))
  (func (export "\\14") (result i32) (i32.const 470)) ;; \u{b6} in CP437
  (func (export "\u{2619}") (result i32) (i32.const 471))
  (func (export "\u{2e3f}") (result i32) (i32.const 472))
  (func (export "\u{3007}") (result i32) (i32.const 473))
  (func (export "\u{e5b}") (result i32) (i32.const 474))

  ;; Test an unusual character.
  (func (export "\u{a66e}") (result i32) (i32.const 475))

  ;; Test the three characters whose normalization forms under NFC, NFD, NFKC,
  ;; and NFKD are all different.
  ;; http://unicode.org/faq/normalization.html#6
  (func (export "\u{3d3}") (result i32) (i32.const 476))
  (func (export "\u{3d4}") (result i32) (i32.const 477))
  (func (export "\u{1e9b}") (result i32) (i32.const 478))
)`);

// ./test/core/names.wast:615
assert_return(() => invoke($2, ``, []), [value("i32", 0)]);

// ./test/core/names.wast:616
assert_return(() => invoke($2, `0`, []), [value("i32", 1)]);

// ./test/core/names.wast:617
assert_return(() => invoke($2, `-0`, []), [value("i32", 2)]);

// ./test/core/names.wast:618
assert_return(() => invoke($2, `_`, []), [value("i32", 3)]);

// ./test/core/names.wast:619
assert_return(() => invoke($2, `$$`, []), [value("i32", 4)]);

// ./test/core/names.wast:620
assert_return(() => invoke($2, `@`, []), [value("i32", 5)]);

// ./test/core/names.wast:621
assert_return(() => invoke($2, `~!@#$$%^&*()_+\`-={}|[]\\:";'<>?,./ `, []), [value("i32", 6)]);

// ./test/core/names.wast:622
assert_return(() => invoke($2, `NaN`, []), [value("i32", 7)]);

// ./test/core/names.wast:623
assert_return(() => invoke($2, `Infinity`, []), [value("i32", 8)]);

// ./test/core/names.wast:624
assert_return(() => invoke($2, `if`, []), [value("i32", 9)]);

// ./test/core/names.wast:625
assert_return(() => invoke($2, `malloc`, []), [value("i32", 10)]);

// ./test/core/names.wast:626
assert_return(() => invoke($2, `_malloc`, []), [value("i32", 11)]);

// ./test/core/names.wast:627
assert_return(() => invoke($2, `__malloc`, []), [value("i32", 12)]);

// ./test/core/names.wast:628
assert_return(() => invoke($2, `a`, []), [value("i32", 13)]);

// ./test/core/names.wast:629
assert_return(() => invoke($2, `A`, []), [value("i32", 14)]);

// ./test/core/names.wast:630
assert_return(() => invoke($2, `\u{feff}`, []), [value("i32", 15)]);

// ./test/core/names.wast:631
assert_return(() => invoke($2, `\u{c5}`, []), [value("i32", 16)]);

// ./test/core/names.wast:632
assert_return(() => invoke($2, `A\u{30a}`, []), [value("i32", 17)]);

// ./test/core/names.wast:633
assert_return(() => invoke($2, `\u{212b}`, []), [value("i32", 18)]);

// ./test/core/names.wast:634
assert_return(() => invoke($2, `\u{fb03}`, []), [value("i32", 19)]);

// ./test/core/names.wast:635
assert_return(() => invoke($2, `f\u{fb01}`, []), [value("i32", 20)]);

// ./test/core/names.wast:636
assert_return(() => invoke($2, `ffi`, []), [value("i32", 21)]);

// ./test/core/names.wast:637
assert_return(
  () => invoke($2, `\x00\x01\x02\x03\x04\x05\x06\x07\x08 
\x0b\x0c\x0d\x0e\x0f`, []),
  [value("i32", 22)],
);

// ./test/core/names.wast:638
assert_return(
  () => invoke($2, `\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f`, []),
  [value("i32", 23)],
);

// ./test/core/names.wast:639
assert_return(() => invoke($2, ` \x7f`, []), [value("i32", 24)]);

// ./test/core/names.wast:640
assert_return(
  () => invoke($2,
    `\u{80}\u{81}\u{82}\u{83}\u{84}\u{85}\u{86}\u{87}\u{88}\u{89}\u{8a}\u{8b}\u{8c}\u{8d}\u{8e}\u{8f}`,
    [],
  ),
  [value("i32", 25)],
);

// ./test/core/names.wast:641
assert_return(
  () => invoke($2,
    `\u{90}\u{91}\u{92}\u{93}\u{94}\u{95}\u{96}\u{97}\u{98}\u{99}\u{9a}\u{9b}\u{9c}\u{9d}\u{9e}\u{9f}`,
    [],
  ),
  [value("i32", 26)],
);

// ./test/core/names.wast:642
assert_return(
  () => invoke($2, `\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}`, []),
  [value("i32", 27)],
);

// ./test/core/names.wast:643
assert_return(
  () => invoke($2, `\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}\u{fffe}\u{ffff}`, []),
  [value("i32", 28)],
);

// ./test/core/names.wast:644
assert_return(
  () => invoke($2,
    `\u{2400}\u{2401}\u{2402}\u{2403}\u{2404}\u{2405}\u{2406}\u{2407}\u{2408}\u{2409}\u{240a}\u{240b}\u{240c}\u{240d}\u{240e}\u{240f}`,
    [],
  ),
  [value("i32", 29)],
);

// ./test/core/names.wast:645
assert_return(
  () => invoke($2,
    `\u{2410}\u{2411}\u{2412}\u{2413}\u{2414}\u{2415}\u{2416}\u{2417}\u{2418}\u{2419}\u{241a}\u{241b}\u{241c}\u{241d}\u{241e}\u{241f}`,
    [],
  ),
  [value("i32", 30)],
);

// ./test/core/names.wast:646
assert_return(() => invoke($2, `\u{2420}\u{2421}`, []), [value("i32", 31)]);

// ./test/core/names.wast:647
assert_return(
  () => invoke($2,
    `\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}`,
    [],
  ),
  [value("i32", 32)],
);

// ./test/core/names.wast:648
assert_return(() => invoke($2, `\u{200d}`, []), [value("i32", 33)]);

// ./test/core/names.wast:649
assert_return(() => invoke($2, `\u{200c}`, []), [value("i32", 34)]);

// ./test/core/names.wast:650
assert_return(() => invoke($2, `\u{34f}`, []), [value("i32", 35)]);

// ./test/core/names.wast:651
assert_return(() => invoke($2, `\u{2060}`, []), [value("i32", 36)]);

// ./test/core/names.wast:652
assert_return(() => invoke($2, `\u{2d7f}`, []), [value("i32", 37)]);

// ./test/core/names.wast:653
assert_return(() => invoke($2, `\u{1107f}`, []), [value("i32", 38)]);

// ./test/core/names.wast:654
assert_return(() => invoke($2, `\u{180e}`, []), [value("i32", 39)]);

// ./test/core/names.wast:655
assert_return(
  () => invoke($2, `\u{ffef}\u{200b}\u{a0}\u{ad}\u{2060}\u{1680}\u{202e}\u{202d}`, []),
  [value("i32", 40)],
);

// ./test/core/names.wast:656
assert_return(
  () => invoke($2,
    `\u{200e}\u{200f}\u{2011}\u{2028}\u{2029}\u{202a}\u{202b}\u{202c}\u{202f}\u{2066}\u{2067}\u{2068}\u{2069}`,
    [],
  ),
  [value("i32", 41)],
);

// ./test/core/names.wast:657
assert_return(
  () => invoke($2, `\u{206a}\u{206b}\u{206c}\u{206d}\u{206e}\u{206f}`, []),
  [value("i32", 42)],
);

// ./test/core/names.wast:658
assert_return(() => invoke($2, `\u{2061}\u{2062}\u{2063}\u{2064}`, []), [value("i32", 43)]);

// ./test/core/names.wast:659
assert_return(() => invoke($2, `\u{10000}\u{dffff}\u{10ffff}`, []), [value("i32", 44)]);

// ./test/core/names.wast:660
assert_return(
  () => invoke($2,
    `Z\u{30f}\u{346}\u{306}\u{35b}\u{34c}\u{334}\u{358}\u{35e}\u{347}\u{32b}\u{325}\u{32a}\u{353}\u{348}\u{354}\u{34e}\u{317}\u{31e}\u{33a}\u{32f}\u{331}\u{31e}\u{319}\u{331}\u{31c}\u{316}\u{320}a\u{357}\u{368}\u{30e}\u{304}\u{306}\u{357}\u{33f}\u{361}\u{35f}\u{340}\u{336}\u{341}\u{325}\u{330}\u{333}\u{32d}\u{359}\u{332}\u{331}\u{339}\u{31d}\u{34e}\u{33c}l\u{344}\u{34a}\u{31a}\u{357}\u{366}\u{344}\u{36b}\u{307}\u{341}\u{336}\u{337}\u{349}\u{329}\u{339}\u{32b}\u{31d}\u{356}\u{345}\u{319}\u{332}\u{33c}\u{347}\u{35a}\u{34d}\u{32e}\u{34e}\u{325}\u{345}\u{31e}g\u{343}\u{310}\u{305}\u{36e}\u{314}\u{310}\u{30e}\u{302}\u{30f}\u{33e}\u{34a}\u{30d}\u{34b}\u{34a}\u{367}\u{301}\u{306}\u{366}\u{35e}\u{336}\u{355}\u{354}\u{35a}\u{329}o\u{34b}\u{314}\u{350}\u{36a}\u{369}\u{321}\u{34f}\u{322}\u{327}\u{341}\u{32b}\u{319}\u{324}\u{32e}\u{356}\u{359}\u{353}\u{33a}\u{31c}\u{329}\u{33c}\u{318}\u{320}`,
    [],
  ),
  [value("i32", 45)],
);

// ./test/core/names.wast:661
assert_return(() => invoke($2, `\u{115f}\u{1160}\u{3164}\u{ffa0}`, []), [value("i32", 46)]);

// ./test/core/names.wast:662
assert_return(() => invoke($2, `\u{fe00}`, []), [value("i32", 47)]);

// ./test/core/names.wast:663
assert_return(() => invoke($2, `\u{fe04}`, []), [value("i32", 48)]);

// ./test/core/names.wast:664
assert_return(() => invoke($2, `\u{e0100}`, []), [value("i32", 49)]);

// ./test/core/names.wast:665
assert_return(() => invoke($2, `\u{e01ef}`, []), [value("i32", 50)]);

// ./test/core/names.wast:666
assert_return(() => invoke($2, `\u{308}`, []), [value("i32", 51)]);

// ./test/core/names.wast:667
assert_return(() => invoke($2, `
`, []), [value("i32", 52)]);

// ./test/core/names.wast:668
assert_return(() => invoke($2, `\u{2424}`, []), [value("i32", 53)]);

// ./test/core/names.wast:669
assert_return(() => invoke($2, `\u{2028}`, []), [value("i32", 54)]);

// ./test/core/names.wast:670
assert_return(() => invoke($2, `\x0d`, []), [value("i32", 55)]);

// ./test/core/names.wast:671
assert_return(() => invoke($2, `\x0d
`, []), [value("i32", 56)]);

// ./test/core/names.wast:672
assert_return(() => invoke($2, `
\x0d`, []), [value("i32", 57)]);

// ./test/core/names.wast:673
assert_return(() => invoke($2, `\x1e`, []), [value("i32", 58)]);

// ./test/core/names.wast:674
assert_return(() => invoke($2, `\x0b`, []), [value("i32", 59)]);

// ./test/core/names.wast:675
assert_return(() => invoke($2, `\x0c`, []), [value("i32", 60)]);

// ./test/core/names.wast:676
assert_return(() => invoke($2, `\u{85}`, []), [value("i32", 61)]);

// ./test/core/names.wast:677
assert_return(() => invoke($2, `\u{2029}`, []), [value("i32", 62)]);

// ./test/core/names.wast:678
assert_return(() => invoke($2, `\u{2026}`, []), [value("i32", 63)]);

// ./test/core/names.wast:679
assert_return(() => invoke($2, `\u{23ce}`, []), [value("i32", 64)]);

// ./test/core/names.wast:680
assert_return(() => invoke($2, `\u{8b}`, []), [value("i32", 65)]);

// ./test/core/names.wast:681
assert_return(() => invoke($2, `\u{8c}`, []), [value("i32", 66)]);

// ./test/core/names.wast:682
assert_return(() => invoke($2, `\u{8d}`, []), [value("i32", 67)]);

// ./test/core/names.wast:683
assert_return(() => invoke($2, `\u{21b5}`, []), [value("i32", 68)]);

// ./test/core/names.wast:684
assert_return(() => invoke($2, `\u{21a9}`, []), [value("i32", 69)]);

// ./test/core/names.wast:685
assert_return(() => invoke($2, `\u{2324}`, []), [value("i32", 70)]);

// ./test/core/names.wast:686
assert_return(() => invoke($2, `\u{2936}`, []), [value("i32", 71)]);

// ./test/core/names.wast:687
assert_return(() => invoke($2, `\u{21b2}`, []), [value("i32", 72)]);

// ./test/core/names.wast:688
assert_return(() => invoke($2, `\u{2ba8}`, []), [value("i32", 73)]);

// ./test/core/names.wast:689
assert_return(() => invoke($2, `\u{2bb0}`, []), [value("i32", 74)]);

// ./test/core/names.wast:690
assert_return(() => invoke($2, `\u{fffd}`, []), [value("i32", 75)]);

// ./test/core/names.wast:691
assert_return(() => invoke($2, `\u{fdd0}`, []), [value("i32", 76)]);

// ./test/core/names.wast:692
assert_return(() => invoke($2, `\u{fdd1}`, []), [value("i32", 77)]);

// ./test/core/names.wast:693
assert_return(() => invoke($2, `\u{fdd2}`, []), [value("i32", 78)]);

// ./test/core/names.wast:694
assert_return(() => invoke($2, `\u{fdd3}`, []), [value("i32", 79)]);

// ./test/core/names.wast:695
assert_return(() => invoke($2, `\u{fdd4}`, []), [value("i32", 80)]);

// ./test/core/names.wast:696
assert_return(() => invoke($2, `\u{fdd5}`, []), [value("i32", 81)]);

// ./test/core/names.wast:697
assert_return(() => invoke($2, `\u{fdd6}`, []), [value("i32", 82)]);

// ./test/core/names.wast:698
assert_return(() => invoke($2, `\u{fdd7}`, []), [value("i32", 83)]);

// ./test/core/names.wast:699
assert_return(() => invoke($2, `\u{fdd8}`, []), [value("i32", 84)]);

// ./test/core/names.wast:700
assert_return(() => invoke($2, `\u{fdd9}`, []), [value("i32", 85)]);

// ./test/core/names.wast:701
assert_return(() => invoke($2, `\u{fdda}`, []), [value("i32", 86)]);

// ./test/core/names.wast:702
assert_return(() => invoke($2, `\u{fddb}`, []), [value("i32", 87)]);

// ./test/core/names.wast:703
assert_return(() => invoke($2, `\u{fddc}`, []), [value("i32", 88)]);

// ./test/core/names.wast:704
assert_return(() => invoke($2, `\u{fddd}`, []), [value("i32", 89)]);

// ./test/core/names.wast:705
assert_return(() => invoke($2, `\u{fdde}`, []), [value("i32", 90)]);

// ./test/core/names.wast:706
assert_return(() => invoke($2, `\u{fddf}`, []), [value("i32", 91)]);

// ./test/core/names.wast:707
assert_return(() => invoke($2, `\u{fde0}`, []), [value("i32", 92)]);

// ./test/core/names.wast:708
assert_return(() => invoke($2, `\u{fde1}`, []), [value("i32", 93)]);

// ./test/core/names.wast:709
assert_return(() => invoke($2, `\u{fde2}`, []), [value("i32", 94)]);

// ./test/core/names.wast:710
assert_return(() => invoke($2, `\u{fde3}`, []), [value("i32", 95)]);

// ./test/core/names.wast:711
assert_return(() => invoke($2, `\u{fde4}`, []), [value("i32", 96)]);

// ./test/core/names.wast:712
assert_return(() => invoke($2, `\u{fde5}`, []), [value("i32", 97)]);

// ./test/core/names.wast:713
assert_return(() => invoke($2, `\u{fde6}`, []), [value("i32", 98)]);

// ./test/core/names.wast:714
assert_return(() => invoke($2, `\u{fde7}`, []), [value("i32", 99)]);

// ./test/core/names.wast:715
assert_return(() => invoke($2, `\u{fde8}`, []), [value("i32", 100)]);

// ./test/core/names.wast:716
assert_return(() => invoke($2, `\u{fde9}`, []), [value("i32", 101)]);

// ./test/core/names.wast:717
assert_return(() => invoke($2, `\u{fdea}`, []), [value("i32", 102)]);

// ./test/core/names.wast:718
assert_return(() => invoke($2, `\u{fdeb}`, []), [value("i32", 103)]);

// ./test/core/names.wast:719
assert_return(() => invoke($2, `\u{fdec}`, []), [value("i32", 104)]);

// ./test/core/names.wast:720
assert_return(() => invoke($2, `\u{fded}`, []), [value("i32", 105)]);

// ./test/core/names.wast:721
assert_return(() => invoke($2, `\u{fdee}`, []), [value("i32", 106)]);

// ./test/core/names.wast:722
assert_return(() => invoke($2, `\u{fdef}`, []), [value("i32", 107)]);

// ./test/core/names.wast:723
assert_return(() => invoke($2, `\u{fffe}`, []), [value("i32", 108)]);

// ./test/core/names.wast:724
assert_return(() => invoke($2, `\u{ffff}`, []), [value("i32", 109)]);

// ./test/core/names.wast:725
assert_return(() => invoke($2, `\u{1fffe}`, []), [value("i32", 110)]);

// ./test/core/names.wast:726
assert_return(() => invoke($2, `\u{1ffff}`, []), [value("i32", 111)]);

// ./test/core/names.wast:727
assert_return(() => invoke($2, `\u{2fffe}`, []), [value("i32", 112)]);

// ./test/core/names.wast:728
assert_return(() => invoke($2, `\u{2ffff}`, []), [value("i32", 113)]);

// ./test/core/names.wast:729
assert_return(() => invoke($2, `\u{3fffe}`, []), [value("i32", 114)]);

// ./test/core/names.wast:730
assert_return(() => invoke($2, `\u{3ffff}`, []), [value("i32", 115)]);

// ./test/core/names.wast:731
assert_return(() => invoke($2, `\u{4fffe}`, []), [value("i32", 116)]);

// ./test/core/names.wast:732
assert_return(() => invoke($2, `\u{4ffff}`, []), [value("i32", 117)]);

// ./test/core/names.wast:733
assert_return(() => invoke($2, `\u{5fffe}`, []), [value("i32", 118)]);

// ./test/core/names.wast:734
assert_return(() => invoke($2, `\u{5ffff}`, []), [value("i32", 119)]);

// ./test/core/names.wast:735
assert_return(() => invoke($2, `\u{6fffe}`, []), [value("i32", 120)]);

// ./test/core/names.wast:736
assert_return(() => invoke($2, `\u{6ffff}`, []), [value("i32", 121)]);

// ./test/core/names.wast:737
assert_return(() => invoke($2, `\u{7fffe}`, []), [value("i32", 122)]);

// ./test/core/names.wast:738
assert_return(() => invoke($2, `\u{7ffff}`, []), [value("i32", 123)]);

// ./test/core/names.wast:739
assert_return(() => invoke($2, `\u{8fffe}`, []), [value("i32", 124)]);

// ./test/core/names.wast:740
assert_return(() => invoke($2, `\u{8ffff}`, []), [value("i32", 125)]);

// ./test/core/names.wast:741
assert_return(() => invoke($2, `\u{9fffe}`, []), [value("i32", 126)]);

// ./test/core/names.wast:742
assert_return(() => invoke($2, `\u{9ffff}`, []), [value("i32", 127)]);

// ./test/core/names.wast:743
assert_return(() => invoke($2, `\u{afffe}`, []), [value("i32", 128)]);

// ./test/core/names.wast:744
assert_return(() => invoke($2, `\u{affff}`, []), [value("i32", 129)]);

// ./test/core/names.wast:745
assert_return(() => invoke($2, `\u{bfffe}`, []), [value("i32", 130)]);

// ./test/core/names.wast:746
assert_return(() => invoke($2, `\u{bffff}`, []), [value("i32", 131)]);

// ./test/core/names.wast:747
assert_return(() => invoke($2, `\u{cfffe}`, []), [value("i32", 132)]);

// ./test/core/names.wast:748
assert_return(() => invoke($2, `\u{cffff}`, []), [value("i32", 133)]);

// ./test/core/names.wast:749
assert_return(() => invoke($2, `\u{dfffe}`, []), [value("i32", 134)]);

// ./test/core/names.wast:750
assert_return(() => invoke($2, `\u{dffff}`, []), [value("i32", 135)]);

// ./test/core/names.wast:751
assert_return(() => invoke($2, `\u{efffe}`, []), [value("i32", 136)]);

// ./test/core/names.wast:752
assert_return(() => invoke($2, `\u{effff}`, []), [value("i32", 137)]);

// ./test/core/names.wast:753
assert_return(() => invoke($2, `\u{ffffe}`, []), [value("i32", 138)]);

// ./test/core/names.wast:754
assert_return(() => invoke($2, `\u{fffff}`, []), [value("i32", 139)]);

// ./test/core/names.wast:755
assert_return(() => invoke($2, `\u{10fffe}`, []), [value("i32", 140)]);

// ./test/core/names.wast:756
assert_return(() => invoke($2, `\u{10ffff}`, []), [value("i32", 141)]);

// ./test/core/names.wast:757
assert_return(() => invoke($2, `\u{308}\u{203d}\u{308}\u{309}`, []), [value("i32", 142)]);

// ./test/core/names.wast:758
assert_return(() => invoke($2, `abc`, []), [value("i32", 143)]);

// ./test/core/names.wast:759
assert_return(() => invoke($2, `\u{202d}abc`, []), [value("i32", 144)]);

// ./test/core/names.wast:760
assert_return(() => invoke($2, `\u{202e}cba`, []), [value("i32", 145)]);

// ./test/core/names.wast:761
assert_return(() => invoke($2, `\u{202d}abc\u{202e}`, []), [value("i32", 146)]);

// ./test/core/names.wast:762
assert_return(() => invoke($2, `\u{202e}cba\u{202d}`, []), [value("i32", 147)]);

// ./test/core/names.wast:763
assert_return(() => invoke($2, `\u{1d468}`, []), [value("i32", 148)]);

// ./test/core/names.wast:764
assert_return(() => invoke($2, `\u{1d434}`, []), [value("i32", 149)]);

// ./test/core/names.wast:765
assert_return(() => invoke($2, `\u{1d608}`, []), [value("i32", 150)]);

// ./test/core/names.wast:766
assert_return(() => invoke($2, `\u{1d63c}`, []), [value("i32", 151)]);

// ./test/core/names.wast:767
assert_return(() => invoke($2, `\u{1d400}`, []), [value("i32", 152)]);

// ./test/core/names.wast:768
assert_return(() => invoke($2, `\u{1d4d0}`, []), [value("i32", 153)]);

// ./test/core/names.wast:769
assert_return(() => invoke($2, `\u{1d56c}`, []), [value("i32", 154)]);

// ./test/core/names.wast:770
assert_return(() => invoke($2, `\u{1d5d4}`, []), [value("i32", 155)]);

// ./test/core/names.wast:771
assert_return(() => invoke($2, `\u{1d49c}`, []), [value("i32", 156)]);

// ./test/core/names.wast:772
assert_return(() => invoke($2, `\u{1d504}`, []), [value("i32", 157)]);

// ./test/core/names.wast:773
assert_return(() => invoke($2, `\u{1d538}`, []), [value("i32", 158)]);

// ./test/core/names.wast:774
assert_return(() => invoke($2, `\u{1d5a0}`, []), [value("i32", 159)]);

// ./test/core/names.wast:775
assert_return(() => invoke($2, `\u{1d670}`, []), [value("i32", 160)]);

// ./test/core/names.wast:776
assert_return(() => invoke($2, `\u{1d00}`, []), [value("i32", 161)]);

// ./test/core/names.wast:777
assert_return(() => invoke($2, `\u{1d2c}`, []), [value("i32", 162)]);

// ./test/core/names.wast:778
assert_return(() => invoke($2, `\u{24b6}`, []), [value("i32", 163)]);

// ./test/core/names.wast:779
assert_return(() => invoke($2, `\u{ff21}`, []), [value("i32", 164)]);

// ./test/core/names.wast:780
assert_return(() => invoke($2, `\u{1f110}`, []), [value("i32", 165)]);

// ./test/core/names.wast:781
assert_return(() => invoke($2, `\u{1f130}`, []), [value("i32", 166)]);

// ./test/core/names.wast:782
assert_return(() => invoke($2, `\u{e0041}`, []), [value("i32", 167)]);

// ./test/core/names.wast:783
assert_return(() => invoke($2, `U+0041`, []), [value("i32", 168)]);

// ./test/core/names.wast:784
assert_return(() => invoke($2, `A\u{200b}`, []), [value("i32", 169)]);

// ./test/core/names.wast:785
assert_return(() => invoke($2, `\u{410}`, []), [value("i32", 170)]);

// ./test/core/names.wast:786
assert_return(() => invoke($2, `\u{a656}`, []), [value("i32", 171)]);

// ./test/core/names.wast:787
assert_return(() => invoke($2, `\u{2dfc}`, []), [value("i32", 172)]);

// ./test/core/names.wast:788
assert_return(() => invoke($2, `\u{2df6}`, []), [value("i32", 173)]);

// ./test/core/names.wast:789
assert_return(() => invoke($2, `\u{2c6f}`, []), [value("i32", 174)]);

// ./test/core/names.wast:790
assert_return(() => invoke($2, `\u{1f150}`, []), [value("i32", 175)]);

// ./test/core/names.wast:791
assert_return(() => invoke($2, `\u{1f170}`, []), [value("i32", 176)]);

// ./test/core/names.wast:792
assert_return(() => invoke($2, `\u{2c2d}`, []), [value("i32", 177)]);

// ./test/core/names.wast:793
assert_return(() => invoke($2, `\u{10402}`, []), [value("i32", 178)]);

// ./test/core/names.wast:794
assert_return(() => invoke($2, `\u{10408}`, []), [value("i32", 179)]);

// ./test/core/names.wast:795
assert_return(() => invoke($2, `\u{104b0}`, []), [value("i32", 180)]);

// ./test/core/names.wast:796
assert_return(() => invoke($2, `\u{c0}`, []), [value("i32", 181)]);

// ./test/core/names.wast:797
assert_return(() => invoke($2, `\u{c1}`, []), [value("i32", 182)]);

// ./test/core/names.wast:798
assert_return(() => invoke($2, `\u{c2}`, []), [value("i32", 183)]);

// ./test/core/names.wast:799
assert_return(() => invoke($2, `\u{c3}`, []), [value("i32", 184)]);

// ./test/core/names.wast:800
assert_return(() => invoke($2, `\u{c4}`, []), [value("i32", 185)]);

// ./test/core/names.wast:801
assert_return(() => invoke($2, `\u{100}`, []), [value("i32", 186)]);

// ./test/core/names.wast:802
assert_return(() => invoke($2, `\u{102}`, []), [value("i32", 187)]);

// ./test/core/names.wast:803
assert_return(() => invoke($2, `\u{104}`, []), [value("i32", 188)]);

// ./test/core/names.wast:804
assert_return(() => invoke($2, `\u{1cd}`, []), [value("i32", 189)]);

// ./test/core/names.wast:805
assert_return(() => invoke($2, `\u{1de}`, []), [value("i32", 190)]);

// ./test/core/names.wast:806
assert_return(() => invoke($2, `\u{1e0}`, []), [value("i32", 191)]);

// ./test/core/names.wast:807
assert_return(() => invoke($2, `\u{1fa}`, []), [value("i32", 192)]);

// ./test/core/names.wast:808
assert_return(() => invoke($2, `\u{200}`, []), [value("i32", 193)]);

// ./test/core/names.wast:809
assert_return(() => invoke($2, `\u{202}`, []), [value("i32", 194)]);

// ./test/core/names.wast:810
assert_return(() => invoke($2, `\u{226}`, []), [value("i32", 195)]);

// ./test/core/names.wast:811
assert_return(() => invoke($2, `\u{23a}`, []), [value("i32", 196)]);

// ./test/core/names.wast:812
assert_return(() => invoke($2, `\u{4d0}`, []), [value("i32", 197)]);

// ./test/core/names.wast:813
assert_return(() => invoke($2, `\u{4d2}`, []), [value("i32", 198)]);

// ./test/core/names.wast:814
assert_return(() => invoke($2, `\u{7ca}`, []), [value("i32", 199)]);

// ./test/core/names.wast:815
assert_return(() => invoke($2, `\u{821}`, []), [value("i32", 200)]);

// ./test/core/names.wast:816
assert_return(() => invoke($2, `\u{822}`, []), [value("i32", 201)]);

// ./test/core/names.wast:817
assert_return(() => invoke($2, `\u{823}`, []), [value("i32", 202)]);

// ./test/core/names.wast:818
assert_return(() => invoke($2, `\u{824}`, []), [value("i32", 203)]);

// ./test/core/names.wast:819
assert_return(() => invoke($2, `\u{825}`, []), [value("i32", 204)]);

// ./test/core/names.wast:820
assert_return(() => invoke($2, `\u{904}`, []), [value("i32", 205)]);

// ./test/core/names.wast:821
assert_return(() => invoke($2, `\u{905}`, []), [value("i32", 206)]);

// ./test/core/names.wast:822
assert_return(() => invoke($2, `\u{972}`, []), [value("i32", 207)]);

// ./test/core/names.wast:823
assert_return(() => invoke($2, `\u{985}`, []), [value("i32", 208)]);

// ./test/core/names.wast:824
assert_return(() => invoke($2, `\u{a05}`, []), [value("i32", 209)]);

// ./test/core/names.wast:825
assert_return(() => invoke($2, `\u{a85}`, []), [value("i32", 210)]);

// ./test/core/names.wast:826
assert_return(() => invoke($2, `\u{b05}`, []), [value("i32", 211)]);

// ./test/core/names.wast:827
assert_return(() => invoke($2, `\u{b85}`, []), [value("i32", 212)]);

// ./test/core/names.wast:828
assert_return(() => invoke($2, `\u{c05}`, []), [value("i32", 213)]);

// ./test/core/names.wast:829
assert_return(() => invoke($2, `\u{c85}`, []), [value("i32", 214)]);

// ./test/core/names.wast:830
assert_return(() => invoke($2, `\u{d05}`, []), [value("i32", 215)]);

// ./test/core/names.wast:831
assert_return(() => invoke($2, `\u{e30}`, []), [value("i32", 216)]);

// ./test/core/names.wast:832
assert_return(() => invoke($2, `\u{eb0}`, []), [value("i32", 217)]);

// ./test/core/names.wast:833
assert_return(() => invoke($2, `\u{f01}`, []), [value("i32", 218)]);

// ./test/core/names.wast:834
assert_return(() => invoke($2, `\u{f68}`, []), [value("i32", 219)]);

// ./test/core/names.wast:835
assert_return(() => invoke($2, `\u{fb8}`, []), [value("i32", 220)]);

// ./test/core/names.wast:836
assert_return(() => invoke($2, `\u{1021}`, []), [value("i32", 221)]);

// ./test/core/names.wast:837
assert_return(() => invoke($2, `\u{1022}`, []), [value("i32", 222)]);

// ./test/core/names.wast:838
assert_return(() => invoke($2, `\u{109c}`, []), [value("i32", 223)]);

// ./test/core/names.wast:839
assert_return(() => invoke($2, `\u{1161}`, []), [value("i32", 224)]);

// ./test/core/names.wast:840
assert_return(() => invoke($2, `\u{12a0}`, []), [value("i32", 225)]);

// ./test/core/names.wast:841
assert_return(() => invoke($2, `\u{12d0}`, []), [value("i32", 226)]);

// ./test/core/names.wast:842
assert_return(() => invoke($2, `\u{13a0}`, []), [value("i32", 227)]);

// ./test/core/names.wast:843
assert_return(() => invoke($2, `\u{140a}`, []), [value("i32", 228)]);

// ./test/core/names.wast:844
assert_return(() => invoke($2, `\u{15b3}`, []), [value("i32", 229)]);

// ./test/core/names.wast:845
assert_return(() => invoke($2, `\u{16a8}`, []), [value("i32", 230)]);

// ./test/core/names.wast:846
assert_return(() => invoke($2, `\u{16aa}`, []), [value("i32", 231)]);

// ./test/core/names.wast:847
assert_return(() => invoke($2, `\u{16c6}`, []), [value("i32", 232)]);

// ./test/core/names.wast:848
assert_return(() => invoke($2, `\u{1700}`, []), [value("i32", 233)]);

// ./test/core/names.wast:849
assert_return(() => invoke($2, `\u{1720}`, []), [value("i32", 234)]);

// ./test/core/names.wast:850
assert_return(() => invoke($2, `\u{1740}`, []), [value("i32", 235)]);

// ./test/core/names.wast:851
assert_return(() => invoke($2, `\u{1760}`, []), [value("i32", 236)]);

// ./test/core/names.wast:852
assert_return(() => invoke($2, `\u{1820}`, []), [value("i32", 237)]);

// ./test/core/names.wast:853
assert_return(() => invoke($2, `\u{1887}`, []), [value("i32", 238)]);

// ./test/core/names.wast:854
assert_return(() => invoke($2, `\u{1920}`, []), [value("i32", 239)]);

// ./test/core/names.wast:855
assert_return(() => invoke($2, `\u{1963}`, []), [value("i32", 240)]);

// ./test/core/names.wast:856
assert_return(() => invoke($2, `\u{1a15}`, []), [value("i32", 241)]);

// ./test/core/names.wast:857
assert_return(() => invoke($2, `\u{1a4b}`, []), [value("i32", 242)]);

// ./test/core/names.wast:858
assert_return(() => invoke($2, `\u{1a61}`, []), [value("i32", 243)]);

// ./test/core/names.wast:859
assert_return(() => invoke($2, `\u{1b83}`, []), [value("i32", 244)]);

// ./test/core/names.wast:860
assert_return(() => invoke($2, `\u{1bc0}`, []), [value("i32", 245)]);

// ./test/core/names.wast:861
assert_return(() => invoke($2, `\u{1bc1}`, []), [value("i32", 246)]);

// ./test/core/names.wast:862
assert_return(() => invoke($2, `\u{1c23}`, []), [value("i32", 247)]);

// ./test/core/names.wast:863
assert_return(() => invoke($2, `\u{1e00}`, []), [value("i32", 248)]);

// ./test/core/names.wast:864
assert_return(() => invoke($2, `\u{1ea0}`, []), [value("i32", 249)]);

// ./test/core/names.wast:865
assert_return(() => invoke($2, `\u{1ea2}`, []), [value("i32", 250)]);

// ./test/core/names.wast:866
assert_return(() => invoke($2, `\u{1ea4}`, []), [value("i32", 251)]);

// ./test/core/names.wast:867
assert_return(() => invoke($2, `\u{1ea6}`, []), [value("i32", 252)]);

// ./test/core/names.wast:868
assert_return(() => invoke($2, `\u{1ea8}`, []), [value("i32", 253)]);

// ./test/core/names.wast:869
assert_return(() => invoke($2, `\u{1eaa}`, []), [value("i32", 254)]);

// ./test/core/names.wast:870
assert_return(() => invoke($2, `\u{1eac}`, []), [value("i32", 255)]);

// ./test/core/names.wast:871
assert_return(() => invoke($2, `\u{1eae}`, []), [value("i32", 256)]);

// ./test/core/names.wast:872
assert_return(() => invoke($2, `\u{1eb0}`, []), [value("i32", 257)]);

// ./test/core/names.wast:873
assert_return(() => invoke($2, `\u{1eb2}`, []), [value("i32", 258)]);

// ./test/core/names.wast:874
assert_return(() => invoke($2, `\u{1eb4}`, []), [value("i32", 259)]);

// ./test/core/names.wast:875
assert_return(() => invoke($2, `\u{1eb6}`, []), [value("i32", 260)]);

// ./test/core/names.wast:876
assert_return(() => invoke($2, `\u{3042}`, []), [value("i32", 261)]);

// ./test/core/names.wast:877
assert_return(() => invoke($2, `\u{30a2}`, []), [value("i32", 262)]);

// ./test/core/names.wast:878
assert_return(() => invoke($2, `\u{311a}`, []), [value("i32", 263)]);

// ./test/core/names.wast:879
assert_return(() => invoke($2, `\u{314f}`, []), [value("i32", 264)]);

// ./test/core/names.wast:880
assert_return(() => invoke($2, `\u{320e}`, []), [value("i32", 265)]);

// ./test/core/names.wast:881
assert_return(() => invoke($2, `\u{320f}`, []), [value("i32", 266)]);

// ./test/core/names.wast:882
assert_return(() => invoke($2, `\u{3210}`, []), [value("i32", 267)]);

// ./test/core/names.wast:883
assert_return(() => invoke($2, `\u{3211}`, []), [value("i32", 268)]);

// ./test/core/names.wast:884
assert_return(() => invoke($2, `\u{3212}`, []), [value("i32", 269)]);

// ./test/core/names.wast:885
assert_return(() => invoke($2, `\u{3213}`, []), [value("i32", 270)]);

// ./test/core/names.wast:886
assert_return(() => invoke($2, `\u{3214}`, []), [value("i32", 271)]);

// ./test/core/names.wast:887
assert_return(() => invoke($2, `\u{3215}`, []), [value("i32", 272)]);

// ./test/core/names.wast:888
assert_return(() => invoke($2, `\u{3216}`, []), [value("i32", 273)]);

// ./test/core/names.wast:889
assert_return(() => invoke($2, `\u{3217}`, []), [value("i32", 274)]);

// ./test/core/names.wast:890
assert_return(() => invoke($2, `\u{3218}`, []), [value("i32", 275)]);

// ./test/core/names.wast:891
assert_return(() => invoke($2, `\u{3219}`, []), [value("i32", 276)]);

// ./test/core/names.wast:892
assert_return(() => invoke($2, `\u{321a}`, []), [value("i32", 277)]);

// ./test/core/names.wast:893
assert_return(() => invoke($2, `\u{321b}`, []), [value("i32", 278)]);

// ./test/core/names.wast:894
assert_return(() => invoke($2, `\u{326e}`, []), [value("i32", 279)]);

// ./test/core/names.wast:895
assert_return(() => invoke($2, `\u{326f}`, []), [value("i32", 280)]);

// ./test/core/names.wast:896
assert_return(() => invoke($2, `\u{3270}`, []), [value("i32", 281)]);

// ./test/core/names.wast:897
assert_return(() => invoke($2, `\u{3271}`, []), [value("i32", 282)]);

// ./test/core/names.wast:898
assert_return(() => invoke($2, `\u{3272}`, []), [value("i32", 283)]);

// ./test/core/names.wast:899
assert_return(() => invoke($2, `\u{3273}`, []), [value("i32", 284)]);

// ./test/core/names.wast:900
assert_return(() => invoke($2, `\u{3274}`, []), [value("i32", 285)]);

// ./test/core/names.wast:901
assert_return(() => invoke($2, `\u{3275}`, []), [value("i32", 286)]);

// ./test/core/names.wast:902
assert_return(() => invoke($2, `\u{3276}`, []), [value("i32", 287)]);

// ./test/core/names.wast:903
assert_return(() => invoke($2, `\u{3277}`, []), [value("i32", 288)]);

// ./test/core/names.wast:904
assert_return(() => invoke($2, `\u{3278}`, []), [value("i32", 289)]);

// ./test/core/names.wast:905
assert_return(() => invoke($2, `\u{3279}`, []), [value("i32", 290)]);

// ./test/core/names.wast:906
assert_return(() => invoke($2, `\u{327a}`, []), [value("i32", 291)]);

// ./test/core/names.wast:907
assert_return(() => invoke($2, `\u{327b}`, []), [value("i32", 292)]);

// ./test/core/names.wast:908
assert_return(() => invoke($2, `\u{32d0}`, []), [value("i32", 293)]);

// ./test/core/names.wast:909
assert_return(() => invoke($2, `\u{a00a}`, []), [value("i32", 294)]);

// ./test/core/names.wast:910
assert_return(() => invoke($2, `\u{a4ee}`, []), [value("i32", 295)]);

// ./test/core/names.wast:911
assert_return(() => invoke($2, `\u{a549}`, []), [value("i32", 296)]);

// ./test/core/names.wast:912
assert_return(() => invoke($2, `\u{a6a0}`, []), [value("i32", 297)]);

// ./test/core/names.wast:913
assert_return(() => invoke($2, `\u{a800}`, []), [value("i32", 298)]);

// ./test/core/names.wast:914
assert_return(() => invoke($2, `\u{a823}`, []), [value("i32", 299)]);

// ./test/core/names.wast:915
assert_return(() => invoke($2, `\u{a85d}`, []), [value("i32", 300)]);

// ./test/core/names.wast:916
assert_return(() => invoke($2, `\u{a882}`, []), [value("i32", 301)]);

// ./test/core/names.wast:917
assert_return(() => invoke($2, `\u{a8ea}`, []), [value("i32", 302)]);

// ./test/core/names.wast:918
assert_return(() => invoke($2, `\u{a922}`, []), [value("i32", 303)]);

// ./test/core/names.wast:919
assert_return(() => invoke($2, `\u{a946}`, []), [value("i32", 304)]);

// ./test/core/names.wast:920
assert_return(() => invoke($2, `\u{a984}`, []), [value("i32", 305)]);

// ./test/core/names.wast:921
assert_return(() => invoke($2, `\u{aa00}`, []), [value("i32", 306)]);

// ./test/core/names.wast:922
assert_return(() => invoke($2, `\u{ff71}`, []), [value("i32", 307)]);

// ./test/core/names.wast:923
assert_return(() => invoke($2, `\u{ffc2}`, []), [value("i32", 308)]);

// ./test/core/names.wast:924
assert_return(() => invoke($2, `\u{10000}`, []), [value("i32", 309)]);

// ./test/core/names.wast:925
assert_return(() => invoke($2, `\u{10280}`, []), [value("i32", 310)]);

// ./test/core/names.wast:926
assert_return(() => invoke($2, `\u{102a0}`, []), [value("i32", 311)]);

// ./test/core/names.wast:927
assert_return(() => invoke($2, `\u{10300}`, []), [value("i32", 312)]);

// ./test/core/names.wast:928
assert_return(() => invoke($2, `\u{103a0}`, []), [value("i32", 313)]);

// ./test/core/names.wast:929
assert_return(() => invoke($2, `\u{10496}`, []), [value("i32", 314)]);

// ./test/core/names.wast:930
assert_return(() => invoke($2, `\u{10500}`, []), [value("i32", 315)]);

// ./test/core/names.wast:931
assert_return(() => invoke($2, `\u{10740}`, []), [value("i32", 316)]);

// ./test/core/names.wast:932
assert_return(() => invoke($2, `\u{10800}`, []), [value("i32", 317)]);

// ./test/core/names.wast:933
assert_return(() => invoke($2, `\u{10920}`, []), [value("i32", 318)]);

// ./test/core/names.wast:934
assert_return(() => invoke($2, `\u{10980}`, []), [value("i32", 319)]);

// ./test/core/names.wast:935
assert_return(() => invoke($2, `\u{109a0}`, []), [value("i32", 320)]);

// ./test/core/names.wast:936
assert_return(() => invoke($2, `\u{10a00}`, []), [value("i32", 321)]);

// ./test/core/names.wast:937
assert_return(() => invoke($2, `\u{10b00}`, []), [value("i32", 322)]);

// ./test/core/names.wast:938
assert_return(() => invoke($2, `\u{10c00}`, []), [value("i32", 323)]);

// ./test/core/names.wast:939
assert_return(() => invoke($2, `\u{10c01}`, []), [value("i32", 324)]);

// ./test/core/names.wast:940
assert_return(() => invoke($2, `\u{10c80}`, []), [value("i32", 325)]);

// ./test/core/names.wast:941
assert_return(() => invoke($2, `\u{11005}`, []), [value("i32", 326)]);

// ./test/core/names.wast:942
assert_return(() => invoke($2, `\u{11083}`, []), [value("i32", 327)]);

// ./test/core/names.wast:943
assert_return(() => invoke($2, `\u{11127}`, []), [value("i32", 328)]);

// ./test/core/names.wast:944
assert_return(() => invoke($2, `\u{11150}`, []), [value("i32", 329)]);

// ./test/core/names.wast:945
assert_return(() => invoke($2, `\u{11183}`, []), [value("i32", 330)]);

// ./test/core/names.wast:946
assert_return(() => invoke($2, `\u{11200}`, []), [value("i32", 331)]);

// ./test/core/names.wast:947
assert_return(() => invoke($2, `\u{11280}`, []), [value("i32", 332)]);

// ./test/core/names.wast:948
assert_return(() => invoke($2, `\u{112b0}`, []), [value("i32", 333)]);

// ./test/core/names.wast:949
assert_return(() => invoke($2, `\u{11305}`, []), [value("i32", 334)]);

// ./test/core/names.wast:950
assert_return(() => invoke($2, `\u{11370}`, []), [value("i32", 335)]);

// ./test/core/names.wast:951
assert_return(() => invoke($2, `\u{11400}`, []), [value("i32", 336)]);

// ./test/core/names.wast:952
assert_return(() => invoke($2, `\u{11481}`, []), [value("i32", 337)]);

// ./test/core/names.wast:953
assert_return(() => invoke($2, `\u{11580}`, []), [value("i32", 338)]);

// ./test/core/names.wast:954
assert_return(() => invoke($2, `\u{11600}`, []), [value("i32", 339)]);

// ./test/core/names.wast:955
assert_return(() => invoke($2, `\u{11680}`, []), [value("i32", 340)]);

// ./test/core/names.wast:956
assert_return(() => invoke($2, `\u{11712}`, []), [value("i32", 341)]);

// ./test/core/names.wast:957
assert_return(() => invoke($2, `\u{11720}`, []), [value("i32", 342)]);

// ./test/core/names.wast:958
assert_return(() => invoke($2, `\u{118a1}`, []), [value("i32", 343)]);

// ./test/core/names.wast:959
assert_return(() => invoke($2, `\u{11ad5}`, []), [value("i32", 344)]);

// ./test/core/names.wast:960
assert_return(() => invoke($2, `\u{11c00}`, []), [value("i32", 345)]);

// ./test/core/names.wast:961
assert_return(() => invoke($2, `\u{11c8f}`, []), [value("i32", 346)]);

// ./test/core/names.wast:962
assert_return(() => invoke($2, `\u{11caf}`, []), [value("i32", 347)]);

// ./test/core/names.wast:963
assert_return(() => invoke($2, `\u{12000}`, []), [value("i32", 348)]);

// ./test/core/names.wast:964
assert_return(() => invoke($2, `\u{169d5}`, []), [value("i32", 349)]);

// ./test/core/names.wast:965
assert_return(() => invoke($2, `\u{16a46}`, []), [value("i32", 350)]);

// ./test/core/names.wast:966
assert_return(() => invoke($2, `\u{16ae7}`, []), [value("i32", 351)]);

// ./test/core/names.wast:967
assert_return(() => invoke($2, `\u{16f54}`, []), [value("i32", 352)]);

// ./test/core/names.wast:968
assert_return(() => invoke($2, `\u{1bc41}`, []), [value("i32", 353)]);

// ./test/core/names.wast:969
assert_return(() => invoke($2, `\u{1bc64}`, []), [value("i32", 354)]);

// ./test/core/names.wast:970
assert_return(() => invoke($2, `\u{1e823}`, []), [value("i32", 355)]);

// ./test/core/names.wast:971
assert_return(() => invoke($2, `\u{1f1e6}`, []), [value("i32", 356)]);

// ./test/core/names.wast:972
assert_return(() => invoke($2, `\u{2c6d}`, []), [value("i32", 357)]);

// ./test/core/names.wast:973
assert_return(() => invoke($2, `\u{39b}`, []), [value("i32", 358)]);

// ./test/core/names.wast:974
assert_return(() => invoke($2, `\u{2c70}`, []), [value("i32", 359)]);

// ./test/core/names.wast:975
assert_return(() => invoke($2, `\u{aa}`, []), [value("i32", 360)]);

// ./test/core/names.wast:976
assert_return(() => invoke($2, `\u{2200}`, []), [value("i32", 361)]);

// ./test/core/names.wast:977
assert_return(() => invoke($2, `\u{20b3}`, []), [value("i32", 362)]);

// ./test/core/names.wast:978
assert_return(() => invoke($2, `\u{10900}`, []), [value("i32", 363)]);

// ./test/core/names.wast:979
assert_return(() => invoke($2, `\u{2c80}`, []), [value("i32", 364)]);

// ./test/core/names.wast:980
assert_return(() => invoke($2, `\u{10330}`, []), [value("i32", 365)]);

// ./test/core/names.wast:981
assert_return(() => invoke($2, `\u{386}`, []), [value("i32", 366)]);

// ./test/core/names.wast:982
assert_return(() => invoke($2, `\u{391}`, []), [value("i32", 367)]);

// ./test/core/names.wast:983
assert_return(() => invoke($2, `\u{1f08}`, []), [value("i32", 368)]);

// ./test/core/names.wast:984
assert_return(() => invoke($2, `\u{1f09}`, []), [value("i32", 369)]);

// ./test/core/names.wast:985
assert_return(() => invoke($2, `\u{1f0a}`, []), [value("i32", 370)]);

// ./test/core/names.wast:986
assert_return(() => invoke($2, `\u{1f0b}`, []), [value("i32", 371)]);

// ./test/core/names.wast:987
assert_return(() => invoke($2, `\u{1f0c}`, []), [value("i32", 372)]);

// ./test/core/names.wast:988
assert_return(() => invoke($2, `\u{1f0d}`, []), [value("i32", 373)]);

// ./test/core/names.wast:989
assert_return(() => invoke($2, `\u{1f0e}`, []), [value("i32", 374)]);

// ./test/core/names.wast:990
assert_return(() => invoke($2, `\u{1f0f}`, []), [value("i32", 375)]);

// ./test/core/names.wast:991
assert_return(() => invoke($2, `\u{1f88}`, []), [value("i32", 376)]);

// ./test/core/names.wast:992
assert_return(() => invoke($2, `\u{1f89}`, []), [value("i32", 377)]);

// ./test/core/names.wast:993
assert_return(() => invoke($2, `\u{1f8a}`, []), [value("i32", 378)]);

// ./test/core/names.wast:994
assert_return(() => invoke($2, `\u{1f8b}`, []), [value("i32", 379)]);

// ./test/core/names.wast:995
assert_return(() => invoke($2, `\u{1f8c}`, []), [value("i32", 380)]);

// ./test/core/names.wast:996
assert_return(() => invoke($2, `\u{1f8d}`, []), [value("i32", 381)]);

// ./test/core/names.wast:997
assert_return(() => invoke($2, `\u{1f8e}`, []), [value("i32", 382)]);

// ./test/core/names.wast:998
assert_return(() => invoke($2, `\u{1f8f}`, []), [value("i32", 383)]);

// ./test/core/names.wast:999
assert_return(() => invoke($2, `\u{1fb8}`, []), [value("i32", 384)]);

// ./test/core/names.wast:1000
assert_return(() => invoke($2, `\u{1fb9}`, []), [value("i32", 385)]);

// ./test/core/names.wast:1001
assert_return(() => invoke($2, `\u{1fba}`, []), [value("i32", 386)]);

// ./test/core/names.wast:1002
assert_return(() => invoke($2, `\u{1fbb}`, []), [value("i32", 387)]);

// ./test/core/names.wast:1003
assert_return(() => invoke($2, `\u{1fbc}`, []), [value("i32", 388)]);

// ./test/core/names.wast:1004
assert_return(() => invoke($2, `\u{1d6a8}`, []), [value("i32", 389)]);

// ./test/core/names.wast:1005
assert_return(() => invoke($2, `\u{1d6e2}`, []), [value("i32", 390)]);

// ./test/core/names.wast:1006
assert_return(() => invoke($2, `\u{1d71c}`, []), [value("i32", 391)]);

// ./test/core/names.wast:1007
assert_return(() => invoke($2, `\u{1d756}`, []), [value("i32", 392)]);

// ./test/core/names.wast:1008
assert_return(() => invoke($2, `\u{1d790}`, []), [value("i32", 393)]);

// ./test/core/names.wast:1009
assert_return(() => invoke($2, `\u{2376}`, []), [value("i32", 394)]);

// ./test/core/names.wast:1010
assert_return(() => invoke($2, `\u{237a}`, []), [value("i32", 395)]);

// ./test/core/names.wast:1011
assert_return(() => invoke($2, `\u{2a5c}`, []), [value("i32", 396)]);

// ./test/core/names.wast:1012
assert_return(() => invoke($2, `\u{15c5}`, []), [value("i32", 397)]);

// ./test/core/names.wast:1013
assert_return(() => invoke($2, `\u{13aa}`, []), [value("i32", 398)]);

// ./test/core/names.wast:1014
assert_return(
  () => invoke($2,
    `)\u{2fa}\u{2fc}\u{145cf}\u{1d174}\u{1d176}\u{1d178}\u{1d17a}\u{207e}\u{208e}\u{2769}\u{276b}\u{27ef}\u{fd3f}\u{fe36}\u{fe5a}\u{ff09}\u{ff60}\u{e0029}\u{2773}\u{2775}\u{27e7}\u{27e9}\u{27eb}\u{27ed}\u{2988}\u{298a}\u{2996}\u{2e23}\u{2e25}\u{fe18}\u{fe38}\u{fe3a}\u{fe3c}\u{fe3e}\u{fe40}\u{fe42}\u{fe44}\u{fe48}\u{fe5c}\u{fe5e}\u{ff3d}\u{ff5d}\u{ff63}\u{e005d}\u{e007d}\u{bb}\u{2019}\u{201d}\u{203a}\u{276f}`,
    [],
  ),
  [value("i32", 399)],
);

// ./test/core/names.wast:1015
assert_return(
  () => invoke($2,
    `(\u{2f9}\u{2fb}\u{145ce}\u{1d173}\u{1d175}\u{1d177}\u{1d179}\u{207d}\u{208d}\u{2768}\u{276a}\u{27ee}\u{fd3e}\u{fe35}\u{fe59}\u{ff08}\u{ff5f}\u{e0028}\u{2772}\u{2774}\u{27e6}\u{27e8}\u{27ea}\u{27ec}\u{2987}\u{2989}\u{2995}\u{2e22}\u{2e24}\u{fe17}\u{fe37}\u{fe39}\u{fe3b}\u{fe3d}\u{fe3f}\u{fe41}\u{fe43}\u{fe47}\u{fe5b}\u{fe5d}\u{ff3b}\u{ff5b}\u{ff62}\u{e005b}\u{e007b}\u{ab}\u{2018}\u{201c}\u{2039}\u{276e}`,
    [],
  ),
  [value("i32", 400)],
);

// ./test/core/names.wast:1016
assert_return(() => invoke($2, `\u{1da8b}\u{1daa4}`, []), [value("i32", 401)]);

// ./test/core/names.wast:1017
assert_return(() => invoke($2, `\u{1da8b}`, []), [value("i32", 402)]);

// ./test/core/names.wast:1018
assert_return(() => invoke($2, `\u{bd}`, []), [value("i32", 403)]);

// ./test/core/names.wast:1019
assert_return(() => invoke($2, `1\u{2044}2`, []), [value("i32", 404)]);

// ./test/core/names.wast:1020
assert_return(() => invoke($2, `1/2`, []), [value("i32", 405)]);

// ./test/core/names.wast:1021
assert_return(() => invoke($2, `\u{b73}`, []), [value("i32", 406)]);

// ./test/core/names.wast:1022
assert_return(() => invoke($2, `\u{d74}`, []), [value("i32", 407)]);

// ./test/core/names.wast:1023
assert_return(() => invoke($2, `\u{2cfd}`, []), [value("i32", 408)]);

// ./test/core/names.wast:1024
assert_return(() => invoke($2, `\u{a831}`, []), [value("i32", 409)]);

// ./test/core/names.wast:1025
assert_return(() => invoke($2, `\u{10141}`, []), [value("i32", 410)]);

// ./test/core/names.wast:1026
assert_return(() => invoke($2, `\u{10175}`, []), [value("i32", 411)]);

// ./test/core/names.wast:1027
assert_return(() => invoke($2, `\u{10176}`, []), [value("i32", 412)]);

// ./test/core/names.wast:1028
assert_return(() => invoke($2, `\u{109bd}`, []), [value("i32", 413)]);

// ./test/core/names.wast:1029
assert_return(() => invoke($2, `\u{10e7b}`, []), [value("i32", 414)]);

// ./test/core/names.wast:1030
assert_return(() => invoke($2, `\u{ff02}`, []), [value("i32", 415)]);

// ./test/core/names.wast:1031
assert_return(() => invoke($2, `\x7f`, []), [value("i32", 416)]);

// ./test/core/names.wast:1032
assert_return(() => invoke($2, `\x08`, []), [value("i32", 417)]);

// ./test/core/names.wast:1033
assert_return(() => invoke($2, `\u{232b}`, []), [value("i32", 418)]);

// ./test/core/names.wast:1034
assert_return(() => invoke($2, `\u{2326}`, []), [value("i32", 419)]);

// ./test/core/names.wast:1035
assert_return(() => invoke($2, `\u{2408}`, []), [value("i32", 420)]);

// ./test/core/names.wast:1036
assert_return(() => invoke($2, `\u{2421}`, []), [value("i32", 421)]);

// ./test/core/names.wast:1037
assert_return(() => invoke($2, `\u{1dfb}`, []), [value("i32", 422)]);

// ./test/core/names.wast:1038
assert_return(() => invoke($2, `\x0f`, []), [value("i32", 423)]);

// ./test/core/names.wast:1039
assert_return(() => invoke($2, `\u{2190}`, []), [value("i32", 424)]);

// ./test/core/names.wast:1040
assert_return(() => invoke($2, `\u{2327}`, []), [value("i32", 425)]);

// ./test/core/names.wast:1041
assert_return(() => invoke($2, `\u{2352}`, []), [value("i32", 426)]);

// ./test/core/names.wast:1042
assert_return(() => invoke($2, `\u{2354}`, []), [value("i32", 427)]);

// ./test/core/names.wast:1043
assert_return(() => invoke($2, `\u{2362}`, []), [value("i32", 428)]);

// ./test/core/names.wast:1044
assert_return(() => invoke($2, `\u{236b}`, []), [value("i32", 429)]);

// ./test/core/names.wast:1045
assert_return(() => invoke($2, `\x1a`, []), [value("i32", 430)]);

// ./test/core/names.wast:1046
assert_return(() => invoke($2, `\u{2426}`, []), [value("i32", 431)]);

// ./test/core/names.wast:1047
assert_return(() => invoke($2, `\u{241a}`, []), [value("i32", 432)]);

// ./test/core/names.wast:1048
assert_return(() => invoke($2, `\u{fffc}`, []), [value("i32", 433)]);

// ./test/core/names.wast:1049
assert_return(() => invoke($2, `?`, []), [value("i32", 434)]);

// ./test/core/names.wast:1050
assert_return(() => invoke($2, `\u{bf}`, []), [value("i32", 435)]);

// ./test/core/names.wast:1051
assert_return(() => invoke($2, `\u{1945}`, []), [value("i32", 436)]);

// ./test/core/names.wast:1052
assert_return(() => invoke($2, `\u{37e}`, []), [value("i32", 437)]);

// ./test/core/names.wast:1053
assert_return(() => invoke($2, `\u{55e}`, []), [value("i32", 438)]);

// ./test/core/names.wast:1054
assert_return(() => invoke($2, `\u{61f}`, []), [value("i32", 439)]);

// ./test/core/names.wast:1055
assert_return(() => invoke($2, `\u{1367}`, []), [value("i32", 440)]);

// ./test/core/names.wast:1056
assert_return(() => invoke($2, `\u{2047}`, []), [value("i32", 441)]);

// ./test/core/names.wast:1057
assert_return(() => invoke($2, `\u{2370}`, []), [value("i32", 442)]);

// ./test/core/names.wast:1058
assert_return(() => invoke($2, `\u{2753}`, []), [value("i32", 443)]);

// ./test/core/names.wast:1059
assert_return(() => invoke($2, `\u{2754}`, []), [value("i32", 444)]);

// ./test/core/names.wast:1060
assert_return(() => invoke($2, `\u{2cfa}`, []), [value("i32", 445)]);

// ./test/core/names.wast:1061
assert_return(() => invoke($2, `\u{2cfb}`, []), [value("i32", 446)]);

// ./test/core/names.wast:1062
assert_return(() => invoke($2, `\u{2e2e}`, []), [value("i32", 447)]);

// ./test/core/names.wast:1063
assert_return(() => invoke($2, `\u{3244}`, []), [value("i32", 448)]);

// ./test/core/names.wast:1064
assert_return(() => invoke($2, `\u{a60f}`, []), [value("i32", 449)]);

// ./test/core/names.wast:1065
assert_return(() => invoke($2, `\u{a6f7}`, []), [value("i32", 450)]);

// ./test/core/names.wast:1066
assert_return(() => invoke($2, `\u{fe16}`, []), [value("i32", 451)]);

// ./test/core/names.wast:1067
assert_return(() => invoke($2, `\u{fe56}`, []), [value("i32", 452)]);

// ./test/core/names.wast:1068
assert_return(() => invoke($2, `\u{ff1f}`, []), [value("i32", 453)]);

// ./test/core/names.wast:1069
assert_return(() => invoke($2, `\u{11143}`, []), [value("i32", 454)]);

// ./test/core/names.wast:1070
assert_return(() => invoke($2, `\u{1e95f}`, []), [value("i32", 455)]);

// ./test/core/names.wast:1071
assert_return(() => invoke($2, `\u{e003f}`, []), [value("i32", 456)]);

// ./test/core/names.wast:1072
assert_return(() => invoke($2, `\u{16844}`, []), [value("i32", 457)]);

// ./test/core/names.wast:1073
assert_return(() => invoke($2, `\u{2bd1}`, []), [value("i32", 458)]);

// ./test/core/names.wast:1074
assert_return(() => invoke($2, `\u{b6}`, []), [value("i32", 459)]);

// ./test/core/names.wast:1075
assert_return(() => invoke($2, `\u{204b}`, []), [value("i32", 460)]);

// ./test/core/names.wast:1076
assert_return(() => invoke($2, `\u{700}`, []), [value("i32", 461)]);

// ./test/core/names.wast:1077
assert_return(() => invoke($2, `\u{10fb}`, []), [value("i32", 462)]);

// ./test/core/names.wast:1078
assert_return(() => invoke($2, `\u{1368}`, []), [value("i32", 463)]);

// ./test/core/names.wast:1079
assert_return(() => invoke($2, `\u{3037}`, []), [value("i32", 464)]);

// ./test/core/names.wast:1080
assert_return(() => invoke($2, `\u{2761}`, []), [value("i32", 465)]);

// ./test/core/names.wast:1081
assert_return(() => invoke($2, `\u{2e0f}`, []), [value("i32", 466)]);

// ./test/core/names.wast:1082
assert_return(() => invoke($2, `\u{2e10}`, []), [value("i32", 467)]);

// ./test/core/names.wast:1083
assert_return(() => invoke($2, `\u{2e11}`, []), [value("i32", 468)]);

// ./test/core/names.wast:1084
assert_return(() => invoke($2, `\u{2e0e}`, []), [value("i32", 469)]);

// ./test/core/names.wast:1085
assert_return(() => invoke($2, `\x14`, []), [value("i32", 470)]);

// ./test/core/names.wast:1086
assert_return(() => invoke($2, `\u{2619}`, []), [value("i32", 471)]);

// ./test/core/names.wast:1087
assert_return(() => invoke($2, `\u{2e3f}`, []), [value("i32", 472)]);

// ./test/core/names.wast:1088
assert_return(() => invoke($2, `\u{3007}`, []), [value("i32", 473)]);

// ./test/core/names.wast:1089
assert_return(() => invoke($2, `\u{e5b}`, []), [value("i32", 474)]);

// ./test/core/names.wast:1090
assert_return(() => invoke($2, `\u{a66e}`, []), [value("i32", 475)]);

// ./test/core/names.wast:1091
assert_return(() => invoke($2, `\u{3d3}`, []), [value("i32", 476)]);

// ./test/core/names.wast:1092
assert_return(() => invoke($2, `\u{3d4}`, []), [value("i32", 477)]);

// ./test/core/names.wast:1093
assert_return(() => invoke($2, `\u{1e9b}`, []), [value("i32", 478)]);

// ./test/core/names.wast:1095
let $3 = instantiate(`(module
  ;; Test that we can use indices instead of names to reference imports,
  ;; exports, functions and parameters.
  (import "spectest" "print_i32" (func (param i32)))
  (func (import "spectest" "print_i32") (param i32))
  (func (param i32) (param i32)
    (call 0 (local.get 0))
    (call 1 (local.get 1))
  )
  (export "print32" (func 2))
)`);

// ./test/core/names.wast:1107
assert_return(() => invoke($3, `print32`, [42, 123]), []);