add id parsing

src/Language/Wasm/Lexer.x

@@ -1,12 +1,14 @@
 {
-module Language.Wasm.Lexer ( 
+module Language.Wasm.Lexer (
-    scan,
+    Lexeme(..),
-    alexScan
+    Token(..),
+    scanner
 ) where
 
 import qualified Data.ByteString.Lazy as LBS
 import qualified Data.Char as Char
 import qualified Data.ByteString.Lazy.UTF8 as LBSUtf8
+import Control.Applicative ((<$>))
 
 }
 
@@ -22,28 +24,31 @@ $idchar    = [$digit $alpha $namepunct]
 $space     = [\  \x09 \x0A \x0D]
 $linechar  = [^ \x09]
 $sign      = [\+ \-]
+$doublequote = \"
 
 @keyword     = $lower $idchar*
 @reserved    = $idchar+
 @linecomment = ";;" $linechar* \x0A
 @startblockcomment = "(;"
-@endblockcomment = "(;"
+@endblockcomment = ";)"
 @num = $digit (\_? $digit*)
 @hexnum = $hexdigit (\_? $hexdigit*)
+@id = "$" $idchar+
 
 tokens :-
 
 <0> $space                                ;
 <0> @keyword                              { tokenStr TKeyword }
 <0> @linecomment                          ;
+<0> @id                                   { tokenStr TId }
 <0> "("                                   { constToken TOpenBracket }
-<0> "("                                   { constToken TCloseBracket }
+<0> ")"                                   { constToken TCloseBracket }
 <0> $sign? @num                           { parseDecimalSignedInt }
 <0> $sign? "0x" @hexnum                   { parseHexalSignedInt }
 <0, blockComment> @startblockcomment      { startBlockComment }
 <blockComment> [.\n]                      ;
 <blockComment> @endblockcomment           { endBlockComment }
-<0> \"                                    { startStringLiteral }
+<0> $doublequote                          { startStringLiteral }
 <stringLiteral> \\ $hexdigit $hexdigit    { appendDoubleHexChar }
 <stringLiteral> \\t                       { appendCharToStringLiteral '\x09' }
 <stringLiteral> \\n                       { appendCharToStringLiteral '\x0A' }
@@ -52,8 +57,8 @@ tokens :-
 <stringLiteral> \\\'                      { appendCharToStringLiteral '\x27' }
 <stringLiteral> \\\\                      { appendCharToStringLiteral '\x5C' }
 <stringLiteral> \\n\{ @hexnum \}          { appendHexEscapedChar }
+<stringLiteral> $doublequote              { endStringLiteral }
 <stringLiteral> . / {isAllowedStringChar} { appendFromHead }
-<stringLiteral> \"                        { endStringLiteral }
 <0> @reserved                             { tokenStr TReserved }
 
 {
@@ -65,7 +70,7 @@ defaultStartCode = 0
 
 -- inner string literal character predicate
 isAllowedStringChar :: user -> AlexInput -> Int -> AlexInput -> Bool
-isAllowedStringChar _userState _prevInp _len (_pos, _rest, inp, _) =
+isAllowedStringChar _userState (_pos, _rest, inp, _) _len _nextInp =
     let Just (char, _) = LBSUtf8.decode inp in
     let code = Char.ord char in
     code >= 0x20 && code /= 0x7f && char /= '"' && char /= '\\'
@@ -150,7 +155,7 @@ endStringLiteral :: AlexAction Lexeme
 endStringLiteral (pos, _, _inp, _) _len = do
     alexSetStartCode defaultStartCode
     setLexerStringFlag False
-    str <- getLexerStringValue
+    str <- LBSUtf8.fromString . reverse <$> getLexerStringValue
     return $ Lexeme pos $ TStringLit str
 
 tokenStr :: (LBS.ByteString -> Token) -> AlexAction Lexeme
@@ -176,7 +181,7 @@ data Lexeme = Lexeme { pos :: AlexPosn, tok :: Token } deriving (Show, Eq)
 
 data AlexUserState = AlexUserState {
         lexerCommentDepth :: Int,
-        lexerStringValue  :: LBS.ByteString,
+        lexerStringValue  :: String,
         lexerIsString     :: Bool
     }
 
@@ -184,7 +189,7 @@ alexInitUserState :: AlexUserState
 alexInitUserState = AlexUserState {
         lexerCommentDepth  = 0,
         lexerIsString      = False,
-        lexerStringValue   = LBS.empty
+        lexerStringValue   = []
     }
 
 getLexerCommentDepth :: Alex Int
@@ -202,19 +207,19 @@ setLexerStringFlag :: Bool -> Alex ()
 setLexerStringFlag isString = Alex $ \s ->
     Right (s{ alex_ust=(alex_ust s){ lexerIsString = isString } }, ())
 
-getLexerStringValue :: Alex LBS.ByteString
+getLexerStringValue :: Alex String
 getLexerStringValue = Alex $ \s@AlexState{alex_ust=ust} -> Right (s, lexerStringValue ust)
 
-setLexerStringValue :: LBS.ByteString -> Alex ()
+setLexerStringValue :: String -> Alex ()
 setLexerStringValue ss = Alex $ \s ->
     Right (s{ alex_ust=(alex_ust s){ lexerStringValue = ss } }, ())
 
 addCharToLexerStringValue :: Char -> Alex ()
 addCharToLexerStringValue c = Alex $ \s ->
     let ust = alex_ust s in
-    Right (s{ alex_ust = ust{ lexerStringValue = LBS.append (LBSUtf8.fromString [c]) (lexerStringValue ust) } }, ())
+    Right (s{ alex_ust = ust{ lexerStringValue = c : lexerStringValue ust } }, ())
 
-alexEOF = return $ Lexeme undefined EOF
+alexEOF = return $ Lexeme (error "Trying to read EOF position") EOF
 
 readHexFromChar :: Char -> Integer
 readHexFromChar chr =
@@ -257,7 +262,13 @@ readHexFromPrefix = readFromPrefix 16
 readDecFromPrefix :: Int64 -> LBS.ByteString -> Integer
 readDecFromPrefix = readFromPrefix 10
 
-scan :: LBS.ByteString -> [Lexeme]
+scanner :: LBS.ByteString -> Either String [Lexeme]
-scan = undefined
+scanner str = runAlex str loop
-
+    where
+        loop :: Alex [Lexeme]
+        loop = do
+            lex <- alexMonadScan
+            case lex of
+                Lexeme _ EOF -> return [lex]
+                otherwise -> (lex :) <$> loop
 }

tests/Test.hs

@@ -5,7 +5,12 @@ module Main (
 import Test.Tasty
 import Test.Tasty.HUnit
 
-import Language.Wasm (something)
+import qualified Data.ByteString.Lazy as LBS
+
+import qualified Language.Wasm.Lexer as Lexer
 
 main :: IO ()
-main = defaultMain $ testGroup "Test Suite" []
+main = do
+  file <- LBS.readFile "tests/samples/i64.wast"
+  print $ map Lexer.tok <$> Lexer.scanner file
+  defaultMain $ testGroup "Test Suite" []

tests/samples/i64.wast

@@ -0,0 +1,426 @@
+;; i64 operations
+
+(;
+    Multiline comment
+    (; with inner multiline comment ;)
+;)
+
+(module
+  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (get_local $x) (get_local $y)))
+  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (get_local $x) (get_local $y)))
+  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (get_local $x) (get_local $y)))
+  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (get_local $x) (get_local $y)))
+  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (get_local $x) (get_local $y)))
+  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (get_local $x) (get_local $y)))
+  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (get_local $x) (get_local $y)))
+  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (get_local $x) (get_local $y)))
+  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (get_local $x) (get_local $y)))
+  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (get_local $x) (get_local $y)))
+  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (get_local $x) (get_local $y)))
+  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (get_local $x) (get_local $y)))
+  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (get_local $x) (get_local $y)))
+  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (get_local $x) (get_local $y)))
+  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (get_local $x) (get_local $y)))
+  (func (export "clz") (param $x i64) (result i64) (i64.clz (get_local $x)))
+  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (get_local $x)))
+  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (get_local $x)))
+  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (get_local $x)))
+  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (get_local $x) (get_local $y)))
+  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (get_local $x) (get_local $y)))
+  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (get_local $x) (get_local $y)))
+  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (get_local $x) (get_local $y)))
+  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (get_local $x) (get_local $y)))
+  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (get_local $x) (get_local $y)))
+  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (get_local $x) (get_local $y)))
+  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (get_local $x) (get_local $y)))
+  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (get_local $x) (get_local $y)))
+  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (get_local $x) (get_local $y)))
+)
+
+(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
+(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
+
+(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
+
+(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
+(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
+(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
+(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
+(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
+(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
+(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
+(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
+(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
+(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d))
+(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1))
+
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567))
+(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2))
+(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+
+(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
+(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
+(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
+(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
+(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
+(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
+(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
+(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
+(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
+(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
+(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
+(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63))
+(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
+
+(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
+
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))